Add basic runtime benchmarks for fast-vec optimisations

Refs jam1garner#319.

Author: csnover

binrw/tests/benches.rs

@@ -0,0 +1,5 @@
+#![cfg_attr(all(nightly, not(coverage)), feature(test))]
+
+#[cfg(all(nightly, not(coverage)))]
+#[path = "benches/fast_vec.rs"]
+mod fast_vec;

binrw/tests/benches/fast_vec.rs

@@ -0,0 +1,77 @@
+#[path = "../test_utils/mod.rs"]
+mod test_utils;
+
+extern crate test;
+
+use binrw::BinRead;
+
+#[cfg(target_endian = "big")]
+const ENDIAN: binrw::Endian = binrw::Endian::Little;
+#[cfg(target_endian = "little")]
+const ENDIAN: binrw::Endian = binrw::Endian::Big;
+
+macro_rules! bench_fast {
+    ($($name:ident, $Ty:ty, $reads:literal);+$(;)?) => {
+        $(#[bench]
+        fn $name(b: &mut test::Bencher) {
+            run_benchmark::<$Ty>(b, binrw::Endian::NATIVE, $reads);
+        })+
+    }
+}
+
+macro_rules! bench_fast_swap {
+    ($($name:ident, $Ty:ty, $reads:literal);+$(;)?) => {
+        $(#[bench]
+        fn $name(b: &mut test::Bencher) {
+            run_benchmark::<$Ty>(b, ENDIAN, $reads);
+        })+
+    }
+}
+
+#[inline(always)]
+fn run_benchmark<T>(b: &mut test::Bencher, endian: binrw::Endian, expected_reads: usize)
+where
+    T: for<'a> BinRead<Args<'a> = ()> + 'static,
+{
+    let mut filler = test_utils::Fill::new(1);
+    let count: usize = 65536 / core::mem::size_of::<T>();
+
+    b.iter(|| {
+        let mut counter = test_utils::Counter::new(&mut filler);
+
+        test::black_box(
+            Vec::<T>::read_options(
+                &mut counter,
+                endian,
+                binrw::VecArgs::builder().count(count).finalize(),
+            )
+            .unwrap(),
+        );
+
+        assert_eq!(counter.reads, expected_reads);
+    });
+}
+
+bench_fast!(
+    vec_i8, i8, 12;
+    vec_u8, u8, 4;
+    vec_i16, i16, 12;
+    vec_u16, u16, 12;
+    vec_i32, i32, 12;
+    vec_u32, u32, 12;
+    vec_i64, i64, 12;
+    vec_u64, u64, 12;
+    vec_i128, i128, 11;
+    vec_u128, u128, 11;
+);
+
+bench_fast_swap!(
+    vec_i16_swap, i16, 12;
+    vec_u16_swap, u16, 12;
+    vec_i32_swap, i32, 12;
+    vec_u32_swap, u32, 12;
+    vec_i64_swap, i64, 12;
+    vec_u64_swap, u64, 12;
+    vec_i128_swap, i128, 11;
+    vec_u128_swap, u128, 11;
+);

binrw/tests/io/bufreader.rs

@@ -2,31 +2,12 @@
 use binrw::io::{BufReader, Cursor, Read, Seek, SeekFrom};
 use std::io::BufRead;
 
+#[path = "../test_utils/mod.rs"]
+mod test_utils;
+
 #[test]
 fn bufreader() {
-    struct Counter<T> {
-        inner: T,
-        reads: usize,
-    }
-
-    impl<T> Counter<T> {
-        fn new(inner: T) -> Self {
-            Counter { inner, reads: 0 }
-        }
-    }
-
-    impl<T: Read> Read for Counter<T> {
-        fn read(&mut self, buf: &mut [u8]) -> binrw::io::Result<usize> {
-            self.reads += 1;
-            self.inner.read(buf)
-        }
-    }
-
-    impl<T: Seek> Seek for Counter<T> {
-        fn seek(&mut self, pos: SeekFrom) -> binrw::io::Result<u64> {
-            self.inner.seek(pos)
-        }
-    }
+    use test_utils::Counter;
 
     let mut stream = Cursor::new(b"helloworld".to_vec());
     // Give wrapped stream a non-zero position first to ensure it is adopted

binrw/tests/test_utils/mod.rs

@@ -0,0 +1,48 @@
+use binrw::io::{Read, Seek, SeekFrom};
+
+pub(crate) struct Fill {
+    value: u8,
+}
+
+impl Fill {
+    pub(crate) fn new(value: u8) -> Self {
+        Self { value }
+    }
+}
+
+impl Read for Fill {
+    fn read(&mut self, buf: &mut [u8]) -> binrw::io::Result<usize> {
+        buf.fill(self.value);
+        Ok(buf.len())
+    }
+}
+
+impl Seek for Fill {
+    fn seek(&mut self, _: SeekFrom) -> binrw::io::Result<u64> {
+        Ok(0)
+    }
+}
+
+pub(crate) struct Counter<T> {
+    pub(crate) inner: T,
+    pub(crate) reads: usize,
+}
+
+impl<T> Counter<T> {
+    pub(crate) fn new(inner: T) -> Self {
+        Counter { inner, reads: 0 }
+    }
+}
+
+impl<T: Read> Read for Counter<T> {
+    fn read(&mut self, buf: &mut [u8]) -> binrw::io::Result<usize> {
+        self.reads += 1;
+        self.inner.read(buf)
+    }
+}
+
+impl<T: Seek> Seek for Counter<T> {
+    fn seek(&mut self, pos: SeekFrom) -> binrw::io::Result<u64> {
+        self.inner.seek(pos)
+    }
+}