rxml.rs

use rxml;
use rxml::EventRead;

const CDATA: &'static [u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

#[derive(Clone, Copy)]
enum State {
	Header,
	Body(usize),
	Footer,
	Eof,
}

struct ChunkGenerator{
	state: State,
	chunks: usize,
}

impl ChunkGenerator {
	fn gen_header(&self) -> Vec<u8> {
		b"<?xml version='1.0'?><stream>".to_vec()
	}

	fn gen_body(&self) -> Vec<u8> {
		let mut result: Vec<u8> = Vec::new();
		result.reserve((1024+3+4) * 32);
		result.extend_from_slice(b"<a>");
		result.extend_from_slice(CDATA);
		result.extend_from_slice(b"</a>");
		result
	}

	fn gen_footer(&self) -> Vec<u8> {
		b"</stream>".to_vec()
	}
}

impl Iterator for ChunkGenerator {
	type Item = Vec<u8>;

	fn next(&mut self) -> Option<Vec<u8>> {
		match self.state {
			State::Header => {
				self.state = State::Body(0);
				Some(self.gen_header())
			},
			State::Body(n) if n == self.chunks => {
				self.state = State::Footer;
				Some(self.gen_body())
			},
			State::Body(n) => {
				self.state = State::Body(n+1);
				Some(self.gen_body())
			},
			State::Footer => {
				self.state = State::Eof;
				Some(self.gen_footer())
			},
			State::Eof => {
				None
			}
		}
	}
}

fn get_rss() -> usize {
	let data = std::fs::read_to_string("/proc/self/statm").unwrap();
	let values: Vec<&str> = data.split(" ").collect();
	let rss_str = values[1];
	let rss = usize::from_str_radix(rss_str, 10).unwrap();
	rss * 4096
}

fn main() {
	let mut iter = ChunkGenerator{state: State::Header, chunks: 262144};
	let mut fp = rxml::FeedParser::new();
	let mut ctr = 0usize;
	let mut last_checkpoint = 0usize;
	let checkpoint_mask = 0xfffffusize;
	for chunk in iter {
		ctr = ctr.checked_add(chunk.len()).unwrap();
		if ctr & !checkpoint_mask != last_checkpoint {
			println!("{} {}", ctr, get_rss());
			last_checkpoint = ctr & !checkpoint_mask;
		}
		fp.feed(chunk);
		rxml::as_eof_flag(fp.read_all(|ev| { })).unwrap();
	}
}

stanza_overhead.rs

extern crate rprosody;

use rprosody::stanza;

fn get_rss() -> usize {
	let data = std::fs::read_to_string("/proc/self/statm").unwrap();
	let values: Vec<&str> = data.split(" ").collect();
	let rss_str = values[1];
	let rss = usize::from_str_radix(rss_str, 10).unwrap();
	rss * 4096
}

const CDATA: &'static str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

fn main() {
	let init_rss = get_rss();
	let mut st = rprosody::stanza::Stanza::new("root".to_string(), None);
	for i in 0..262144 {
		let child = st.tag("a".to_string(), None).unwrap();
		// child.borrow_mut().text(CDATA.to_string());
		st.up();
		if i % 1024 == 0 {
			println!("{} {}", (i+1), get_rss() - init_rss);
		}
	}
	println!("{} {}", 262144, get_rss() - init_rss);
}