#![feature(test)]
extern crate test;
use std::io::Write;
use std::borrow::Cow;
use test::{Bencher, black_box};
use speedy::{Context, Readable, Reader, Writable, Endianness};
#[bench]
fn write_manual_megabyte_buffer( b: &mut Bencher ) {
let mut buffer: Vec< u8 > = Vec::new();
buffer.resize( 1024 * 1024, 1 );
buffer = black_box( buffer );
b.iter( || {
let mut output = Vec::new();
Write::write_all( &mut output, &buffer ).unwrap();
output
})
}
#[bench]
fn write_speedy_megabyte_buffer_le( b: &mut Bencher ) {
let mut buffer: Vec< u8 > = Vec::new();
buffer.resize( 1024 * 1024, 1 );
buffer = black_box( buffer );
b.iter( || {
let mut output = Vec::new();
buffer.write_to_stream_with_ctx( Endianness::LittleEndian, &mut output ).unwrap();
output
})
}
#[bench]
fn write_speedy_megabyte_buffer_be( b: &mut Bencher ) {
let mut buffer: Vec< u8 > = Vec::new();
buffer.resize( 1024 * 1024, 1 );
buffer = black_box( buffer );
b.iter( || {
let mut output = Vec::new();
buffer.write_to_stream_with_ctx( Endianness::BigEndian, &mut output ).unwrap();
output
})
}
#[bench]
fn read_speedy_megabyte_buffer_cow_borrowed( b: &mut Bencher ) {
let mut buffer: Vec< u8 > = Vec::new();
buffer.resize( 1024 * 1024, 1 );
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Cow< [u8] > = Readable::read_from_buffer_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[bench]
fn read_speedy_megabyte_buffer_cow_owned( b: &mut Bencher ) {
let mut buffer: Vec< u8 > = Vec::new();
buffer.resize( 1024 * 1024, 1 );
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Cow< [u8] > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[repr(transparent)]
#[derive(Copy, Clone, Writable)]
struct Byte( u8 );
impl< 'a, C: Context > Readable< 'a, C > for Byte {
#[inline]
fn read_from< R: Reader< 'a, C > >( reader: &mut R ) -> Result< Self, C::Error > {
Ok( Byte( reader.read_u8()? ) )
}
#[inline]
fn minimum_bytes_needed() -> usize {
1
}
}
#[bench]
fn read_speedy_megabyte_buffer_vec_non_primitive( b: &mut Bencher ) {
let mut buffer: Vec< Byte > = Vec::new();
buffer.resize( 1024 * 1024, Byte( 1 ) );
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Vec< Byte > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[derive(Clone, Readable, Writable)]
struct Dummy {
a: u64,
b: u32,
c: u16,
d: u8,
e: f32,
f: f64,
g: bool
}
#[bench]
fn read_speedy_many_small_structs( b: &mut Bencher ) {
let mut buffer: Vec< Dummy > = Vec::new();
let dummy = Dummy {
a: 1,
b: 2,
c: 3,
d: 4,
e: 5.0,
f: 6.0,
g: true
};
buffer.resize( 1024 * 1024, dummy );
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Vec< Dummy > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[bench]
fn write_speedy_many_small_structs( b: &mut Bencher ) {
let mut buffer: Vec< Dummy > = Vec::new();
let dummy = Dummy {
a: 1,
b: 2,
c: 3,
d: 4,
e: 5.0,
f: 6.0,
g: true
};
buffer.resize( 1024 * 1024, dummy );
buffer = black_box( buffer );
b.iter( || {
buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap()
})
}
pub struct XorShift64 {
a: u64,
}
impl XorShift64 {
pub fn new( seed: u64 ) -> XorShift64 {
XorShift64 { a: seed }
}
pub fn next( &mut self ) -> u64 {
let mut x = self.a;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
self.a = x;
x
}
}
#[bench]
fn read_varint_random( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| (1_u64 << (rng.next() % 63)).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Vec< VarInt64 > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[bench]
fn read_varint_always_one_byte( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| (rng.next() % 100).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Vec< VarInt64 > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[bench]
fn read_varint_always_eight_bytes( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| ((rng.next() % 100) | (1 << 63)).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
let deserialized: Vec< VarInt64 > = Readable::read_from_buffer_copying_data_with_ctx( Endianness::NATIVE, &buffer ).unwrap();
deserialized
})
}
#[bench]
fn write_varint_random( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| (1_u64 << (rng.next() % 63)).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap()
})
}
#[bench]
fn write_varint_always_one_byte( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| (rng.next() % 100).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap()
})
}
#[bench]
fn write_varint_always_eight_bytes( b: &mut Bencher ) {
use speedy::private::VarInt64;
let mut rng = XorShift64 { a: 1234 };
let buffer: Vec< VarInt64 > = (0..1024 * 1024).into_iter().map( |_| ((rng.next() % 100) | (1 << 63)).into() ).collect();
let mut buffer = buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap();
buffer = black_box( buffer );
b.iter( || {
buffer.write_to_vec_with_ctx( Endianness::NATIVE ).unwrap()
})
}