зеркало из https://github.com/mozilla/gecko-dev.git
329 строки
10 KiB
Rust
329 строки
10 KiB
Rust
#![feature(test)]
|
|
|
|
extern crate byteorder;
|
|
extern crate rand;
|
|
extern crate test;
|
|
|
|
macro_rules! bench_num {
|
|
($name:ident, $read:ident, $bytes:expr, $data:expr) => (
|
|
mod $name {
|
|
use byteorder::{ByteOrder, BigEndian, NativeEndian, LittleEndian};
|
|
use super::test::Bencher;
|
|
use super::test::black_box as bb;
|
|
|
|
const NITER: usize = 100_000;
|
|
|
|
#[bench]
|
|
fn read_big_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(BigEndian::$read(&buf, $bytes));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn read_little_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(LittleEndian::$read(&buf, $bytes));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn read_native_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(NativeEndian::$read(&buf, $bytes));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
);
|
|
($ty:ident, $max:ident,
|
|
$read:ident, $write:ident, $size:expr, $data:expr) => (
|
|
mod $ty {
|
|
use std::$ty;
|
|
use byteorder::{ByteOrder, BigEndian, NativeEndian, LittleEndian};
|
|
use super::test::Bencher;
|
|
use super::test::black_box as bb;
|
|
|
|
const NITER: usize = 100_000;
|
|
|
|
#[bench]
|
|
fn read_big_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(BigEndian::$read(&buf));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn read_little_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(LittleEndian::$read(&buf));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn read_native_endian(b: &mut Bencher) {
|
|
let buf = $data;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(NativeEndian::$read(&buf));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn write_big_endian(b: &mut Bencher) {
|
|
let mut buf = $data;
|
|
let n = $ty::$max;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(BigEndian::$write(&mut buf, n));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn write_little_endian(b: &mut Bencher) {
|
|
let mut buf = $data;
|
|
let n = $ty::$max;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(LittleEndian::$write(&mut buf, n));
|
|
}
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn write_native_endian(b: &mut Bencher) {
|
|
let mut buf = $data;
|
|
let n = $ty::$max;
|
|
b.iter(|| {
|
|
for _ in 0..NITER {
|
|
bb(NativeEndian::$write(&mut buf, n));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
bench_num!(u16, MAX, read_u16, write_u16, 2, [1, 2]);
|
|
bench_num!(i16, MAX, read_i16, write_i16, 2, [1, 2]);
|
|
bench_num!(u32, MAX, read_u32, write_u32, 4, [1, 2, 3, 4]);
|
|
bench_num!(i32, MAX, read_i32, write_i32, 4, [1, 2, 3, 4]);
|
|
bench_num!(u64, MAX, read_u64, write_u64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
bench_num!(i64, MAX, read_i64, write_i64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
bench_num!(f32, MAX, read_f32, write_f32, 4, [1, 2, 3, 4]);
|
|
bench_num!(f64, MAX, read_f64, write_f64, 8,
|
|
[1, 2, 3, 4, 5, 6, 7, 8]);
|
|
|
|
bench_num!(uint_1, read_uint, 1, [1]);
|
|
bench_num!(uint_2, read_uint, 2, [1, 2]);
|
|
bench_num!(uint_3, read_uint, 3, [1, 2, 3]);
|
|
bench_num!(uint_4, read_uint, 4, [1, 2, 3, 4]);
|
|
bench_num!(uint_5, read_uint, 5, [1, 2, 3, 4, 5]);
|
|
bench_num!(uint_6, read_uint, 6, [1, 2, 3, 4, 5, 6]);
|
|
bench_num!(uint_7, read_uint, 7, [1, 2, 3, 4, 5, 6, 7]);
|
|
bench_num!(uint_8, read_uint, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
|
|
bench_num!(int_1, read_int, 1, [1]);
|
|
bench_num!(int_2, read_int, 2, [1, 2]);
|
|
bench_num!(int_3, read_int, 3, [1, 2, 3]);
|
|
bench_num!(int_4, read_int, 4, [1, 2, 3, 4]);
|
|
bench_num!(int_5, read_int, 5, [1, 2, 3, 4, 5]);
|
|
bench_num!(int_6, read_int, 6, [1, 2, 3, 4, 5, 6]);
|
|
bench_num!(int_7, read_int, 7, [1, 2, 3, 4, 5, 6, 7]);
|
|
bench_num!(int_8, read_int, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(u128, MAX, read_u128, write_u128,
|
|
16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(i128, MAX, read_i128, write_i128,
|
|
16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_1, read_uint128,
|
|
1, [1]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_2, read_uint128,
|
|
2, [1, 2]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_3, read_uint128,
|
|
3, [1, 2, 3]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_4, read_uint128,
|
|
4, [1, 2, 3, 4]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_5, read_uint128,
|
|
5, [1, 2, 3, 4, 5]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_6, read_uint128,
|
|
6, [1, 2, 3, 4, 5, 6]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_7, read_uint128,
|
|
7, [1, 2, 3, 4, 5, 6, 7]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_8, read_uint128,
|
|
8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_9, read_uint128,
|
|
9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_10, read_uint128,
|
|
10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_11, read_uint128,
|
|
11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_12, read_uint128,
|
|
12, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_13, read_uint128,
|
|
13, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_14, read_uint128,
|
|
14, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_15, read_uint128,
|
|
15, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(uint128_16, read_uint128,
|
|
16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_1, read_int128,
|
|
1, [1]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_2, read_int128,
|
|
2, [1, 2]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_3, read_int128,
|
|
3, [1, 2, 3]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_4, read_int128,
|
|
4, [1, 2, 3, 4]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_5, read_int128,
|
|
5, [1, 2, 3, 4, 5]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_6, read_int128,
|
|
6, [1, 2, 3, 4, 5, 6]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_7, read_int128,
|
|
7, [1, 2, 3, 4, 5, 6, 7]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_8, read_int128,
|
|
8, [1, 2, 3, 4, 5, 6, 7, 8]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_9, read_int128,
|
|
9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_10, read_int128,
|
|
10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_11, read_int128,
|
|
11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_12, read_int128,
|
|
12, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_13, read_int128,
|
|
13, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_14, read_int128,
|
|
14, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_15, read_int128,
|
|
15, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
|
|
#[cfg(byteorder_i128)]
|
|
bench_num!(int128_16, read_int128,
|
|
16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
|
|
|
|
|
|
macro_rules! bench_slice {
|
|
($name:ident, $numty:ty, $read:ident, $write:ident) => {
|
|
mod $name {
|
|
use std::mem::size_of;
|
|
|
|
use byteorder::{ByteOrder, BigEndian, LittleEndian};
|
|
use rand::{self, Rng};
|
|
use rand::distributions;
|
|
use test::Bencher;
|
|
|
|
#[bench]
|
|
fn read_big_endian(b: &mut Bencher) {
|
|
let mut numbers: Vec<$numty> = rand::thread_rng()
|
|
.sample_iter(&distributions::Standard)
|
|
.take(100000)
|
|
.collect();
|
|
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
|
|
BigEndian::$write(&numbers, &mut bytes);
|
|
|
|
b.bytes = bytes.len() as u64;
|
|
b.iter(|| {
|
|
BigEndian::$read(&bytes, &mut numbers);
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn read_little_endian(b: &mut Bencher) {
|
|
let mut numbers: Vec<$numty> = rand::thread_rng()
|
|
.sample_iter(&distributions::Standard)
|
|
.take(100000)
|
|
.collect();
|
|
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
|
|
LittleEndian::$write(&numbers, &mut bytes);
|
|
|
|
b.bytes = bytes.len() as u64;
|
|
b.iter(|| {
|
|
LittleEndian::$read(&bytes, &mut numbers);
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn write_big_endian(b: &mut Bencher) {
|
|
let numbers: Vec<$numty> = rand::thread_rng()
|
|
.sample_iter(&distributions::Standard)
|
|
.take(100000)
|
|
.collect();
|
|
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
|
|
|
|
b.bytes = bytes.len() as u64;
|
|
b.iter(|| {
|
|
BigEndian::$write(&numbers, &mut bytes);
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
fn write_little_endian(b: &mut Bencher) {
|
|
let numbers: Vec<$numty> = rand::thread_rng()
|
|
.sample_iter(&distributions::Standard)
|
|
.take(100000)
|
|
.collect();
|
|
let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
|
|
|
|
b.bytes = bytes.len() as u64;
|
|
b.iter(|| {
|
|
LittleEndian::$write(&numbers, &mut bytes);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bench_slice!(slice_u64, u64, read_u64_into, write_u64_into);
|