pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-25 12:47:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

experiment with alternative MemWriters

Browse Source 
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
This commit is contained in:
Erick Tryzelaar
2014-07-05 23:44:43 -07:00
parent 076a35075a
commit aeffb413c4
2 changed files with 630 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
json.rs
+56 -45
View File
@@ -736,7 +736,7 @@ fn io_error_to_error(io: io::IoError) -> ParserError {
pub type EncodeResult = io::IoResult<()>;
pub fn escape_bytes<W: Writer>(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<W: Writer>(wr: &mut W, bytes: &[u8]) -> IoResult<()> {
try!(wr.write(bytes.slice_from(start)));
}
wr.write_str("\"")
//wr.write_str("\"")
Ok(())
}
pub fn escape_str<W: Writer>(wr: &mut W, v: &str) -> IoResult<()> {
@@ -796,9 +797,9 @@ fn spaces<W: Writer>(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<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
#[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<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
T: Serializable,
Iter: Iterator<T>
>(&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<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
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<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
}
/// Encode the specified struct into a json `[u8]` buffer.
#[inline]
pub fn to_vec<T: ser::Serializable>(value: &T) -> Vec<u8> {
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<T: ser::Serializable>(value: &T) -> Vec<u8> {
}
/// Encode the specified struct into a json `String` buffer.
#[inline]
pub fn to_str<T: ser::Serializable>(value: &T) -> Result<String, Vec<u8>> {
let buf = to_vec(value);
String::from_utf8(buf)