full parameter set in bench

benches/my_benchmark.rs

@@ -5,25 +5,38 @@ use preemptive_iterator::{AsyncIterator, PreemptiveIterator};
 use std::hint::black_box;
 
 pub fn criterion_benchmark(c: &mut Criterion) {
-    let n_iters = [100];
-    // let n_iters = [100, 1_000, 10_000];
-    let task_dur = 10;
-    let reac = 10;
-    let reac_d = Duration::from_micros(reac);
+    // let n_iters = [100];
+    let n_iters = [100, 1_000, 10_000];
+    let task_durs = [10, 100, 1000];
+    let reacs = [10];
     let mut group = c.benchmark_group("Iterator");
     for n_iter in n_iters {
-        group.bench_function(BenchmarkId::new("Preemptive", n_iter), |b| {
-            b.iter(|| preemptive(n_iter, task_dur, reac_d))
-        });
-        group.bench_function(BenchmarkId::new("Preemptive2", n_iter), |b| {
-            b.iter(|| preemptive2(n_iter, task_dur, reac_d))
-        });
-        group.bench_function(BenchmarkId::new("PreemptiveFixed", n_iter), |b| {
-            b.iter(|| preemptive_fixed(n_iter, task_dur, reac as usize))
-        });
-        group.bench_function(BenchmarkId::new("Baseline", n_iter), |b| {
-            b.iter(|| baseline(n_iter, task_dur))
-        });
+        for task_dur in task_durs {
+            for reac in reacs {
+                let reac_d = Duration::from_micros(reac);
+                let params_id = format!("_iter{}_task_{}_reac{}", n_iter, task_dur, reac);
+                group.bench_function(BenchmarkId::new("Preemptive", &params_id), |b| {
+                    b.iter(|| preemptive(n_iter, task_dur, reac_d))
+                });
+                group.bench_function(BenchmarkId::new("Preemptive2", &params_id), |b| {
+                    b.iter(|| preemptive2(n_iter, task_dur, reac_d))
+                });
+                // Just choose block size with the number of micro seconds in reactivity
+                // This is dumb in most cases
+                group.bench_function(BenchmarkId::new("PreemptiveFixedDummy", &params_id), |b| {
+                    b.iter(|| preemptive_fixed(n_iter, task_dur, reac as usize))
+                });
+                // from previous bench it takes approximately 6 or 7 ns for each call to work(10)
+                // so X micro seconds should take (1000 * X) / (0.7 * task_dur) iterations
+                let reac_fix = (reac * 1000 / (7 * (task_dur as u64))) as usize;
+                group.bench_function(BenchmarkId::new("PreemptiveFixedSmart", &params_id), |b| {
+                    b.iter(|| preemptive_fixed(n_iter, task_dur, reac_fix))
+                });
+                group.bench_function(BenchmarkId::new("Baseline", &params_id), |b| {
+                    b.iter(|| baseline(n_iter, task_dur))
+                });
+            }
+        }
     }
     group.finish();
 }