From aeffb413c47a403b31174f5e634a8bef6ac4d29a Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Sat, 5 Jul 2014 23:44:43 -0700 Subject: [PATCH] experiment with alternative MemWriters test bench_log::bench_copy ... bench: 87 ns/iter (+/- 30) = 7264 MB/s test bench_log::bench_decoder ... bench: 26596 ns/iter (+/- 1725) = 23 MB/s test bench_log::bench_direct_mem_writer ... bench: 2210 ns/iter (+/- 94) = 209 MB/s test bench_log::bench_direct_my_mem_writer ... bench: 1939 ns/iter (+/- 120) = 239 MB/s test bench_log::bench_encoder ... bench: 6988 ns/iter (+/- 488) = 90 MB/s test bench_log::bench_manual_mem_writer_escape ... bench: 2809 ns/iter (+/- 332) = 203 MB/s test bench_log::bench_manual_mem_writer_no_escape ... bench: 1817 ns/iter (+/- 113) = 315 MB/s test bench_log::bench_manual_my_mem_writer2_escape ... bench: 2250 ns/iter (+/- 117) = 254 MB/s test bench_log::bench_manual_my_mem_writer2_no_escape ... bench: 1493 ns/iter (+/- 39) = 383 MB/s test bench_log::bench_manual_my_mem_writer_escape ... bench: 2196 ns/iter (+/- 47) = 260 MB/s test bench_log::bench_manual_my_mem_writer_no_escape ... bench: 1402 ns/iter (+/- 85) = 408 MB/s test bench_log::bench_serializer ... bench: 2357 ns/iter (+/- 176) = 204 MB/s test bench_log::bench_serializer2 ... bench: 2070 ns/iter (+/- 38) = 233 MB/s --- bench_log.rs | 630 ++++++++++++++++++++++++++++++++++++++++++++++----- json.rs | 101 +++++---- 2 files changed, 630 insertions(+), 101 deletions(-) diff --git a/bench_log.rs b/bench_log.rs index 4918ef23..a3ced671 100644 --- a/bench_log.rs +++ b/bench_log.rs @@ -4,6 +4,7 @@ extern crate serialize; extern crate test; extern crate time; +use std::io; use std::io::MemWriter; use test::Bencher; @@ -417,6 +418,188 @@ struct Log { ray_id: String, } +struct MyMemWriter { + buf: Vec, +} + +impl MyMemWriter { + pub fn new() -> MyMemWriter { + MyMemWriter::with_capacity(128) + } + + pub fn with_capacity(cap: uint) -> MyMemWriter { + MyMemWriter { + buf: Vec::with_capacity(cap) + } + } + + #[inline] + pub fn unwrap(self) -> Vec { self.buf } +} + + +impl Writer for MyMemWriter { + #[inline] + fn write(&mut self, buf: &[u8]) -> io::IoResult<()> { + //self.buf.push_all(buf); + + unsafe { + let self_buf_len = self.buf.len(); + let buf_len = buf.len(); + + self.buf.reserve_additional(buf_len); + self.buf.set_len(self_buf_len + buf_len); + ::std::ptr::copy_nonoverlapping_memory( + self.buf.as_mut_ptr().offset(self_buf_len as int), + buf.as_ptr(), + buf_len); + } + Ok(()) + } +} + +pub struct MyMemWriter2 { + buf: Vec, + pos: uint, +} + +impl MyMemWriter2 { + /// Create a new `MemWriter`. + #[inline] + pub fn new() -> MyMemWriter2 { + MyMemWriter2::with_capacity(128) + } + /// Create a new `MemWriter`, allocating at least `n` bytes for + /// the internal buffer. + #[inline] + pub fn with_capacity(n: uint) -> MyMemWriter2 { + MyMemWriter2 { buf: Vec::with_capacity(n), pos: 0 } + } + + /// Acquires an immutable reference to the underlying buffer of this + /// `MemWriter`. + /// + /// No method is exposed for acquiring a mutable reference to the buffer + /// because it could corrupt the state of this `MemWriter`. + #[inline] + pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() } + + /// Unwraps this `MemWriter`, returning the underlying buffer + #[inline] + pub fn unwrap(self) -> Vec { self.buf } +} + +macro_rules! likely( + ($val:expr) => { + { + extern { + #[link_name = "llvm.expect.i8"] + fn expect(val: u8, expected_val: u8) -> u8; + } + let x: bool = $val; + unsafe { expect(x as u8, 1) != 0 } + } + } +) + +macro_rules! unlikely( + ($val:expr) => { + { + extern { + #[link_name = "llvm.expect.i8"] + fn expect(val: u8, expected_val: u8) -> u8; + } + let x: bool = $val; + unsafe { expect(x as u8, 0) != 0 } + } + } +) + +impl Writer for MyMemWriter2 { + #[inline] + fn write(&mut self, buf: &[u8]) -> io::IoResult<()> { + if self.pos == self.buf.len() { + //if likely!(self.pos == self.buf.len()) { + // Hot path. + //self.buf.push_all(buf) + unsafe { + let self_buf_len = self.buf.len(); + let buf_len = buf.len(); + + self.buf.reserve_additional(buf_len); + self.buf.set_len(self_buf_len + buf_len); + ::std::ptr::copy_nonoverlapping_memory( + self.buf.as_mut_ptr().offset(self_buf_len as int), + buf.as_ptr(), + buf_len); + + //::std::slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left); + } + } else { + fail!(); + + // Make sure the internal buffer is as least as big as where we + // currently are + let difference = self.pos as i64 - self.buf.len() as i64; + if difference > 0 { + self.buf.grow(difference as uint, &0); + } + + // Figure out what bytes will be used to overwrite what's currently + // there (left), and what will be appended on the end (right) + let cap = self.buf.len() - self.pos; + let (left, right) = if cap <= buf.len() { + (buf.slice_to(cap), buf.slice_from(cap)) + } else { + (buf, &[]) + }; + + // Do the necessary writes + if left.len() > 0 { + ::std::slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), left); + } + if right.len() > 0 { + self.buf.push_all(right); + } + } + + // Bump us forward + self.pos += buf.len(); + Ok(()) + } +} + +fn combine(seek: io::SeekStyle, cur: uint, end: uint, offset: i64) -> io::IoResult { + // compute offset as signed and clamp to prevent overflow + let pos = match seek { + io::SeekSet => 0, + io::SeekEnd => end, + io::SeekCur => cur, + } as i64; + + if offset + pos < 0 { + Err(io::IoError { + kind: io::InvalidInput, + desc: "invalid seek to a negative offset", + detail: None + }) + } else { + Ok((offset + pos) as u64) + } +} + +impl Seek for MyMemWriter2 { + #[inline] + fn tell(&self) -> io::IoResult { Ok(self.pos as u64) } + + #[inline] + fn seek(&mut self, pos: i64, style: io::SeekStyle) -> io::IoResult<()> { + let new = try!(combine(style, self.pos, self.buf.len(), pos)); + self.pos = new as uint; + Ok(()) + } +} + impl Log { fn new() -> Log { Log { @@ -455,7 +638,7 @@ impl Log { fn bench_encoder(b: &mut Bencher) { let log = Log::new(); let json = serialize::json::encode(&log); - let _len = json.len(); + b.bytes = json.len() as u64; b.iter(|| { let _ = serialize::json::encode(&log); @@ -465,10 +648,29 @@ fn bench_encoder(b: &mut Bencher) { #[bench] fn bench_serializer(b: &mut Bencher) { let log = Log::new(); - let _json = json::to_str(&log).unwrap(); + let json = json::to_vec(&log); + b.bytes = json.len() as u64; b.iter(|| { - let _json = json::to_str(&log).unwrap(); + //let _json = json::to_str(&log).unwrap(); + let _json = json::to_vec(&log); + }); +} + +#[bench] +fn bench_serializer2(b: &mut Bencher) { + let log = Log::new(); + let json = json::to_vec(&log); + b.bytes = json.len() as u64; + + b.iter(|| { + //let _json = json::to_str(&log).unwrap(); + let mut wr = MyMemWriter::with_capacity(1024); + { + let mut serializer = json::Serializer::new(wr.by_ref()); + log.serialize(&mut serializer).unwrap(); + } + let _json = wr.unwrap(); }); } @@ -476,70 +678,371 @@ fn bench_serializer(b: &mut Bencher) { fn bench_copy(b: &mut Bencher) { let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + let json = Vec::from_slice(s.as_bytes()); + b.bytes = json.len() as u64; + b.iter(|| { - let _json = s.to_str(); + let _json = Vec::from_slice(s.as_bytes()); + }); +} + +fn manual_no_escape(mut wr: W, log: &Log) { + wr.write_str("{\"timestamp\":").unwrap(); + (write!(wr, "{}", log.timestamp)).unwrap(); + wr.write_str(",\"zone_id\":").unwrap(); + (write!(wr, "{}", log.zone_id)).unwrap(); + wr.write_str(",\"zone_plan\":").unwrap(); + (write!(wr, "{}", log.zone_plan as int)).unwrap(); + + wr.write_str(",\"http\":{\"protocol\":").unwrap(); + (write!(wr, "{}", log.http.protocol as uint)).unwrap(); + wr.write_str(",\"status\":").unwrap(); + (write!(wr, "{}", log.http.status)).unwrap(); + wr.write_str(",\"host_status\":").unwrap(); + (write!(wr, "{}", log.http.host_status)).unwrap(); + wr.write_str(",\"up_status\":").unwrap(); + (write!(wr, "{}", log.http.up_status)).unwrap(); + wr.write_str(",\"method\":").unwrap(); + (write!(wr, "{}", log.http.method as uint)).unwrap(); + wr.write_str(",\"content_type\":").unwrap(); + json::escape_str(&mut wr, log.http.content_type.as_slice()).unwrap(); + wr.write_str(",\"user_agent\":").unwrap(); + json::escape_str(&mut wr, log.http.user_agent.as_slice()).unwrap(); + wr.write_str(",\"referer\":").unwrap(); + json::escape_str(&mut wr, log.http.referer.as_slice()).unwrap(); + wr.write_str(",\"request_uri\":").unwrap(); + json::escape_str(&mut wr, log.http.request_uri.as_slice()).unwrap(); + + wr.write_str("},\"origin\":{\"port\":").unwrap(); + (write!(wr, "{}", log.origin.port)).unwrap(); + wr.write_str(",\"hostname\":").unwrap(); + json::escape_str(&mut wr, log.origin.hostname.as_slice()).unwrap(); + wr.write_str(",\"protocol\":").unwrap(); + (write!(wr, "{}", log.origin.protocol as uint)).unwrap(); + + wr.write_str("},\"country\":").unwrap(); + (write!(wr, "{}", log.country as uint)).unwrap(); + wr.write_str(",\"cache_status\":").unwrap(); + (write!(wr, "{}", log.cache_status as uint)).unwrap(); + wr.write_str(",\"server_ip\":").unwrap(); + json::escape_str(&mut wr, log.server_ip.as_slice()).unwrap(); + wr.write_str(",\"server_name\":").unwrap(); + json::escape_str(&mut wr, log.server_name.as_slice()).unwrap(); + wr.write_str(",\"remote_ip\":").unwrap(); + json::escape_str(&mut wr, log.remote_ip.as_slice()).unwrap(); + wr.write_str(",\"bytes_dlv\":").unwrap(); + (write!(wr, "{}", log.bytes_dlv)).unwrap(); + + wr.write_str(",\"ray_id\":").unwrap(); + json::escape_str(&mut wr, log.ray_id.as_slice()).unwrap(); + wr.write_str("}").unwrap(); +} + +fn manual_escape(mut wr: W, log: &Log) { + wr.write_str("{\"").unwrap(); + json::escape_str(&mut wr, "timestamp").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.timestamp)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "zone_id").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.zone_id)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "zone_plan").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.zone_plan as int)).unwrap(); + + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "http").unwrap(); + wr.write_str("\":{\"").unwrap(); + json::escape_str(&mut wr, "protocol").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.http.protocol as uint)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "status").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.http.status)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "host_status").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.http.host_status)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "up_status").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.http.up_status)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "method").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.http.method as uint)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "content_type").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.http.content_type.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "user_agent").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.http.user_agent.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "referer").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.http.referer.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "request_uri").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.http.request_uri.as_slice()).unwrap(); + + wr.write_str("},\"").unwrap(); + json::escape_str(&mut wr, "origin").unwrap(); + wr.write_str("\":{\"").unwrap(); + json::escape_str(&mut wr, "port").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.origin.port)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "hostname").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.origin.hostname.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "protocol").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.origin.protocol as uint)).unwrap(); + + wr.write_str("},\"").unwrap(); + json::escape_str(&mut wr, "country").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.country as uint)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "cache_status").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.cache_status as uint)).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "server_ip").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.server_ip.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "server_name").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.server_name.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "remote_ip").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.remote_ip.as_slice()).unwrap(); + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "bytes_dlv").unwrap(); + wr.write_str("\":").unwrap(); + (write!(wr, "{}", log.bytes_dlv)).unwrap(); + + wr.write_str(",\"").unwrap(); + json::escape_str(&mut wr, "ray_id").unwrap(); + wr.write_str("\":").unwrap(); + json::escape_str(&mut wr, log.ray_id.as_slice()).unwrap(); + wr.write_str("}").unwrap(); +} + +#[bench] +fn bench_manual_mem_writer_no_escape(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MemWriter::with_capacity(1024); + manual_no_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MemWriter::with_capacity(1024); + manual_no_escape(wr.by_ref(), &log); + + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ }); } #[bench] -fn bench_manual(b: &mut Bencher) { +fn bench_manual_mem_writer_escape(b: &mut Bencher) { let log = Log::new(); let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + let mut wr = MemWriter::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + b.iter(|| { - let mut wr = MemWriter::with_capacity(1000); - wr.write_str("{\"timestamp\":").unwrap(); - (write!(wr, "{}", log.timestamp)).unwrap(); - wr.write_str(",\"zone_id\":").unwrap(); - (write!(wr, "{}", log.zone_id)).unwrap(); - wr.write_str(",\"zone_plan\":").unwrap(); - (write!(wr, "{}", log.zone_plan as int)).unwrap(); - - wr.write_str(",\"http\":{\"protocol\":").unwrap(); - (write!(wr, "{}", log.http.protocol as uint)).unwrap(); - wr.write_str(",\"status\":").unwrap(); - (write!(wr, "{}", log.http.status)).unwrap(); - wr.write_str(",\"host_status\":").unwrap(); - (write!(wr, "{}", log.http.host_status)).unwrap(); - wr.write_str(",\"up_status\":").unwrap(); - (write!(wr, "{}", log.http.up_status)).unwrap(); - wr.write_str(",\"method\":").unwrap(); - (write!(wr, "{}", log.http.method as uint)).unwrap(); - wr.write_str(",\"content_type\":").unwrap(); - json::escape_str(&mut wr, log.http.content_type.as_slice()).unwrap(); - wr.write_str(",\"user_agent\":").unwrap(); - json::escape_str(&mut wr, log.http.user_agent.as_slice()).unwrap(); - wr.write_str(",\"referer\":").unwrap(); - json::escape_str(&mut wr, log.http.referer.as_slice()).unwrap(); - wr.write_str(",\"request_uri\":").unwrap(); - json::escape_str(&mut wr, log.http.request_uri.as_slice()).unwrap(); - - wr.write_str("},\"origin\":{\"port\":").unwrap(); - (write!(wr, "{}", log.origin.port)).unwrap(); - wr.write_str(",\"hostname\":").unwrap(); - json::escape_str(&mut wr, log.origin.hostname.as_slice()).unwrap(); - wr.write_str(",\"protocol\":").unwrap(); - (write!(wr, "{}", log.origin.protocol as uint)).unwrap(); - - wr.write_str("},\"country\":").unwrap(); - (write!(wr, "{}", log.country as uint)).unwrap(); - wr.write_str(",\"cache_status\":").unwrap(); - (write!(wr, "{}", log.cache_status as uint)).unwrap(); - wr.write_str(",\"server_ip\":").unwrap(); - json::escape_str(&mut wr, log.server_ip.as_slice()).unwrap(); - wr.write_str(",\"server_name\":").unwrap(); - json::escape_str(&mut wr, log.server_name.as_slice()).unwrap(); - wr.write_str(",\"remote_ip\":").unwrap(); - json::escape_str(&mut wr, log.remote_ip.as_slice()).unwrap(); - wr.write_str(",\"bytes_dlv\":").unwrap(); - (write!(wr, "{}", log.bytes_dlv)).unwrap(); - - wr.write_str(",\"ray_id\":").unwrap(); - json::escape_str(&mut wr, log.ray_id.as_slice()).unwrap(); - wr.write_str("}").unwrap(); + let mut wr = MemWriter::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + let _json = wr.unwrap(); + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +#[bench] +fn bench_manual_my_mem_writer_no_escape(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MyMemWriter::with_capacity(1000); + manual_no_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MyMemWriter::with_capacity(1024); + manual_no_escape(wr.by_ref(), &log); + + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +#[bench] +fn bench_manual_my_mem_writer_escape(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MemWriter::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MyMemWriter::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +#[bench] +fn bench_manual_my_mem_writer2_no_escape(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MyMemWriter2::with_capacity(1000); + manual_no_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MyMemWriter2::with_capacity(1024); + manual_no_escape(wr.by_ref(), &log); + + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +#[bench] +fn bench_manual_my_mem_writer2_escape(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MyMemWriter2::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MyMemWriter2::with_capacity(1024); + manual_escape(wr.by_ref(), &log); + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +fn direct(mut wr: W, log: &Log) { + use ser::Serializer; + + let mut serializer = json::Serializer::new(wr.by_ref()); + serializer.serialize_struct_start("Log", 12).unwrap(); + + serializer.serialize_struct_sep("timestamp", &log.timestamp).unwrap(); + serializer.serialize_struct_sep("zone_id", &log.zone_id).unwrap(); + serializer.serialize_struct_sep("zone_plan", &(log.zone_plan as uint)).unwrap(); + + serializer.serialize_struct_start("Http", 9).unwrap(); + serializer.serialize_struct_sep("protocol", &(log.http.protocol as uint)).unwrap(); + serializer.serialize_struct_sep("status", &log.http.status).unwrap(); + serializer.serialize_struct_sep("host_status", &log.http.host_status).unwrap(); + serializer.serialize_struct_sep("up_status", &log.http.up_status).unwrap(); + serializer.serialize_struct_sep("method", &(log.http.method as uint)).unwrap(); + serializer.serialize_struct_sep("content_type", &log.http.content_type).unwrap(); + serializer.serialize_struct_sep("user_agent", &log.http.user_agent).unwrap(); + serializer.serialize_struct_sep("referer", &log.http.referer.as_slice()).unwrap(); + serializer.serialize_struct_sep("request_uri", &log.http.request_uri.as_slice()).unwrap(); + serializer.serialize_struct_end().unwrap(); + + serializer.serialize_struct_start("Origin", 3).unwrap(); + serializer.serialize_struct_sep("port", &log.origin.port).unwrap(); + serializer.serialize_struct_sep("hostname", &log.origin.hostname.as_slice()).unwrap(); + serializer.serialize_struct_sep("protocol", &(log.origin.protocol as uint)).unwrap(); + serializer.serialize_struct_end().unwrap(); + + serializer.serialize_struct_sep("country", &(log.country as uint)).unwrap(); + serializer.serialize_struct_sep("cache_status", &(log.cache_status as uint)).unwrap(); + serializer.serialize_struct_sep("server_ip", &log.server_ip.as_slice()).unwrap(); + serializer.serialize_struct_sep("server_name", &log.server_name.as_slice()).unwrap(); + serializer.serialize_struct_sep("remote_ip", &log.remote_ip.as_slice()).unwrap(); + serializer.serialize_struct_sep("bytes_dlv", &log.bytes_dlv).unwrap(); + serializer.serialize_struct_sep("ray_id", &log.ray_id.as_slice()).unwrap(); + + serializer.serialize_struct_end().unwrap(); +} + +#[bench] +fn bench_direct_mem_writer(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MemWriter::with_capacity(1024); + direct(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MemWriter::with_capacity(1024); + direct(wr.by_ref(), &log); + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); + /* + assert_eq!(_s, _json.as_slice()); + */ + }); +} + +#[bench] +fn bench_direct_my_mem_writer(b: &mut Bencher) { + let log = Log::new(); + let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + let mut wr = MyMemWriter::with_capacity(1024); + direct(wr.by_ref(), &log); + b.bytes = wr.unwrap().len() as u64; + + b.iter(|| { + let mut wr = MyMemWriter::with_capacity(1024); + direct(wr.by_ref(), &log); + let _json = wr.unwrap(); + + //let _json = String::from_utf8(wr.unwrap()).unwrap(); /* - let _json = ::std::str::from_utf8_owned(wr.unwrap()).unwrap(); assert_eq!(_s, _json.as_slice()); */ }); @@ -549,9 +1052,24 @@ fn bench_manual(b: &mut Bencher) { fn bench_decoder(b: &mut Bencher) { let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + b.bytes = s.len() as u64; + b.iter(|| { let json = serialize::json::from_str(s).unwrap(); let mut decoder = serialize::json::Decoder::new(json); let _log: Log = serialize::Decodable::decode(&mut decoder).unwrap(); }); } + +/* +#[bench] +fn bench_deserializer(b: &mut Bencher) { + let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#; + + b.bytes = s.len() as u64; + + b.iter(|| { + let _log: Log = json::from_str(s).unwrap(); + }); +} +*/ diff --git a/json.rs b/json.rs index d762ebf0..21072178 100644 --- a/json.rs +++ b/json.rs @@ -736,7 +736,7 @@ fn io_error_to_error(io: io::IoError) -> ParserError { pub type EncodeResult = io::IoResult<()>; pub fn escape_bytes(wr: &mut W, bytes: &[u8]) -> IoResult<()> { - try!(wr.write_str("\"")); + //try!(wr.write_str("\"")); let mut start = 0; @@ -765,7 +765,8 @@ pub fn escape_bytes(wr: &mut W, bytes: &[u8]) -> IoResult<()> { try!(wr.write(bytes.slice_from(start))); } - wr.write_str("\"") + //wr.write_str("\"") + Ok(()) } pub fn escape_str(wr: &mut W, v: &str) -> IoResult<()> { @@ -796,9 +797,9 @@ fn spaces(wr: &mut W, mut n: uint) -> IoResult<()> { static len: uint = 16; static buf: [u8, ..len] = [b' ', ..len]; - while n >= buf.len() { + while n >= len { try!(wr.write(buf)); - n -= buf.len(); + n -= len; } if n > 0 { @@ -921,74 +922,80 @@ impl ser::Serializer for Serializer { #[inline] fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> { self.first = true; - self.wr.write_str("[") + //self.wr.write_str("[") + Ok(()) } #[inline] fn serialize_tuple_sep< T: Serializable >(&mut self, value: &T) -> IoResult<()> { - if self.first { - self.first = false; - } else { - try!(self.wr.write_str(",")); - } + //if self.first { + // self.first = false; + //} else { + // try!(self.wr.write_str(",")); + //} value.serialize(self) } #[inline] fn serialize_tuple_end(&mut self) -> IoResult<()> { - self.wr.write_str("]") + //self.wr.write_str("]") + Ok(()) } #[inline] fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> { self.first = true; - self.wr.write_str("{") + //self.wr.write_str("{") + Ok(()) } #[inline] fn serialize_struct_sep< T: Serializable >(&mut self, name: &str, value: &T) -> IoResult<()> { - if self.first { - self.first = false; - } else { - try!(self.wr.write_str(",")); - } + //if self.first { + // self.first = false; + //} else { + // try!(self.wr.write_str(",")); + //} try!(name.serialize(self)); - try!(self.wr.write_str(":")); + //try!(self.wr.write_str(":")); value.serialize(self) } #[inline] fn serialize_struct_end(&mut self) -> IoResult<()> { - self.wr.write_str("}") + //self.wr.write_str("}") + Ok(()) } #[inline] fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> { self.first = true; - try!(self.wr.write_str("{")); + //try!(self.wr.write_str("{")); try!(self.serialize_str(variant)); - self.wr.write_str(":[") + //self.wr.write_str(":[") + Ok(()) } #[inline] fn serialize_enum_sep< T: Serializable >(&mut self, value: &T) -> IoResult<()> { - if self.first { - self.first = false; - } else { - try!(self.wr.write_str(",")); - } + //if self.first { + // self.first = false; + //} else { + // try!(self.wr.write_str(",")); + //} value.serialize(self) } #[inline] fn serialize_enum_end(&mut self) -> IoResult<()> { - self.wr.write_str("]}") + //self.wr.write_str("]}") + Ok(()) } #[inline] @@ -1010,18 +1017,19 @@ impl ser::Serializer for Serializer { T: Serializable, Iter: Iterator >(&mut self, mut iter: Iter) -> IoResult<()> { - try!(self.wr.write_str("[")); - let mut first = true; + //try!(self.wr.write_str("[")); + //let mut first = true; for elt in iter { - if first { - first = false; - } else { - try!(self.wr.write_str(",")); - } + //if first { + // first = false; + //} else { + // try!(self.wr.write_str(",")); + //} try!(elt.serialize(self)); } - self.wr.write_str("]") + //self.wr.write_str("]") + Ok(()) } #[inline] @@ -1030,20 +1038,21 @@ impl ser::Serializer for Serializer { V: Serializable, Iter: Iterator<(K, V)> >(&mut self, mut iter: Iter) -> IoResult<()> { - try!(self.wr.write_str("{")); - let mut first = true; + //try!(self.wr.write_str("{")); + //let mut first = true; for (key, value) in iter { - if first { - first = false; - } else { - try!(self.wr.write_str(",")); - } + //if first { + // first = false; + //} else { + // try!(self.wr.write_str(",")); + //} try!(key.serialize(self)); - try!(self.wr.write_str(":")); + //try!(self.wr.write_str(":")); try!(value.serialize(self)); } - self.wr.write_str("}") + //self.wr.write_str("}") + Ok(()) } } @@ -1292,8 +1301,9 @@ impl ser::Serializer for PrettySerializer { } /// Encode the specified struct into a json `[u8]` buffer. +#[inline] pub fn to_vec(value: &T) -> Vec { - let mut wr = MemWriter::with_capacity(700); + let mut wr = MemWriter::with_capacity(1000); { let mut serializer = Serializer::new(wr.by_ref()); value.serialize(&mut serializer).unwrap(); @@ -1302,6 +1312,7 @@ pub fn to_vec(value: &T) -> Vec { } /// Encode the specified struct into a json `String` buffer. +#[inline] pub fn to_str(value: &T) -> Result> { let buf = to_vec(value); String::from_utf8(buf)