Add cachegrind runtime profiler

Author: Kobzol

collector/src/bin/collector.rs

@@ -30,9 +30,10 @@ use tokio::runtime::Runtime;
 
 use collector::compile::execute::bencher::BenchProcessor;
 use collector::compile::execute::profiler::{ProfileProcessor, Profiler};
+use collector::runtime::profile_runtime;
 use collector::runtime::{
-    bench_runtime, prepare_runtime_benchmark_suite, profile_runtime, runtime_benchmark_dir,
-    BenchmarkFilter, BenchmarkSuite, BenchmarkSuiteCompilation, CargoIsolationMode,
+    bench_runtime, prepare_runtime_benchmark_suite, runtime_benchmark_dir, BenchmarkFilter,
+    BenchmarkSuite, BenchmarkSuiteCompilation, CargoIsolationMode, RuntimeProfiler,
     DEFAULT_RUNTIME_ITERATIONS,
 };
 use collector::toolchain::{
@@ -496,8 +497,11 @@ enum Commands {
 
     /// Profiles a runtime benchmark.
     ProfileRuntime {
-        #[command(flatten)]
-        local: LocalOptions,
+        /// Profiler to use
+        profiler: RuntimeProfiler,
+
+        /// The path to the local rustc used to compile the runtime benchmark
+        rustc: String,
 
         /// Name of the benchmark that should be profiled
         benchmark: String,
@@ -682,15 +686,27 @@ fn main_result() -> anyhow::Result<i32> {
             run_benchmarks(&mut rt, conn, shared, None, Some(config))?;
             Ok(0)
         }
-        Commands::ProfileRuntime { local, benchmark } => {
-            let toolchain = get_local_toolchain_for_runtime_benchmarks(&local, &target_triple)?;
+        Commands::ProfileRuntime {
+            profiler,
+            rustc,
+            benchmark,
+        } => {
+            let toolchain = get_local_toolchain(
+                &[Profile::Opt],
+                &rustc,
+                None,
+                None,
+                None,
+                "",
+                target_triple.to_string(),
+            )?;
             let suite = prepare_runtime_benchmark_suite(
                 &toolchain,
                 &runtime_benchmark_dir,
                 CargoIsolationMode::Cached,
             )?
             .suite;
-            profile_runtime(suite, &benchmark)?;
+            profile_runtime(profiler, suite, &benchmark)?;
             Ok(0)
         }
         Commands::BenchLocal {

collector/src/runtime/mod.rs

@@ -14,9 +14,12 @@ pub use benchmark::{
 use database::{ArtifactIdNumber, CollectionId, Connection};
 
 use crate::utils::git::get_rustc_perf_commit;
-use crate::{run_command, run_command_with_output, CollectorCtx};
+use crate::{run_command_with_output, CollectorCtx};
 
 mod benchmark;
+mod profile;
+
+pub use profile::{profile_runtime, RuntimeProfiler};
 
 pub const DEFAULT_RUNTIME_ITERATIONS: u32 = 5;
 
@@ -106,16 +109,6 @@ pub async fn bench_runtime(
     Ok(())
 }
 
-pub fn profile_runtime(suite: BenchmarkSuite, benchmark: &str) -> anyhow::Result<()> {
-    let Some(group) = suite.get_group_by_benchmark(benchmark) else {
-        return Err(anyhow::anyhow!("Benchmark `{benchmark}` not found"));
-    };
-    let mut cmd = prepare_command(&group.binary);
-    cmd.arg("profile").arg(benchmark);
-    run_command(&mut cmd)?;
-    Ok(())
-}
-
 /// Prepares a command for execution, adding some shared flags.
 fn prepare_command<S: AsRef<OsStr>>(binary: S) -> Command {
     // Turn off ASLR

collector/src/runtime/profile.rs

@@ -0,0 +1,49 @@
+use std::fs::create_dir_all;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+use anyhow::Context;
+
+use crate::command_output;
+use crate::runtime::BenchmarkSuite;
+
+#[derive(Clone, Debug, clap::ValueEnum)]
+pub enum RuntimeProfiler {
+    Cachegrind,
+}
+
+pub fn profile_runtime(
+    profiler: RuntimeProfiler,
+    suite: BenchmarkSuite,
+    benchmark: &str,
+) -> anyhow::Result<()> {
+    let Some(group) = suite.get_group_by_benchmark(benchmark) else {
+        return Err(anyhow::anyhow!("Benchmark `{benchmark}` not found"));
+    };
+
+    let result_dir = Path::new("results");
+    create_dir_all(result_dir)?;
+
+    let (mut cmd, out_file) = match profiler {
+        RuntimeProfiler::Cachegrind => {
+            let out_file = result_dir.join(format!("cgout-{benchmark}"));
+            let mut cmd = Command::new("valgrind");
+            cmd.arg("--tool=cachegrind")
+                .arg("--branch-sim=no")
+                .arg("--cache-sim=no")
+                .arg(format!("--cachegrind-out-file={}", out_file.display()));
+            (cmd, out_file)
+        }
+    };
+    cmd.stdin(Stdio::null());
+
+    cmd.arg(&group.binary).arg("profile").arg(benchmark);
+    command_output(&mut cmd).context("Cannot run profiler")?;
+
+    println!(
+        "Profiling complete, result can be found in `{}`",
+        out_file.display()
+    );
+
+    Ok(())
+}