remove bench grouping because codspeed doesn't support

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-compute/benches/filter_buffer_mut.rs

@@ -3,8 +3,6 @@
 
 //! In-place filter benchmarks for `BufferMut`.
 
-use std::fmt;
-
 use divan::Bencher;
 use vortex_buffer::BufferMut;
 use vortex_compute::filter::Filter;
@@ -16,28 +14,10 @@ fn main() {
 
 const BUFFER_SIZE: usize = 1024;
 
-// Full selectivity spectrum with extra detail around the 80% threshold.
 const SELECTIVITIES: &[f64] = &[
-    0.01, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.50, 0.75, 0.78, 0.79, 0.80, 0.81, 0.82, 0.85, 0.99,
+    0.01, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 0.99,
 ];
 
-#[derive(Copy, Clone, Debug)]
-enum Pattern {
-    Random,
-    Contiguous,
-    Alternating,
-}
-
-impl fmt::Display for Pattern {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Pattern::Random => write!(f, "random"),
-            Pattern::Contiguous => write!(f, "contiguous"),
-            Pattern::Alternating => write!(f, "alternating"),
-        }
-    }
-}
-
 fn create_test_buffer<T>(size: usize) -> BufferMut<T>
 where
     T: Copy + Default + From<u8>,
@@ -50,112 +30,25 @@ where
     buffer
 }
 
-fn generate_mask(len: usize, selectivity: f64, pattern: Pattern) -> Mask {
+fn generate_mask(len: usize, selectivity: f64) -> Mask {
     #[expect(clippy::cast_possible_truncation)]
     #[expect(clippy::cast_sign_loss)]
     let num_selected = ((len as f64) * selectivity).round() as usize;
 
-    let selection = match pattern {
-        Pattern::Random => {
-            let mut selection = vec![false; len];
-            let mut indices: Vec<usize> = (0..len).collect();
-
-            // Simple deterministic shuffle.
-            for i in (1..len).rev() {
-                let j = (i * 7 + 13) % (i + 1);
-                indices.swap(i, j);
-            }
-
-            for i in 0..num_selected.min(len) {
-                selection[indices[i]] = true;
-            }
-            selection
-        }
-        Pattern::Contiguous => {
-            let mut selection = vec![false; len];
-            let start = (len.saturating_sub(num_selected)) / 2;
-            for i in start..(start + num_selected).min(len) {
-                selection[i] = true;
-            }
-            selection
-        }
-        Pattern::Alternating => {
-            let mut selection = vec![false; len];
-            if num_selected > 0 {
-                let step = len.max(1) / num_selected.max(1);
-                let step = step.max(1);
-                for i in (0..len).step_by(step).take(num_selected) {
-                    selection[i] = true;
-                }
-            }
-            selection
-        }
-    };
+    let mut selection = vec![false; len];
+    let mut indices: Vec<usize> = (0..len).collect();
 
-    Mask::from_iter(selection)
-}
-
-#[divan::bench(types = [u8, u32, u64], args = SELECTIVITIES, sample_count = 1000)]
-fn filter_selectivity<T: Copy + Default + From<u8>>(bencher: Bencher, selectivity: f64) {
-    let mask = generate_mask(BUFFER_SIZE, selectivity, Pattern::Random);
-    bencher
-        .with_inputs(|| {
-            let buffer = create_test_buffer::<T>(BUFFER_SIZE);
-            (buffer, mask.clone())
-        })
-        .bench_values(|(mut buffer, mask)| {
-            buffer.filter(&mask);
-            divan::black_box(buffer);
-        });
-}
-
-#[divan::bench_group(sample_count = 1000)]
-mod patterns_at_threshold {
-    use super::*;
-
-    const SELECTIVITY: f64 = 0.50;
-
-    #[divan::bench]
-    fn random(bencher: Bencher) {
-        let mask = generate_mask(BUFFER_SIZE, SELECTIVITY, Pattern::Random);
-        bencher
-            .with_inputs(|| {
-                let buffer = create_test_buffer::<u32>(BUFFER_SIZE);
-                (buffer, mask.clone())
-            })
-            .bench_values(|(mut buffer, mask)| {
-                buffer.filter(&mask);
-                divan::black_box(buffer);
-            });
+    // Simple deterministic shuffle.
+    for i in (1..len).rev() {
+        let j = (i * 7 + 13) % (i + 1);
+        indices.swap(i, j);
     }
 
-    #[divan::bench]
-    fn contiguous(bencher: Bencher) {
-        let mask = generate_mask(BUFFER_SIZE, SELECTIVITY, Pattern::Contiguous);
-        bencher
-            .with_inputs(|| {
-                let buffer = create_test_buffer::<u32>(BUFFER_SIZE);
-                (buffer, mask.clone())
-            })
-            .bench_values(|(mut buffer, mask)| {
-                buffer.filter(&mask);
-                divan::black_box(buffer);
-            });
+    for i in 0..num_selected.min(len) {
+        selection[indices[i]] = true;
     }
 
-    #[divan::bench]
-    fn alternating(bencher: Bencher) {
-        let mask = generate_mask(BUFFER_SIZE, SELECTIVITY, Pattern::Alternating);
-        bencher
-            .with_inputs(|| {
-                let buffer = create_test_buffer::<u32>(BUFFER_SIZE);
-                (buffer, mask.clone())
-            })
-            .bench_values(|(mut buffer, mask)| {
-                buffer.filter(&mask);
-                divan::black_box(buffer);
-            });
-    }
+    Mask::from_iter(selection)
 }
 
 #[derive(Copy, Clone, Default)]
@@ -168,12 +61,12 @@ impl From<u8> for LargeElement {
     }
 }
 
-#[divan::bench(args = SELECTIVITIES, sample_count = 1000)]
-fn filter_large_element(bencher: Bencher, selectivity: f64) {
-    let mask = generate_mask(BUFFER_SIZE, selectivity, Pattern::Random);
+#[divan::bench(types = [u8, u32, u64, LargeElement], args = SELECTIVITIES, sample_count = 1000)]
+fn filter_selectivity<T: Copy + Default + From<u8>>(bencher: Bencher, selectivity: f64) {
+    let mask = generate_mask(BUFFER_SIZE, selectivity);
     bencher
         .with_inputs(|| {
-            let buffer = create_test_buffer::<LargeElement>(BUFFER_SIZE);
+            let buffer = create_test_buffer::<T>(BUFFER_SIZE);
             (buffer, mask.clone())
         })
         .bench_values(|(mut buffer, mask)| {