feat(cargo-codspeed): add support for --bench target selection

GuillaumeLagrange · GuillaumeLagrange · commit 43a2ff0e04fa · 2025-09-25T16:52:36.000+02:00
diff --git a/crates/cargo-codspeed/src/app.rs b/crates/cargo-codspeed/src/app.rs
@@ -3,7 +3,7 @@ use cargo_metadata::MetadataCommand;
 use clap::{Args, Parser, Subcommand};
 use std::{ffi::OsString, process::exit};
 
-use crate::build::build_benches;
+use crate::build::{build_benches, BuildConfig};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
@@ -35,8 +35,16 @@ pub(crate) struct PackageFilters {
     pub(crate) package: Vec<String>,
 }
 
+#[derive(Args)]
+pub(crate) struct BenchTargetFilters {
+    /// Select only the specified benchmark target (all benchmark targets by default)
+    #[arg(long, help_heading = TARGET_HELP)]
+    pub(crate) bench: Option<Vec<String>>,
+}
+
 const FEATURE_HELP: &str = "Feature Selection";
 const COMPILATION_HELP: &str = "Compilation Options";
+const TARGET_HELP: &str = "Target Selection";
 #[derive(Subcommand)]
 enum Commands {
     /// Build the benchmarks
@@ -63,13 +71,20 @@ enum Commands {
         /// Build the benchmarks with the specified profile
         #[arg(long, default_value = "bench", help_heading = COMPILATION_HELP)]
         profile: String,
+
+        #[command(flatten)]
+        bench_target_filters: BenchTargetFilters,
     },
     /// Run the previously built benchmarks
     Run {
         /// If specified, only run benches containing this string in their names
-        bench_name: Option<String>,
+        benchname: Option<String>,
+
         #[command(flatten)]
         package_filters: PackageFilters,
+
+        #[command(flatten)]
+        bench_target_filters: BenchTargetFilters,
     },
 }
 
@@ -83,6 +98,7 @@ pub fn run(args: impl Iterator<Item = OsString>) -> Result<()> {
     let res = match cli.command {
         Commands::Build {
             package_filters,
+            bench_target_filters,
             features,
             all_features,
             jobs,
@@ -110,18 +126,28 @@ pub fn run(args: impl Iterator<Item = OsString>) -> Result<()> {
                 features.map(|f| f.split([' ', ',']).map(|s| s.to_string()).collect_vec());
             build_benches(
                 &metadata,
-                package_filters,
-                features,
-                profile,
-                cli.quiet,
-                measurement_mode,
-                passthrough_flags,
+                BuildConfig {
+                    package_filters,
+                    bench_target_filters,
+                    features,
+                    profile,
+                    quiet: cli.quiet,
+                    measurement_mode,
+                    passthrough_flags,
+                },
             )
         }
         Commands::Run {
-            bench_name,
+            benchname,
+            package_filters,
+            bench_target_filters,
+        } => run_benches(
+            &metadata,
+            benchname,
             package_filters,
-        } => run_benches(&metadata, bench_name, package_filters, measurement_mode),
+            bench_target_filters,
+            measurement_mode,
+        ),
     };
 
     if let Err(e) = res {
diff --git a/crates/cargo-codspeed/src/build.rs b/crates/cargo-codspeed/src/build.rs
@@ -1,5 +1,5 @@
 use crate::{
-    app::PackageFilters,
+    app::{BenchTargetFilters, PackageFilters},
     helpers::{clear_dir, get_codspeed_target_dir},
     measurement_mode::MeasurementMode,
     prelude::*,
@@ -8,6 +8,7 @@ use cargo_metadata::{camino::Utf8PathBuf, Message, Metadata, TargetKind};
 use std::process::{exit, Command, Stdio};
 
 struct BuildOptions<'a> {
+    bench_target_filters: BenchTargetFilters,
     package_filters: PackageFilters,
     features: &'a Option<Vec<String>>,
     profile: &'a str,
@@ -20,6 +21,16 @@ struct BuiltBench {
     executable_path: Utf8PathBuf,
 }
 
+pub struct BuildConfig {
+    pub package_filters: PackageFilters,
+    pub bench_target_filters: BenchTargetFilters,
+    pub features: Option<Vec<String>>,
+    pub profile: String,
+    pub quiet: bool,
+    pub measurement_mode: MeasurementMode,
+    pub passthrough_flags: Vec<String>,
+}
+
 impl BuildOptions<'_> {
     /// Builds the benchmarks by invoking cargo
     /// Returns a list of built benchmarks, with path to associated executables
@@ -167,7 +178,15 @@ impl BuildOptions<'_> {
     /// This command explicitly ignores the `self.benches`: all benches are built
     fn build_command(&self, measurement_mode: MeasurementMode) -> Command {
         let mut cargo = Command::new("cargo");
-        cargo.args(["build", "--benches"]);
+        cargo.arg("build");
+
+        if let Some(bench_target_filters) = &self.bench_target_filters.bench {
+            for bench_target_filter in bench_target_filters {
+                cargo.args(["--bench", bench_target_filter]);
+            }
+        } else {
+            cargo.args(["--benches"]);
+        }
 
         self.add_rust_flags(&mut cargo, measurement_mode);
 
@@ -205,22 +224,15 @@ impl PackageFilters {
     }
 }
 
-pub fn build_benches(
-    metadata: &Metadata,
-    package_filters: PackageFilters,
-    features: Option<Vec<String>>,
-    profile: String,
-    quiet: bool,
-    measurement_mode: MeasurementMode,
-    passthrough_flags: Vec<String>,
-) -> Result<()> {
+pub fn build_benches(metadata: &Metadata, config: BuildConfig) -> Result<()> {
     let built_benches = BuildOptions {
-        package_filters,
-        features: &features,
-        profile: &profile,
-        passthrough_flags: &passthrough_flags,
+        bench_target_filters: config.bench_target_filters,
+        package_filters: config.package_filters,
+        features: &config.features,
+        profile: &config.profile,
+        passthrough_flags: &config.passthrough_flags,
     }
-    .build(metadata, quiet, measurement_mode)?;
+    .build(metadata, config.quiet, config.measurement_mode)?;
 
     if built_benches.is_empty() {
         bail!(
@@ -229,7 +241,7 @@ pub fn build_benches(
         );
     }
 
-    let codspeed_target_dir = get_codspeed_target_dir(metadata, measurement_mode);
+    let codspeed_target_dir = get_codspeed_target_dir(metadata, config.measurement_mode);
     let built_bench_count = built_benches.len();
 
     // Create and clear packages codspeed target directories
diff --git a/crates/cargo-codspeed/src/run.rs b/crates/cargo-codspeed/src/run.rs
@@ -1,5 +1,7 @@
 use crate::{
-    app::PackageFilters, helpers::get_codspeed_target_dir, measurement_mode::MeasurementMode,
+    app::{BenchTargetFilters, PackageFilters},
+    helpers::get_codspeed_target_dir,
+    measurement_mode::MeasurementMode,
     prelude::*,
 };
 use anyhow::Context;
@@ -15,7 +17,7 @@ use std::os::unix::process::ExitStatusExt;
 
 struct BenchToRun {
     bench_path: PathBuf,
-    bench_name: String,
+    bench_target_name: String,
     working_directory: PathBuf,
     package_name: String,
 }
@@ -47,8 +49,9 @@ impl PackageFilters {
 
     fn benches_to_run(
         &self,
-        codspeed_target_dir: PathBuf,
         metadata: &Metadata,
+        bench_target_filters: BenchTargetFilters,
+        codspeed_target_dir: PathBuf,
     ) -> Result<Vec<BenchToRun>> {
         let packages = self.packages_from_flags(metadata)?;
 
@@ -63,18 +66,23 @@ impl PackageFilters {
                 for entry in read_dir {
                     let entry = entry?;
                     let bench_path = entry.path();
-                    let bench_name = bench_path
+                    let bench_target_name = bench_path
                         .file_name()
                         .unwrap()
                         .to_str()
                         .unwrap()
                         .to_string();
+                    if let Some(bench_target_filter) = &bench_target_filters.bench {
+                        if !bench_target_filter.contains(&bench_target_name) {
+                            continue;
+                        }
+                    }
                     if !bench_path.is_dir() {
                         benches.push(BenchToRun {
                             package_name: package_name.clone(),
                             working_directory: working_directory.into(),
                             bench_path,
-                            bench_name,
+                            bench_target_name,
                         });
                     }
                 }
@@ -89,26 +97,28 @@ pub fn run_benches(
     metadata: &Metadata,
     bench_name_filter: Option<String>,
     package_filters: PackageFilters,
+    bench_target_filters: BenchTargetFilters,
     measurement_mode: MeasurementMode,
 ) -> Result<()> {
     let codspeed_target_dir = get_codspeed_target_dir(metadata, measurement_mode);
     let workspace_root = metadata.workspace_root.as_std_path();
     if measurement_mode == MeasurementMode::Walltime {
         WalltimeResults::clear(workspace_root)?;
     }
-    let benches = package_filters.benches_to_run(codspeed_target_dir, metadata)?;
+    let benches =
+        package_filters.benches_to_run(metadata, bench_target_filters, codspeed_target_dir)?;
     if benches.is_empty() {
         bail!("No benchmarks found. Run `cargo codspeed build` first.");
     }
 
     eprintln!("Collected {} benchmark suite(s) to run", benches.len());
 
     for bench in benches.iter() {
-        let bench_name = &bench.bench_name;
+        let bench_target_name = &bench.bench_target_name;
         // workspace_root is needed since file! returns the path relatively to the workspace root
         // while CARGO_MANIFEST_DIR returns the path to the sub package
         let workspace_root = metadata.workspace_root.clone();
-        eprintln!("Running {} {}", &bench.package_name, bench_name);
+        eprintln!("Running {} {}", &bench.package_name, bench_target_name);
         let mut command = std::process::Command::new(&bench.bench_path);
         command
             .env("CODSPEED_CARGO_WORKSPACE_ROOT", workspace_root)
@@ -146,7 +156,7 @@ pub fn run_benches(
                     }
                 }
             })?;
-        eprintln!("Done running {bench_name}");
+        eprintln!("Done running {bench_target_name}");
     }
     eprintln!("Finished running {} benchmark suite(s)", benches.len());
 
diff --git a/crates/cargo-codspeed/tests/simple-bencher.rs b/crates/cargo-codspeed/tests/simple-bencher.rs
@@ -45,7 +45,7 @@ fn test_simple_build_single() {
     let dir = setup(DIR, Project::Simple);
     cargo_codspeed(&dir)
         .arg("build")
-        .arg("another_bencher_example")
+        .args(["--bench", "another_bencher_example"])
         .assert()
         .success()
         .stderr(contains("Built 1 benchmark suite(s)"))
@@ -58,12 +58,12 @@ fn test_simple_build_and_run_single() {
     let dir = setup(DIR, Project::Simple);
     cargo_codspeed(&dir)
         .arg("build")
-        .arg("another_bencher_example")
+        .args(["--bench", "another_bencher_example"])
         .assert()
         .success();
     cargo_codspeed(&dir)
         .arg("run")
-        .arg("another_bencher_example")
+        .args(["--bench", "another_bencher_example"])
         .assert()
         .success()
         .stderr(contains("Finished running 1 benchmark suite(s)"))
diff --git a/crates/cargo-codspeed/tests/simple-criterion.rs b/crates/cargo-codspeed/tests/simple-criterion.rs
@@ -45,7 +45,7 @@ fn test_criterion_build_single() {
     let dir = setup(DIR, Project::Simple);
     cargo_codspeed(&dir)
         .arg("build")
-        .arg("another_criterion_example")
+        .args(["--bench", "another_criterion_example"])
         .assert()
         .success()
         .stderr(contains("Built 1 benchmark suite(s)"))
@@ -58,19 +58,45 @@ fn test_criterion_build_and_run_single() {
     let dir = setup(DIR, Project::Simple);
     cargo_codspeed(&dir)
         .arg("build")
-        .arg("another_criterion_example")
+        .args(["--bench", "another_criterion_example"])
         .assert()
         .success();
     cargo_codspeed(&dir)
         .arg("run")
-        .arg("another_criterion_example")
+        .args(["--bench", "another_criterion_example"])
         .assert()
         .success()
         .stderr(contains("Finished running 1 benchmark suite(s)"))
         .stderr(contains("another_criterion_example"));
     teardown(dir);
 }
 
+#[test]
+fn test_criterion_build_and_run_filtered_by_name() {
+    let dir = setup(DIR, Project::Simple);
+    cargo_codspeed(&dir).arg("build").assert().success();
+    cargo_codspeed(&dir)
+        .arg("run")
+        .arg("fib 20")
+        .assert()
+        .success()
+        .stderr(contains("Finished running 2 benchmark suite(s)"));
+    teardown(dir);
+}
+
+#[test]
+fn test_criterion_build_and_run_filtered_by_partial_name() {
+    let dir = setup(DIR, Project::Simple);
+    cargo_codspeed(&dir).arg("build").assert().success();
+    cargo_codspeed(&dir)
+        .arg("run")
+        .arg("bubble")
+        .assert()
+        .success()
+        .stderr(contains("Finished running 2 benchmark suite(s)"));
+    teardown(dir);
+}
+
 #[test]
 fn test_criterion_cargo_bench_no_run() {
     let dir = setup(DIR, Project::Simple);
diff --git a/crates/cargo-codspeed/tests/simple-divan.rs b/crates/cargo-codspeed/tests/simple-divan.rs
