feat(divan_compat): add divan_compat initial implementation

Author: GuillaumeLagrange

Cargo.lock

@@ -4,5 +4,7 @@ members = [
     "crates/bencher_compat",
     "crates/criterion_compat",
     "crates/cargo-codspeed",
+    "crates/divan_compat",
+    "crates/divan_compat/macros",
 ]
 resolver = "2"

Cargo.toml

@@ -13,4 +13,5 @@ This mono-repo contains the integration crates for using CodSpeed in Rust:
 - [`cargo-codspeed`](./crates/cargo-codspeed/): A cargo subcommand for running CodSpeed on your project
 - [`codspeed-criterion-compat`](./crates/criterion_compat/): Criterion.rs compatibility layer for CodSpeed
 - [`codspeed-bencher-compat`](./crates/bencher_compat/): Bencher compatibility layer for CodSpeed
+- [`codspeed-divan-compat`](./crates/divan_compat/): Divan compatibility layer for CodSpeed
 - [`codspeed`](./crates/codspeed/): The core library used to integrate with Codspeed runners

README.md

@@ -0,0 +1,27 @@
+[package]
+name = "codspeed-divan-compat"
+version = "2.7.2"
+rust-version = "1.74" # MSRV TODO: Check versioning
+edition = "2021"
+description = "Bencher compatibility layer for CodSpeed"
+authors = ["Arthur Pastel <[email protected]>"]
+documentation = "https://docs.codspeed.io"
+readme = "README.md"
+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",
+]
+keywords = ["codspeed", "benchmark", "divan"]
+
+[dependencies]
+codspeed = { path = "../codspeed", version = "=2.7.2" }
+divan = "0.1.17"
+codspeed-divan-compat-macros = { version = "=2.7.2", path = './macros' }
+
+[[bench]]
+name = "basic_example"
+harness = false

crates/divan_compat/Cargo.toml

@@ -0,0 +1 @@
+TODO

crates/divan_compat/README.md

@@ -0,0 +1,29 @@
+use codspeed_divan_compat as divan;
+
+fn fibo(n: i32) -> i32 {
+    let mut a = 0;
+    let mut b = 1;
+
+    for _ in 0..n {
+        let tmp = a;
+        a = b;
+        b += tmp;
+    }
+
+    a
+}
+
+#[divan::bench]
+fn fibo_500() -> i32 {
+    divan::black_box(fibo(500))
+}
+
+#[divan::bench]
+fn fibo_100() -> i32 {
+    divan::black_box(fibo(10))
+}
+
+fn main() {
+    // Run `add` benchmark:
+    divan::main();
+}

crates/divan_compat/benches/basic_example.rs

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

crates/divan_compat/build.rs

@@ -0,0 +1,28 @@
+[package]
+name = "codspeed-divan-compat-macros"
+version = "2.7.2"
+rust-version = "1.74" # MSRV TODO: Check versioning
+edition = "2021"
+description = "Bencher compatibility layer for CodSpeed"
+authors = ["Arthur Pastel <[email protected]>"]
+documentation = "https://docs.codspeed.io"
+readme = "../README.md"
+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",
+]
+keywords = ["codspeed", "benchmark", "divan"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+divan-macros = { version = "=0.1.17" }
+proc-macro2 = "1"
+quote = { version = "1", default-features = false }
+# Versions prior to *.18 fail to parse empty attribute metadata.
+syn = { version = "^2.0.18", default-features = false, features = ["full", "clone-impls", "parsing", "printing", "proc-macro"] }

crates/divan_compat/macros/Cargo.toml

@@ -0,0 +1,47 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    parse::Parse, parse_macro_input, punctuated::Punctuated, ItemFn, Meta, MetaNameValue, Token,
+};
+
+struct MyBenchArgs {
+    args: Punctuated<Meta, Token![,]>,
+}
+
+impl Parse for MyBenchArgs {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            args: Punctuated::parse_terminated(input)?,
+        })
+    }
+}
+
+#[proc_macro_attribute]
+pub fn bench_compat(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let parsed_args = parse_macro_input!(attr as MyBenchArgs);
+    let input = parse_macro_input!(item as ItemFn);
+
+    let mut filtered_args = Vec::new();
+
+    for arg in parsed_args.args {
+        match &arg {
+            Meta::NameValue(MetaNameValue { path, .. }) if path.is_ident("crate") => {
+                return quote! {
+                    compile_error!("crate argument is not supported with codspeed_divan_compat");
+                }
+                .into();
+            }
+            _ => filtered_args.push(arg),
+        }
+    }
+
+    filtered_args.push(syn::parse_quote!(crate = ::codspeed_divan_compat));
+
+    // Important: keep macro name in sync with re-exported macro name in divan-compat lib
+    let expanded = quote! {
+        #[::codspeed_divan_compat::bench_original(#(#filtered_args),*)]
+        #input
+    };
+
+    TokenStream::from(expanded)
+}

crates/divan_compat/macros/src/lib.rs

@@ -0,0 +1,44 @@
+//! Handpicked stubs from [divan::entry](https://github.com/nvzqz/divan/blob/main/src/entry/mod.rs)
+//! Minimally reimplemented in an API compatible way to run the benches using codspeed intrumentation
+use codspeed::codspeed::CodSpeed;
+use std::{cell::RefCell, rc::Rc};
+
+/// Benchmarking options set directly by the user in `#[divan::bench]` and
+/// `#[divan::bench_group]`.
+///
+/// Changes to fields must be reflected in the "Options" sections of the docs
+/// for `#[divan::bench]` and `#[divan::bench_group]`.
+#[derive(Default)]
+pub struct BenchOptions<'a> {
+    pub(crate) _marker: std::marker::PhantomData<&'a ()>,
+}
+
+pub struct Bencher<'a, 'b> {
+    pub(crate) codspeed: Rc<RefCell<CodSpeed>>,
+    pub(crate) uri: String,
+    pub(crate) _marker: std::marker::PhantomData<&'a &'b ()>,
+}
+
+#[allow(clippy::needless_lifetimes)]
+impl<'a, 'b> Bencher<'a, 'b> {
+    pub(crate) fn new(uri: String) -> Self {
+        Self {
+            codspeed: Rc::new(RefCell::new(CodSpeed::new())),
+            uri,
+            _marker: std::marker::PhantomData,
+        }
+    }
+}
+
+#[allow(clippy::needless_lifetimes)]
+impl<'a, 'b> Bencher<'a, 'b> {
+    pub fn bench<O, B>(&self, benched: B)
+    where
+        B: Fn() -> O + Sync,
+    {
+        let mut codspeed = self.codspeed.borrow_mut();
+        codspeed.start_benchmark(self.uri.as_str());
+        divan::black_box(benched());
+        codspeed.end_benchmark();
+    }
+}