test: add benchmarks

Author: cdellacqua

Cargo.toml

@@ -14,7 +14,7 @@ categories = ["data-structures"]
 license = "MIT"
 
 [dev-dependencies]
-criterion = "0.4.0"
+criterion = { version = "0.4.0", features = ["html_reports"] }
 compiletest_rs = "0.10.0"
 
 [features]

benches/bench.rs

@@ -1,6 +1,7 @@
-#![no_coverage]
+#![feature(coverage_attribute)]
+#![coverage(off)]
 use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion};
-use ringbuffer::{AllocRingBuffer, ConstGenericRingBuffer, RingBuffer};
+use ringbuffer::{AllocRingBuffer, ConstGenericRingBuffer, RingBuffer, SetLen};
 
 fn benchmark_push<T: RingBuffer<i32>, F: Fn() -> T>(b: &mut Bencher, new: F) {
     b.iter(|| {
@@ -63,6 +64,89 @@ fn benchmark_various<T: RingBuffer<i32>, F: Fn() -> T>(b: &mut Bencher, new: F)
     })
 }
 
+fn benchmark_copy_to_slice_vs_extend<T: RingBuffer<i32>, F: Fn() -> T>(
+    rb_size: usize,
+    rb_type: &str,
+    fn_name: &str,
+    c: &mut Criterion,
+    new: F,
+) {
+    let mut group = c.benchmark_group(format!("{fn_name}({rb_type}, {rb_size})"));
+    let mut output = vec![0; rb_size];
+    group.bench_function(format!("CopyTo({rb_type}; {rb_size})"), |b| {
+        let mut rb = new();
+        rb.fill(9);
+        // making sure the read/write pointers wrap around
+        for _ in 0..rb_size / 2 {
+            let _ = rb.dequeue();
+            let _ = rb.enqueue(9);
+        }
+        b.iter(|| {
+            rb.copy_to_slice(0, &mut output);
+            assert_eq!(output[output.len() / 2], 9);
+            assert_eq!(output.len(), rb_size);
+        })
+    });
+    let mut output: Vec<i32> = Vec::with_capacity(rb_size);
+    group.bench_function(format!("ExtendVec({rb_type}; {rb_size})"), |b| {
+        let mut rb = new();
+        rb.fill(9);
+        // making sure the read/write pointers wrap around
+        for _ in 0..rb_size / 2 {
+            let _ = rb.dequeue();
+            let _ = rb.enqueue(9);
+        }
+        b.iter(|| {
+            unsafe { output.set_len(0) };
+            output.extend(rb.iter());
+            assert_eq!(output[output.len() / 2], 9);
+            assert_eq!(output.len(), rb_size);
+        })
+    });
+    group.finish();
+}
+
+fn benchmark_copy_from_slice_vs_extend<T: RingBuffer<i32> + SetLen, F: Fn() -> T>(
+    rb_size: usize,
+    rb_type: &str,
+    fn_name: &str,
+    c: &mut Criterion,
+    new: F,
+) {
+    let mut group = c.benchmark_group(format!("{fn_name}({rb_type}, {rb_size})"));
+    let input = vec![9; rb_size];
+    group.bench_function(format!("CopyFrom({rb_type}; {rb_size})"), |b| {
+        let mut rb = new();
+        rb.fill(0);
+        // making sure the read/write pointers wrap around
+        for _ in 0..rb_size / 2 {
+            let _ = rb.dequeue();
+            let _ = rb.enqueue(0);
+        }
+        for _ in 0..rb_size / 2 {}
+        b.iter(|| {
+            rb.copy_from_slice(0, &input);
+            assert_eq!(rb[rb.len() / 2], 9);
+            assert_eq!(rb.len(), rb_size);
+        })
+    });
+    group.bench_function(format!("ExtendRb({rb_type}; {rb_size})"), |b| {
+        let mut rb = new();
+        // making sure the read/write pointers wrap around
+        for _ in 0..rb_size / 2 {
+            let _ = rb.dequeue();
+            let _ = rb.enqueue(0);
+        }
+        b.iter(|| {
+            unsafe { rb.set_len(0) };
+            rb.extend(input.iter().copied());
+            assert_eq!(rb[rb.len() / 2], 9);
+            assert_eq!(rb.len(), rb_size);
+        })
+    });
+    group.finish();
+}
+
 macro_rules! generate_benches {
     (called, $c: tt, $rb: tt, $ty: tt, $fn: tt, $bmfunc: tt, $($i:tt),*) => {
         $(
@@ -86,6 +170,22 @@ macro_rules! generate_benches {
             }));
         )*
     };
+
+    (compare, $c: tt, $rb: tt, $ty: tt, $fn: tt, $bmfunc: tt, $($i:tt),*) => {
+        $(
+            $bmfunc($i, stringify!($rb), stringify!($bmfunc), $c, || {
+                $rb::<$ty>::$fn($i)
+            });
+        )*
+    };
+
+    (compare_typed, $c: tt, $rb: tt, $ty: tt, $fn: tt, $bmfunc: tt, $($i:tt),*) => {
+        $(
+            $bmfunc($i, stringify!($rb), stringify!($bmfunc), $c, || {
+                $rb::<$ty, $i>::$fn()
+            });
+        )*
+    };
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
@@ -180,6 +280,119 @@ fn criterion_benchmark(c: &mut Criterion) {
         8192,
         8195
     ];
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_copy_to_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_copy_to_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_copy_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_copy_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_copy_to_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_copy_to_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_copy_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_copy_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
 }
 
 criterion_group!(benches, criterion_benchmark);