Support aggregate bench

Author: SpriteOvO

spdlog/benches/common/mod.rs

@@ -1,6 +1,10 @@
 use std::{
-    env, fs,
+    env,
+    fmt::Write,
+    fs,
     path::{Path, PathBuf},
+    process::{self, Stdio},
+    str,
 };
 
 use once_cell::sync::Lazy;
@@ -47,3 +51,119 @@ macro_rules! required_multi_thread_feature {
         compile_error!("please rerun `cargo bench` with `--features multi-thread`");
     };
 }
+
+#[macro_export]
+macro_rules! aggregate_bench_main {
+    () => {
+        fn main() {
+            common::__aggregate_bench_main_impl(
+                &std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                    .parent()
+                    .unwrap()
+                    .join(file!()),
+            );
+        }
+    };
+}
+
+// Some log crates are based on `log` crate, which has only one global logger
+// instance, meaning that the logger is only allowed to be configured once. In
+// order to bench multiple different configurations, we need multiple child
+// processes to bench, and this function is used as a launcher for those child
+// processes.
+pub fn __aggregate_bench_main_impl(source_file: &Path) {
+    let args = env::args().collect::<Vec<_>>();
+    if args.len() != 2 || args.get(1).unwrap() != "--bench" {
+        eprintln!(
+            "error: this is an aggregate bench and is supposed to be run only by `cargo bench`"
+        );
+        process::exit(1);
+    }
+
+    let current_exe = env::current_exe().unwrap();
+    let current_dir = current_exe.parent().unwrap();
+
+    let name = format!("{}_", env!("CARGO_CRATE_NAME"));
+
+    let mut sub_benches = fs::read_dir(current_dir)
+        .unwrap()
+        .filter_map(|p| p.ok())
+        .filter(|p| {
+            #[cfg(unix)]
+            let is_executable = p.path().metadata().is_ok_and(|m| {
+                use std::os::unix::fs::PermissionsExt;
+                m.is_file() && m.permissions().mode() & 0o111 != 0
+            });
+            #[cfg(windows)]
+            let is_executable = p.path().extension().is_some_and(|ext| ext == "exe");
+
+            p.file_name().to_string_lossy().starts_with(&name) && is_executable
+            // TODO: Test it on Windows
+        })
+        .collect::<Vec<_>>();
+    sub_benches.sort_by_key(|p| p.file_name());
+
+    let mut sub_bench_sources = fs::read_dir(Path::new(source_file).parent().unwrap())
+        .unwrap()
+        .filter_map(|p| p.ok())
+        .filter(|p| {
+            p.file_name()
+                .to_string_lossy()
+                .chars()
+                .next()
+                .is_some_and(|ch| ch.is_ascii_digit())
+                && p.path().extension().is_some_and(|ext| ext == "rs")
+        })
+        .collect::<Vec<_>>();
+    sub_bench_sources.sort_by_key(|p| p.file_name());
+
+    fn exit_as_files_mismatch() {
+        eprintln!(
+            "error: not all expected sub-benches have been built. try running `cargo bench` directly instead of specifying a `--bench` option."
+        );
+        process::exit(1);
+    }
+    if sub_benches.len() != sub_bench_sources.len() {
+        exit_as_files_mismatch();
+    }
+    sub_bench_sources
+        .into_iter()
+        .zip(sub_benches.iter())
+        .for_each(|(source, bin)| {
+            let expected_start = format!(
+                "{}_{}-",
+                env!("CARGO_CRATE_NAME"),
+                source.path().file_stem().unwrap().to_string_lossy()
+            );
+            if !bin
+                .file_name()
+                .to_string_lossy()
+                .starts_with(&expected_start)
+            {
+                exit_as_files_mismatch();
+            }
+        });
+
+    let mut captured_stdout = String::new();
+    for sub_bench in sub_benches {
+        let output = process::Command::new(sub_bench.path())
+            .arg("--bench")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit())
+            .output()
+            .unwrap();
+        assert!(output.status.success());
+
+        captured_stdout
+            .write_str(str::from_utf8(&output.stdout).unwrap())
+            .unwrap();
+    }
+
+    let results = captured_stdout
+        .lines()
+        .filter(|line| line.contains("test ") && line.contains(" ... "))
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    println!("{}", results);
+}