Share target directories between benchmarks

Author: Mark-Simulacrum

collector/src/execute.rs

@@ -1005,24 +1005,24 @@ impl Benchmark {
     pub fn measure(
         &self,
         processor: &mut dyn Processor,
-        build_kinds: &[BuildKind],
+        build_kinds_and_target_dir: &[(BuildKind, &Path)],
         run_kinds: &[RunKind],
         compiler: Compiler<'_>,
         iterations: usize,
     ) -> anyhow::Result<()> {
         let iterations = cmp::min(iterations, self.config.runs);
 
-        if self.config.disabled || build_kinds.is_empty() {
+        if self.config.disabled || build_kinds_and_target_dir.is_empty() {
             eprintln!("Skipping {}: disabled", self.name);
             bail!("disabled benchmark");
         }
 
         eprintln!("Preparing {}", self.name);
 
         // These directories are *target* directories.
-        let build_kind_dirs = build_kinds
+        let build_kind_dirs = build_kinds_and_target_dir
             .iter()
-            .map(|kind| Ok((*kind, TempDir::new()?, self.make_temp_dir(&self.path)?)))
+            .map(|(kind, target_dir)| Ok((*kind, target_dir, self.make_temp_dir(&self.path)?)))
             .collect::<anyhow::Result<Vec<_>>>()?;
 
         // In parallel (but with a limit to the number of CPUs), prepare all
@@ -1051,7 +1051,7 @@ impl Benchmark {
             for (build_kind, target_dir, src_dir) in &build_kind_dirs {
                 let server = server.clone();
                 s.spawn::<_, anyhow::Result<()>>(move |_| {
-                    self.mk_cargo_process(compiler, target_dir.path(), src_dir.path(), *build_kind)
+                    self.mk_cargo_process(compiler, target_dir, src_dir.path(), *build_kind)
                         .jobserver(server)
                         .run_rustc(false)?;
                     Ok(())
@@ -1077,7 +1077,7 @@ impl Benchmark {
                     }
                 }
                 log::debug!("Benchmark iteration {}/{}", i + 1, iterations);
-                let target_dir = self.make_temp_dir(target_dir.path())?;
+                let target_dir = self.make_temp_dir(target_dir)?;
                 let target_dir = target_dir.path();
                 let src_dir = self.make_temp_dir(src_dir.path())?;
                 let src_dir = src_dir.path();

collector/src/main.rs

@@ -13,6 +13,7 @@ use std::path::{Path, PathBuf};
 use std::process;
 use std::process::Command;
 use std::{str, time::Instant};
+use tempfile::TempDir;
 use tokio::runtime::Runtime;
 
 mod execute;
@@ -207,6 +208,16 @@ fn bench(
         );
     }
 
+    let bk_and_targets = build_kinds
+        .iter()
+        .map(|kind| Ok((*kind, TempDir::new()?)))
+        .collect::<anyhow::Result<Vec<_>>>()
+        .expect("created temp directories");
+    let bk_and_targets = bk_and_targets
+        .iter()
+        .map(|(k, td)| (*k, td.path()))
+        .collect::<Vec<_>>();
+
     let steps = benchmarks
         .iter()
         .map(|b| b.name.to_string())
@@ -250,8 +261,13 @@ fn bench(
             interned_cid,
             self_profile,
         );
-        let result =
-            benchmark.measure(&mut processor, build_kinds, run_kinds, compiler, iterations);
+        let result = benchmark.measure(
+            &mut processor,
+            &bk_and_targets,
+            run_kinds,
+            compiler,
+            iterations,
+        );
         if let Err(s) = result {
             eprintln!(
                 "collector error: Failed to benchmark '{}', recorded: {}",
@@ -734,12 +750,22 @@ fn main_result() -> anyhow::Result<i32> {
 
             eprintln!("Profiling with {:?}", profiler);
 
+            let bk_and_targets = build_kinds
+                .iter()
+                .map(|kind| Ok((*kind, TempDir::new()?)))
+                .collect::<anyhow::Result<Vec<_>>>()
+                .expect("created temp directories");
+            let bk_and_targets = bk_and_targets
+                .iter()
+                .map(|(k, td)| (*k, td.path()))
+                .collect::<Vec<_>>();
+
             let mut errors = BenchmarkErrors::new();
             for (i, benchmark) in benchmarks.iter().enumerate() {
                 eprintln!("{}", n_benchmarks_remaining(benchmarks.len() - i));
                 let mut processor = execute::ProfileProcessor::new(profiler, &out_dir, &id);
                 let result =
-                    benchmark.measure(&mut processor, &build_kinds, &run_kinds, compiler, 1);
+                    benchmark.measure(&mut processor, &bk_and_targets, &run_kinds, compiler, 1);
                 if let Err(ref s) = result {
                     errors.incr();
                     eprintln!(