Extend and drain with slices

benches/bench.rs

@@ -157,6 +157,98 @@ fn benchmark_copy_from_slice_vs_extend<T: RingBuffer<i32> + SetLen, F: Fn() -> T
     group.finish();
 }
 
+fn benchmark_extend_from_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 input = vec![9; rb_size];
+    group.bench_function(format!("ExtendFromSlice({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(6);
+        }
+        b.iter(|| {
+            rb.extend_from_slice(&input);
+            assert_eq!(input[input.len() / 2], 9);
+        })
+    });
+    group.bench_function(format!("ExtendFromIter({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.extend(input.iter().copied());
+            assert_eq!(input[input.len() / 2], 9);
+        })
+    });
+    group.finish();
+}
+
+fn benchmark_drain_to_slice_vs_drain<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!("DrainToSlice({rb_type}; {rb_size})"), |b| {
+        b.iter_batched(
+            || {
+                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);
+                }
+                rb
+            },
+            |mut rb| {
+                rb.drain_to_slice(&mut output);
+                assert_eq!(output[output.len() / 2], 9);
+            },
+            criterion::BatchSize::NumIterations(1),
+        )
+    });
+    let mut output = vec![0; rb_size];
+    group.bench_function(format!("DrainIter({rb_type}; {rb_size})"), |b| {
+        b.iter_batched(
+            || {
+                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);
+                }
+                rb
+            },
+            |mut rb| {
+                output
+                    .iter_mut()
+                    .zip(rb.drain())
+                    .for_each(|(dst, src)| *dst = src);
+                assert_eq!(output[output.len() / 2], 9);
+            },
+            criterion::BatchSize::NumIterations(1),
+        )
+    });
+    group.finish();
+}
+
 macro_rules! generate_benches {
     (called, $c: tt, $rb: tt, $ty: tt, $fn: tt, $bmfunc: tt, $($i:tt),*) => {
         $(
@@ -429,6 +521,60 @@ fn criterion_benchmark(c: &mut Criterion) {
         1_000_000,
         1_048_576
     ];
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_extend_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_extend_from_slice_vs_extend,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare,
+        c,
+        AllocRingBuffer,
+        i32,
+        new,
+        benchmark_drain_to_slice_vs_drain,
+        16,
+        1024,
+        4096,
+        8192,
+        1_000_000,
+        1_048_576
+    ];
+    generate_benches![
+        compare_typed,
+        c,
+        ConstGenericRingBuffer,
+        i32,
+        new,
+        benchmark_drain_to_slice_vs_drain,
+        16,
+        1024,
+        4096,
+        8192
+    ];
 }
 
 criterion_group!(benches, criterion_benchmark);