feat(divan): add benchmark filtering in instrumentation mode

Author: GuillaumeLagrange

Cargo.lock

@@ -11,16 +11,16 @@ repository = "https://github.com/CodSpeedHQ/codspeed-rust"
 homepage = "https://codspeed.io"
 license = "MIT OR Apache-2.0"
 categories = [
-    "development-tools",
-    "development-tools::cargo-plugins",
-    "development-tools::profiling",
-    "development-tools::testing",
+  "development-tools",
+  "development-tools::cargo-plugins",
+  "development-tools::profiling",
+  "development-tools::testing",
 ]
 keywords = ["codspeed", "benchmark", "cargo"]
 
 [dependencies]
 cargo_metadata = "0.19.2"
-clap = { version = "=4.5.17", features = ["derive", "env"] }
+clap = { version = ">=4.5.17", features = ["derive", "env"] }
 termcolor = "1.4"
 anyhow = { workspace = true }
 itertools = { workspace = true }

crates/cargo-codspeed/Cargo.toml

@@ -21,6 +21,8 @@ keywords = ["codspeed", "benchmark", "divan"]
 codspeed = { path = "../codspeed", version = "=3.0.5" }
 divan = { package = "codspeed-divan-compat-walltime", path = "./divan_fork", version = "=3.0.5" }
 codspeed-divan-compat-macros = { version = "=3.0.5", path = './macros' }
+regex = "1.11.3"
+clap = "4.5.48"
 
 [[bench]]
 name = "basic_example"

crates/divan_compat/Cargo.toml

@@ -0,0 +1,20 @@
+use clap::{Arg, ArgAction, Command};
+
+pub(crate) fn command() -> Command {
+    fn option(name: &'static str) -> Arg {
+        Arg::new(name).long(name)
+    }
+
+    fn flag(name: &'static str) -> Arg {
+        option(name).action(ArgAction::SetTrue)
+    }
+
+    Command::new("divan")
+        .arg(
+            Arg::new("filter")
+                .value_name("FILTER")
+                .help("Only run benchmarks whose names match this pattern")
+                .action(ArgAction::Append),
+        )
+        .arg(flag("exact").help("Filter benchmarks by exact name rather than by pattern"))
+}

crates/divan_compat/src/compat/cli.rs

@@ -0,0 +1,17 @@
+use regex::Regex;
+
+/// Filters which benchmark to run based on name.
+pub(crate) enum Filter {
+    Regex(Regex),
+    Exact(String),
+}
+
+impl Filter {
+    /// Returns `true` if a string matches this filter.
+    pub fn is_match(&self, s: &str) -> bool {
+        match self {
+            Self::Regex(r) => r.is_match(s),
+            Self::Exact(e) => e == s,
+        }
+    }
+}

crates/divan_compat/src/compat/config.rs

@@ -13,15 +13,18 @@ pub mod __private {
 }
 
 mod bench;
+mod cli;
+mod config;
 mod entry;
 mod uri;
 mod util;
 
-use std::{cell::RefCell, rc::Rc};
-
 pub use bench::*;
 use codspeed::codspeed::CodSpeed;
+use config::Filter;
 use entry::AnyBenchEntry;
+use regex::Regex;
+use std::{cell::RefCell, rc::Rc};
 
 pub fn main() {
     // Outlined steps of original divan::main and their equivalent in codspeed instrumented mode
@@ -46,8 +49,37 @@ pub fn main() {
     // codspeed URI from entry metadata directly.
 
     // 3. Filtering
-    // We do not support finer filtering that bench targets for now, do nothing here, bench
-    // filtering is managed by the `cargo-codspeed` wrappers before we reach this point.
+    let should_run_benchmark_from_filters = {
+        let mut command = cli::command();
+        let matches = command.get_matches_mut();
+        let is_exact = matches.get_flag("exact");
+
+        let parse_filter = |filter: &String| {
+            if is_exact {
+                Filter::Exact(filter.to_owned())
+            } else {
+                match Regex::new(filter) {
+                    Ok(r) => Filter::Regex(r),
+                    Err(error) => {
+                        let kind = clap::error::ErrorKind::ValueValidation;
+                        command.error(kind, error).exit();
+                    }
+                }
+            }
+        };
+
+        let filters: Option<Vec<Filter>> = matches
+            .get_many::<String>("filter")
+            .map(|arg_filters| arg_filters.map(parse_filter).collect());
+
+        move |uri: &str| {
+            if let Some(filters) = filters.as_ref() {
+                filters.iter().any(|filter| filter.is_match(uri))
+            } else {
+                true
+            }
+        }
+    };
 
     // 4. Scan the tree and execute benchmarks
     let codspeed = Rc::new(RefCell::new(CodSpeed::new()));
@@ -66,6 +98,10 @@ pub fn main() {
             entry::BenchEntryRunner::Plain(bench_fn) => {
                 let uri = uri::generate(&entry, entry.display_name());
 
+                if !should_run_benchmark_from_filters(&uri) {
+                    continue;
+                }
+
                 bench_fn(bench::Bencher::new(&codspeed, uri));
             }
             entry::BenchEntryRunner::Args(bench_runner) => {
@@ -74,6 +110,10 @@ pub fn main() {
                 for (arg_index, arg_name) in bench_runner.arg_names().iter().enumerate() {
                     let uri = uri::generate(&entry, arg_name);
 
+                    if !should_run_benchmark_from_filters(&uri) {
+                        continue;
+                    }
+
                     let bencher = bench::Bencher::new(&codspeed, uri);
 
                     bench_runner.bench(bencher, arg_index);