robin/bitbuffer
1
0
Fork 0
mirror of https://codeberg.org/icewind/bitbuffer.git synced 2026-06-03 16:44:06 +02:00
Code Issues Releases Wiki Activity

move benches to iai

Browse source
This commit is contained in:
Robin Appelman 2021-07-18 19:55:45 +02:00
commit 94bc320add
3 changed files with 188 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Cargo.toml
View file

@ -15,5 +15,10 @@ memchr = "2"
[dev-dependencies] [dev-dependencies]
maplit = "1" maplit = "1"
iai = "0.1"
[[bench]]
name = "bench"
harness = false
[workspace] [workspace]

193
benches/bench.rs
View file

@ -1,9 +1,5 @@
#![feature(test)]
extern crate test;
use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, Endianness, LittleEndian}; use bitbuffer::{BigEndian, BitRead, BitReadBuffer, BitReadStream, Endianness, LittleEndian};
use test::Bencher; use iai::black_box;
fn read_perf<E: Endianness>(buffer: &BitReadBuffer<E>) -> u16 { fn read_perf<E: Endianness>(buffer: &BitReadBuffer<E>) -> u16 {
let size = 5; let size = 5;
@ -20,33 +16,24 @@ fn read_perf<E: Endianness>(buffer: &BitReadBuffer<E>) -> u16 {
} }
} }
#[bench] const ONES: [u8; 1024 * 1024 * 10] = [1u8; 1024 * 1024 * 10];
fn perf_le(b: &mut Bencher) {
let data = vec![1u8; 1024 * 1024 * 10]; fn perf_le() {
let buffer = BitReadBuffer::new(&data, LittleEndian); let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
b.iter(|| {
let data = read_perf(&buffer); let data = read_perf(&buffer);
assert_eq!(data, 0); assert_eq!(data, 0);
test::black_box(data); black_box(data);
});
} }
#[bench] fn perf_be() {
fn perf_be(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let data = read_perf(&buffer); let data = read_perf(&buffer);
assert_eq!(data, 0); assert_eq!(data, 0);
test::black_box(data); black_box(data);
});
} }
#[bench] fn perf_f32_be() {
fn perf_f32_be(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
let mut result: f32 = 0.0; let mut result: f32 = 0.0;
@ -59,15 +46,11 @@ fn perf_f32_be(b: &mut Bencher) {
pos += 32; pos += 32;
} }
assert_eq!(result, 0.00000000000000000000000000000006170106); assert_eq!(result, 0.00000000000000000000000000000006170106);
test::black_box(result); black_box(result);
});
} }
#[bench] fn perf_f32_le() {
fn perf_f32_le(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitReadBuffer::new(&data, LittleEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
let mut result: f32 = 0.0; let mut result: f32 = 0.0;
@ -80,17 +63,13 @@ fn perf_f32_le(b: &mut Bencher) {
pos += 32; pos += 32;
} }
assert_eq!(result, 0.00000000000000000000000000000006170106); assert_eq!(result, 0.00000000000000000000000000000006170106);
test::black_box(result); black_box(result);
});
} }
const F64_RESULT: f64 = 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010156250477904244; const F64_RESULT: f64 = 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010156250477904244;
#[bench] fn perf_f64() {
fn perf_f64(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
let data = vec![1u8; 1024 * 1024 * 10];
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
let mut result: f64 = 0.0; let mut result: f64 = 0.0;
@ -103,15 +82,11 @@ fn perf_f64(b: &mut Bencher) {
pos += 64; pos += 64;
} }
assert_eq!(result, F64_RESULT); assert_eq!(result, F64_RESULT);
test::black_box(result); black_box(result);
});
} }
#[bench] fn perf_bool() {
fn perf_bool(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&ONES), BigEndian);
let data = vec![1u8; 1024 * 1024 * 1];
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -119,42 +94,49 @@ fn perf_bool(b: &mut Bencher) {
break; break;
} }
let num = buffer.read_bool(pos).unwrap(); let num = buffer.read_bool(pos).unwrap();
test::black_box(num); black_box(num);
pos += 1; pos += 1;
} }
});
} }
fn build_string_data(size: usize, inputs: &Vec<&str>) -> Vec<u8> { const fn build_string_data<const N: usize>(inputs: &[&str]) -> [u8; N] {
let mut data = Vec::with_capacity(size); let mut data = [0; N];
let mut i = 0;
loop { loop {
for input in inputs.iter() { let mut y = 0;
if data.len() + input.len() + 1 >= size { while y < inputs.len() {
let mut z = 0;
let input = inputs[y].as_bytes();
while z < input.len() {
i += 1;
if i >= N {
return data; return data;
} }
data.extend_from_slice(input.as_bytes());
data.push(0); data[i] = input[z];
z += 1;
}
y += 1;
} }
} }
} }
fn get_string_buffer() -> Vec<u8> { const fn get_string_buffer<const N: usize>() -> [u8; N] {
let inputs = vec![ let inputs = [
"foo", "foo\0",
"bar", "bar\0",
"something a little bit longer for extra testing", "something a little bit longer for extra testing\0",
"a", "a\0",
"", "\0",
]; ];
build_string_data(10 * 1024 * 1024, &inputs) build_string_data::<N>(&inputs)
} }
#[bench] const STRING_DATA: [u8; 10 * 1024] = get_string_buffer();
fn perf_string_be(b: &mut Bencher) {
let data = get_string_buffer(); fn perf_string_be() {
let buffer = BitReadBuffer::new(&data, BigEndian); let buffer = BitReadBuffer::new(black_box(&STRING_DATA), BigEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -163,17 +145,13 @@ fn perf_string_be(b: &mut Bencher) {
} }
let result = buffer.read_string(pos, None).unwrap(); let result = buffer.read_string(pos, None).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[bench] fn perf_string_le() {
fn perf_string_le(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), LittleEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, LittleEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -182,17 +160,13 @@ fn perf_string_le(b: &mut Bencher) {
} }
let result = buffer.read_string(pos, None).unwrap(); let result = buffer.read_string(pos, None).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[bench] fn perf_bytes_be() {
fn perf_bytes_be(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), BigEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -201,17 +175,13 @@ fn perf_bytes_be(b: &mut Bencher) {
} }
let result = buffer.read_bytes(pos, 128).unwrap(); let result = buffer.read_bytes(pos, 128).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[bench] fn perf_bytes_le() {
fn perf_bytes_le(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), LittleEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, LittleEndian);
b.iter(|| {
let mut pos = 0; let mut pos = 0;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -220,17 +190,13 @@ fn perf_bytes_le(b: &mut Bencher) {
} }
let result = buffer.read_bytes(pos, 128).unwrap(); let result = buffer.read_bytes(pos, 128).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[bench] fn perf_bytes_be_unaligned() {
fn perf_bytes_be_unaligned(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), BigEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, BigEndian);
b.iter(|| {
let mut pos = 3; let mut pos = 3;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -239,17 +205,13 @@ fn perf_bytes_be_unaligned(b: &mut Bencher) {
} }
let result = buffer.read_bytes(pos, 128).unwrap(); let result = buffer.read_bytes(pos, 128).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[bench] fn perf_bytes_le_unaligned() {
fn perf_bytes_le_unaligned(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), LittleEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, LittleEndian);
b.iter(|| {
let mut pos = 3; let mut pos = 3;
let len = buffer.bit_len(); let len = buffer.bit_len();
loop { loop {
@ -258,9 +220,8 @@ fn perf_bytes_le_unaligned(b: &mut Bencher) {
} }
let result = buffer.read_bytes(pos, 128).unwrap(); let result = buffer.read_bytes(pos, 128).unwrap();
pos += (result.len() + 1) * 8; pos += (result.len() + 1) * 8;
test::black_box(result); black_box(result);
} }
});
} }
#[allow(dead_code)] #[allow(dead_code)]
@ -272,16 +233,28 @@ struct BasicStruct {
c: u32, c: u32,
} }
#[bench] fn perf_struct() {
fn perf_struct(b: &mut Bencher) { let buffer = BitReadBuffer::new(black_box(&STRING_DATA), LittleEndian);
let data = get_string_buffer();
let buffer = BitReadBuffer::new(&data, LittleEndian);
b.iter(|| {
let mut stream: BitReadStream<LittleEndian> = buffer.clone().into(); let mut stream: BitReadStream<LittleEndian> = buffer.clone().into();
while stream.bits_left() > 40 { while stream.bits_left() > 40 {
let result = stream.read::<BasicStruct>().unwrap(); let result = stream.read::<BasicStruct>().unwrap();
test::black_box(result); black_box(result);
} }
});
} }
iai::main!(
perf_be,
perf_bool,
perf_bytes_be,
perf_bytes_be_unaligned,
perf_bytes_le,
perf_bytes_le_unaligned,
perf_f32_be,
perf_f32_le,
perf_f64,
perf_le,
perf_string_be,
perf_string_le,
perf_struct
);

4
src/readbuffer.rs
View file

@ -362,7 +362,7 @@ where
}); });
} }
if position + count + USIZE_BIT_SIZE > self.bit_len() { if position + USIZE_BIT_SIZE > self.bit_len() {
if position + count > self.bit_len() { if position + count > self.bit_len() {
return if position > self.bit_len() { return if position > self.bit_len() {
Err(BitError::IndexOutOfBounds { Err(BitError::IndexOutOfBounds {
@ -712,7 +712,7 @@ where
T: Float + UncheckedPrimitiveFloat, T: Float + UncheckedPrimitiveFloat,
{ {
let type_bit_size = size_of::<T>() * 8; let type_bit_size = size_of::<T>() * 8;
if position + type_bit_size + USIZE_BIT_SIZE > self.bit_len() { if position + USIZE_BIT_SIZE > self.bit_len() {
if position + type_bit_size > self.bit_len() { if position + type_bit_size > self.bit_len() {
if position > self.bit_len() { if position > self.bit_len() {
return Err(BitError::IndexOutOfBounds { return Err(BitError::IndexOutOfBounds {