feat(divan_compat): add support for args divan macro argument, add more examples

Author: GuillaumeLagrange

Cargo.lock

@@ -1,12 +1,14 @@
 [workspace]
 members = [
-    "crates/codspeed",
-    "crates/bencher_compat",
-    "crates/criterion_compat",
-    "crates/cargo-codspeed",
-    "crates/divan_compat",
-    "crates/divan_compat/macros",
-    "crates/divan_compat/divan_fork",
+  "crates/codspeed",
+  "crates/bencher_compat",
+  "crates/criterion_compat",
+  "crates/cargo-codspeed",
+
+  "crates/divan_compat",
+  "crates/divan_compat/macros",
+  "crates/divan_compat/divan_fork",
+  "crates/divan_compat/examples",
 ]
 resolver = "2"
 

Cargo.toml

@@ -11,9 +11,9 @@ repository = "https://github.com/CodSpeedHQ/codspeed-rust"
 homepage = "https://codspeed.io"
 license = "MIT OR Apache-2.0"
 categories = [
-    "development-tools",
-    "development-tools::profiling",
-    "development-tools::testing",
+  "development-tools",
+  "development-tools::profiling",
+  "development-tools::testing",
 ]
 keywords = ["codspeed", "benchmark", "divan"]
 

crates/divan_compat/Cargo.toml

@@ -1,5 +1,3 @@
-use codspeed_divan_compat as divan;
-
 fn fibo(n: i32) -> i32 {
     let mut a = 0;
     let mut b = 1;
@@ -13,17 +11,16 @@ fn fibo(n: i32) -> i32 {
     a
 }
 
-#[divan::bench]
+#[codspeed_divan_compat::bench]
 fn fibo_500() -> i32 {
-    divan::black_box(fibo(500))
+    codspeed_divan_compat::black_box(fibo(500))
 }
 
-#[divan::bench]
-fn fibo_100() -> i32 {
-    divan::black_box(fibo(10))
+#[codspeed_divan_compat::bench]
+fn fibo_10() -> i32 {
+    codspeed_divan_compat::black_box(fibo(10))
 }
 
 fn main() {
-    // Run `add` benchmark:
-    divan::main();
+    codspeed_divan_compat::main();
 }

crates/divan_compat/benches/basic_example.rs

@@ -0,0 +1,23 @@
+[package]
+name = "codspeed-divan-compat-examples"
+version = "0.0.0"
+edition = "2021"
+description = "Examples for Divan, a comfy benchmarking framework."
+publish = false
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+fastrand = "2.3.0"
+divan = { package = "codspeed-divan-compat", path = ".." }
+
+[[bench]]
+name = "math"
+harness = false
+
+[[bench]]
+name = "sort"
+harness = false
+
+[[bench]]
+name = "time"
+harness = false

crates/divan_compat/examples/Cargo.toml

@@ -0,0 +1,3 @@
+# Example benchmarks
+
+Mostly copied from [divan's examples](https://github.com/nvzqz/divan/tree/main/examples).

crates/divan_compat/examples/README.md

@@ -0,0 +1,116 @@
+//! Copied from divan's exmaples
+use divan::black_box;
+use std::collections::{BTreeMap, HashMap};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench]
+fn add() -> i32 {
+    black_box(2) + black_box(1)
+}
+
+#[divan::bench]
+#[ignore]
+fn sub() -> i32 {
+    black_box(2) - black_box(1)
+}
+
+#[divan::bench]
+fn mul() -> i32 {
+    black_box(2) * black_box(1)
+}
+
+#[divan::bench]
+fn div() -> i32 {
+    black_box(2) / black_box(1)
+}
+
+#[divan::bench]
+fn rem() -> i32 {
+    black_box(2) % black_box(1)
+}
+
+// 1, 1, 2, 3, 5, ...
+mod fibonacci {
+    use super::*;
+
+    const VALUES: &[u64] = &[0, 5, 10, 20, 30];
+
+    // O(n)
+    #[divan::bench(args = VALUES)]
+    fn iterative(n: u64) -> u64 {
+        let mut previous = 1;
+        let mut current = 1;
+
+        for _ in 2..=n {
+            let next = previous + current;
+            previous = current;
+            current = next;
+        }
+
+        current
+    }
+
+    // O(2^n)
+    #[divan::bench(args = VALUES, max_time = 1)]
+    fn recursive(n: u64) -> u64 {
+        if n <= 1 {
+            1
+        } else {
+            recursive(n - 2) + recursive(n - 1)
+        }
+    }
+
+    #[allow(dead_code)]
+    trait Map: Default {
+        fn get(&self, key: u64) -> Option<u64>;
+        fn set(&mut self, key: u64, value: u64);
+    }
+
+    impl Map for HashMap<u64, u64> {
+        fn get(&self, key: u64) -> Option<u64> {
+            self.get(&key).copied()
+        }
+
+        fn set(&mut self, key: u64, value: u64) {
+            self.insert(key, value);
+        }
+    }
+
+    impl Map for BTreeMap<u64, u64> {
+        fn get(&self, key: u64) -> Option<u64> {
+            self.get(&key).copied()
+        }
+
+        fn set(&mut self, key: u64, value: u64) {
+            self.insert(key, value);
+        }
+    }
+
+    // Will be ignored in instrumented mode as we do not support type generics yet
+    // O(n)
+    #[cfg(not(codspeed))]
+    #[divan::bench(
+        types = [BTreeMap<u64, u64>, HashMap<u64, u64>],
+        args = VALUES,
+    )]
+    fn recursive_memoized<M: Map>(n: u64) -> u64 {
+        fn fibonacci<M: Map>(n: u64, cache: &mut M) -> u64 {
+            if let Some(result) = cache.get(n) {
+                return result;
+            }
+
+            if n <= 1 {
+                return 1;
+            }
+
+            let result = fibonacci(n - 2, cache) + fibonacci(n - 1, cache);
+            cache.set(n, result);
+            result
+        }
+
+        fibonacci(n, &mut M::default())
+    }
+}

crates/divan_compat/examples/benches/math.rs

@@ -0,0 +1,64 @@
+//! Copied from divan's exmaples
+use divan::{AllocProfiler, Bencher};
+
+#[global_allocator]
+static ALLOC: AllocProfiler = AllocProfiler::system();
+
+fn main() {
+    divan::main();
+}
+
+/// Functions that generate deterministic values.
+mod gen {
+    pub const LEN: usize = 100_000;
+
+    pub fn rand_int_generator() -> impl FnMut() -> i32 {
+        let mut rng = fastrand::Rng::with_seed(42);
+        move || rng.i32(..)
+    }
+
+    pub fn rand_int_vec_generator() -> impl FnMut() -> Vec<i32> {
+        let mut rand_int_generator = rand_int_generator();
+        move || (0..LEN).map(|_| rand_int_generator()).collect()
+    }
+
+    pub fn sorted_int_vec_generator() -> impl FnMut() -> Vec<i32> {
+        move || (0..LEN).map(|i| i as i32).collect()
+    }
+}
+
+mod random {
+    use super::*;
+
+    #[divan::bench]
+    fn sort(bencher: Bencher) {
+        bencher
+            .with_inputs(gen::rand_int_vec_generator())
+            .bench_local_refs(|v| v.sort());
+    }
+
+    #[divan::bench]
+    fn sort_unstable(bencher: Bencher) {
+        bencher
+            .with_inputs(gen::rand_int_vec_generator())
+            .bench_local_refs(|v| v.sort_unstable());
+    }
+}
+
+mod sorted {
+    use super::*;
+
+    #[divan::bench]
+    fn sort(bencher: Bencher) {
+        bencher
+            .with_inputs(gen::sorted_int_vec_generator())
+            .bench_local_refs(|v| v.sort());
+    }
+
+    #[divan::bench]
+    fn sort_unstable(bencher: Bencher) {
+        bencher
+            .with_inputs(gen::sorted_int_vec_generator())
+            .bench_local_refs(|v| v.sort_unstable());
+    }
+}