update benches

Author: RagnarGrootKoerkamp

Cargo.lock

@@ -26,6 +26,7 @@ authors = ["Ragnar Groot Koerkamp", "Igor Martayan"]
 description = "A SIMD-accelerated library to compute random minimizers"
 
 [dependencies]
+clap = { version = "4.5.47", features = ["derive"] }
 itertools = "0.14"
 packed-seq.workspace = true
 seq-hash.workspace = true

Cargo.toml

@@ -1,55 +1,96 @@
+use clap::Parser;
 use packed_seq::SeqVec;
 use seq_hash::{NtHasher, SeqHasher};
+use simd_minimizers::private::sliding_min::Cache;
+
+#[derive(clap::Parser)]
+struct Args {
+    #[arg(short)]
+    a: bool,
+    #[arg(short)]
+    b: bool,
+    #[arg(short)]
+    c: bool,
+    #[arg(short)]
+    d: bool,
+
+    #[arg(short)]
+    n: Option<usize>,
+}
 
 fn main() {
     let k = 9;
     let w = 19;
 
+    let Args { a, b, c, d, n } = Args::parse();
+
+    let ns = n.map(|n| vec![n]).unwrap_or( vec![50, 150, 300, 1000, 10000, 100000]);
+
     eprintln!("      n   fwd simd/scalar   can simd/scalar");
-    for n in [50, 100, 150, 500, 10000, 100000, 1000000] {
-        let seq = packed_seq::PackedSeqVec::random(n);
+    for n in ns {
         eprint!("{n:>7}: ");
 
-        let time = bench(w, n, &seq, &NtHasher::<false>::new(k), false, true);
-        eprint!("  {:5.2}", time);
-        let time = bench(w, n, &seq, &NtHasher::<false>::new(k), false, false);
-        eprint!(" {:5.2}", time);
+        if a {
+            let time = bench(w, n, &NtHasher::<false>::new(k), false, true);
+            eprint!("  {:5.2}", time);
+        }
+        if b {
+            let time = bench(w, n, &NtHasher::<false>::new(k), false, false);
+            eprint!(" {:5.2}", time);
+        }
 
-        let time = bench(w, n, &seq, &NtHasher::<true>::new(k), true, true);
-        eprint!("        {:5.2}", time);
-        let time = bench(w, n, &seq, &NtHasher::<true>::new(k), true, false);
-        eprint!(" {:5.2}", time);
+        if c {
+            let time = bench(w, n, &NtHasher::<true>::new(k), true, true);
+            eprint!("        {:5.2}", time);
+        }
+        if d {
+            let time = bench(w, n, &NtHasher::<true>::new(k), true, false);
+            eprint!(" {:5.2}", time);
+        }
         eprintln!();
     }
 }
 
 fn bench(
     w: usize,
     n: usize,
-    seq: &packed_seq::PackedSeqVec,
     hasher: &impl SeqHasher,
     canonical: bool,
     simd: bool,
 ) -> f32 {
-    let total = 100_000_000;
+    let total = 150_000_000;
     let samples = total / n;
 
     let poss = &mut vec![];
     let mut times = vec![];
+    let mut cache = Cache::default();
     for _ in 0..samples {
+        let seq = packed_seq::PackedSeqVec::random(n);
         poss.clear();
         let s = std::time::Instant::now();
         if simd {
             if canonical {
-                simd_minimizers::canonical_minimizer_positions(seq.as_slice(), hasher, w, poss);
+                simd_minimizers::canonical_minimizer_positions(seq.as_slice(), hasher, w, poss, &mut cache);
             } else {
-                simd_minimizers::minimizer_positions(seq.as_slice(), hasher, w, poss);
+                simd_minimizers::minimizer_positions(seq.as_slice(), hasher, w, poss, &mut cache);
             }
         } else {
             if canonical {
-                simd_minimizers::scalar::canonical_minimizer_positions_scalar(seq.as_slice(), hasher, w, poss);
+                simd_minimizers::scalar::canonical_minimizer_positions_scalar(
+                    seq.as_slice(),
+                    hasher,
+                    w,
+                    poss,
+                    &mut cache
+                );
             } else {
-                simd_minimizers::scalar::minimizer_positions_scalar(seq.as_slice(), hasher, w, poss);
+                simd_minimizers::scalar::minimizer_positions_scalar(
+                    seq.as_slice(),
+                    hasher,
+                    w,
+                    poss,
+                    &mut cache
+                );
             }
         }
         times.push(s.elapsed().as_nanos());