feat: add support for args divan macro argument

Author: GuillaumeLagrange

crates/divan_compat/examples/Cargo.toml

@@ -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", version = "*", path = ".." }
+
+[[bench]]
+name = "math"
+harness = false
+
+[[bench]]
+name = "sort"
+harness = false
+
+[[bench]]
+name = "time"
+harness = false

crates/divan_compat/examples/README.md

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

crates/divan_compat/examples/benches/math.rs

@@ -0,0 +1,115 @@
+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/sort.rs

@@ -0,0 +1,63 @@
+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());
+    }
+}

crates/divan_compat/examples/benches/time.rs

@@ -0,0 +1,97 @@
+use std::time::{Instant, SystemTime};
+
+use divan::{AllocProfiler, Bencher};
+
+#[global_allocator]
+static ALLOC: AllocProfiler = AllocProfiler::system();
+
+fn main() {
+    divan::main();
+}
+
+mod now {
+    use super::*;
+
+    #[divan::bench]
+    fn instant() -> Instant {
+        Instant::now()
+    }
+
+    #[divan::bench]
+    fn system_time() -> SystemTime {
+        SystemTime::now()
+    }
+
+    #[divan::bench(name = if cfg!(target_arch = "aarch64") {
+        "tsc (aarch64)"
+    } else {
+        "tsc (x86)"
+    })]
+    #[cfg(all(
+        not(miri),
+        any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"),
+    ))]
+    pub fn tsc() -> u64 {
+        #[cfg(target_arch = "aarch64")]
+        unsafe {
+            let timestamp: u64;
+            std::arch::asm!(
+                "mrs {}, cntvct_el0",
+                out(reg) timestamp,
+                // Leave off `nomem` because this should be a compiler fence.
+                options(nostack, preserves_flags),
+            );
+            timestamp
+        }
+
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        unsafe {
+            #[cfg(target_arch = "x86")]
+            use std::arch::x86;
+            #[cfg(target_arch = "x86_64")]
+            use std::arch::x86_64 as x86;
+
+            x86::_rdtsc()
+        }
+    }
+}
+
+mod duration_since {
+    use super::*;
+
+    #[divan::bench]
+    fn instant(bencher: Bencher) {
+        bencher
+            .with_inputs(|| [Instant::now(), Instant::now()])
+            .bench_values(|[start, end]| end.duration_since(start));
+    }
+
+    #[divan::bench]
+    fn system_time(bencher: Bencher) {
+        bencher
+            .with_inputs(|| [SystemTime::now(), SystemTime::now()])
+            .bench_values(|[start, end]| end.duration_since(start));
+    }
+
+    #[divan::bench(name = if cfg!(target_arch = "aarch64") {
+        "tsc (aarch64)"
+    } else {
+        "tsc (x86)"
+    })]
+    #[cfg(all(
+        not(miri),
+        any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"),
+    ))]
+    fn tsc(bencher: Bencher) {
+        bencher
+            .with_inputs(|| [crate::now::tsc(), crate::now::tsc()])
+            .bench_values(|[start, end]| {
+                // Simply subtract because an optimized timing implementation
+                // would want to keep the value as TSC units for as long as
+                // possible before dividing by the TSC frequency.
+                //
+                // Saturating arithmetic to ensures monotonicity.
+                end.saturating_sub(start)
+            })
+    }
+}

crates/divan_compat/examples/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("cargo:rustc-check-cfg=cfg(codspeed)");
+}