mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
serde/bench_log.rs
Erick Tryzelaar aeffb413c4 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
2014-07-05 23:44:43 -07:00

1076 lines
32 KiB
Rust
Raw Blame History

#![allow(non_camel_case_types)]
extern crate serialize;
extern crate test;
extern crate time;
use std::io;
use std::io::MemWriter;
use test::Bencher;
use json;
use ser::Serializable;
use ser;
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
struct Http {
protocol: HttpProtocol,
status: u32,
host_status: u32,
up_status: u32,
method: HttpMethod,
content_type: String,
user_agent: String,
referer: String,
request_uri: String,
}
#[deriving(Show, Encodable, Decodable)]
enum HttpProtocol {
HTTP_PROTOCOL_UNKNOWN,
HTTP10,
HTTP11,
}
impl ser::Serializable for HttpProtocol {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Show, Encodable, Decodable)]
enum HttpMethod {
METHOD_UNKNOWN,
GET,
POST,
DELETE,
PUT,
HEAD,
PURGE,
OPTIONS,
PROPFIND,
MKCOL,
PATCH,
}
impl ser::Serializable for HttpMethod {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Show, Encodable, Decodable)]
enum CacheStatus {
CACHESTATUS_UNKNOWN,
Miss,
Expired,
Hit,
}
impl ser::Serializable for CacheStatus {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
struct Origin {
ip: String,
port: u32,
hostname: String,
protocol: OriginProtocol,
}
#[deriving(Show, Encodable, Decodable)]
enum OriginProtocol {
ORIGIN_PROTOCOL_UNKNOWN,
HTTP,
HTTPS,
}
impl ser::Serializable for OriginProtocol {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Show, Encodable, Decodable)]
enum ZonePlan {
ZONEPLAN_UNKNOWN,
FREE,
PRO,
BIZ,
ENT,
}
impl ser::Serializable for ZonePlan {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Show, Encodable, Decodable)]
enum Country {
UNKNOWN,
A1,
A2,
O1,
AD,
AE,
AF,
AG,
AI,
AL,
AM,
AO,
AP,
AQ,
AR,
AS,
AT,
AU,
AW,
AX,
AZ,
BA,
BB,
BD,
BE,
BF,
BG,
BH,
BI,
BJ,
BL,
BM,
BN,
BO,
BQ,
BR,
BS,
BT,
BV,
BW,
BY,
BZ,
CA,
CC,
CD,
CF,
CG,
CH,
CI,
CK,
CL,
CM,
CN,
CO,
CR,
CU,
CV,
CW,
CX,
CY,
CZ,
DE,
DJ,
DK,
DM,
DO,
DZ,
EC,
EE,
EG,
EH,
ER,
ES,
ET,
EU,
FI,
FJ,
FK,
FM,
FO,
FR,
GA,
GB,
GD,
GE,
GF,
GG,
GH,
GI,
GL,
GM,
GN,
GP,
GQ,
GR,
GS,
GT,
GU,
GW,
GY,
HK,
HM,
HN,
HR,
HT,
HU,
ID,
IE,
IL,
IM,
IN,
IO,
IQ,
IR,
IS,
IT,
JE,
JM,
JO,
JP,
KE,
KG,
KH,
KI,
KM,
KN,
KP,
KR,
KW,
KY,
KZ,
LA,
LB,
LC,
LI,
LK,
LR,
LS,
LT,
LU,
LV,
LY,
MA,
MC,
MD,
ME,
MF,
MG,
MH,
MK,
ML,
MM,
MN,
MO,
MP,
MQ,
MR,
MS,
MT,
MU,
MV,
MW,
MX,
MY,
MZ,
NA,
NC,
NE,
NF,
NG,
NI,
NL,
NO,
NP,
NR,
NU,
NZ,
OM,
PA,
PE,
PF,
PG,
PH,
PK,
PL,
PM,
PN,
PR,
PS,
PT,
PW,
PY,
QA,
RE,
RO,
RS,
RU,
RW,
SA,
SB,
SC,
SD,
SE,
SG,
SH,
SI,
SJ,
SK,
SL,
SM,
SN,
SO,
SR,
SS,
ST,
SV,
SX,
SY,
SZ,
TC,
TD,
TF,
TG,
TH,
TJ,
TK,
TL,
TM,
TN,
TO,
TR,
TT,
TV,
TW,
TZ,
UA,
UG,
UM,
US,
UY,
UZ,
VA,
VC,
VE,
VG,
VI,
VN,
VU,
WF,
WS,
XX,
YE,
YT,
ZA,
ZM,
ZW,
}
impl ser::Serializable for Country {
#[inline]
fn serialize<
S: ser::Serializer<E>,
E
>(&self, s: &mut S) -> Result<(), E> {
s.serialize_uint(*self as uint)
}
}
#[deriving(Encodable, Decodable)]
#[deriving_serializable]
struct Log {
timestamp: i64,
zone_id: u32,
zone_plan: ZonePlan,
http: Http,
origin: Origin,
country: Country,
cache_status: CacheStatus,
server_ip: String,
server_name: String,
remote_ip: String,
bytes_dlv: u64,
ray_id: String,
}
struct MyMemWriter {
buf: Vec<u8>,
}
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<u8> { 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<u8>,
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<u8> { 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<u64> {
// 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<u64> { 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 {
timestamp: time::precise_time_ns() as i64,
zone_id: 123456,
zone_plan: FREE,
http: Http {
protocol: HTTP11,
status: 200,
host_status: 503,
up_status: 520,
method: GET,
content_type: "text/html".to_string(),
user_agent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36".to_string(),
referer: "https://www.cloudflare.com/".to_string(),
request_uri: "/cdn-cgi/trace".to_string(),
},
origin: Origin {
ip: "1.2.3.4".to_string(),
port: 8000,
hostname: "www.example.com".to_string(),
protocol: HTTPS,
},
country: US,
cache_status: Hit,
server_ip: "192.168.1.1".to_string(),
server_name: "metal.cloudflare.com".to_string(),
remote_ip: "10.1.2.3".to_string(),
bytes_dlv: 123456,
ray_id: "10c73629cce30078-LAX".to_string(),
}
}
}
#[bench]
fn bench_encoder(b: &mut Bencher) {
let log = Log::new();
let json = serialize::json::encode(&log);
b.bytes = json.len() as u64;
b.iter(|| {
let _ = serialize::json::encode(&log);
});
}
#[bench]
fn bench_serializer(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 _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();
});
}
#[bench]
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 = Vec::from_slice(s.as_bytes());
});
}
fn manual_no_escape<W: Writer>(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<W: Writer>(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_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(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<W: Writer>(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();
/*
assert_eq!(_s, _json.as_slice());
*/
});
}
#[bench]
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();
});
}
*/
Reference in New Issue View Git Blame Copy Permalink