Merge LocalToolchain and Compiler and rename it to just Toolchain

Kobzol · Kobzol · commit e275af4e0e1a · 2023-07-01T19:54:27.000+02:00
There was no need for two structs, the `is_nightly` attribute is unused and it was basically the same as `LocalToolchain`.
diff --git a/collector/src/bin/collector.rs b/collector/src/bin/collector.rs
@@ -30,7 +30,7 @@ use collector::compile::execute::profiler::{ProfileProcessor, Profiler};
 use collector::runtime::{
     bench_runtime, runtime_benchmark_dir, BenchmarkFilter, CargoIsolationMode,
 };
-use collector::toolchain::{get_local_toolchain, Compiler, Sysroot};
+use collector::toolchain::{get_local_toolchain, Sysroot, Toolchain};
 
 fn n_normal_benchmarks_remaining(n: usize) -> String {
     let suffix = if n == 1 { "" } else { "s" };
@@ -66,7 +66,7 @@ fn bench(
     mut conn: Box<dyn Connection>,
     profiles: &[Profile],
     scenarios: &[Scenario],
-    compiler: Compiler<'_>,
+    toolchain: &Toolchain,
     benchmarks: &[Benchmark],
     iterations: Option<usize>,
     is_self_profile: bool,
@@ -75,7 +75,7 @@ fn bench(
     let mut errors = BenchmarkErrors::new();
     eprintln!(
         "Benchmarking {} for triple {}",
-        collector.artifact_id, compiler.triple
+        collector.artifact_id, toolchain.triple
     );
 
     if is_self_profile {
@@ -145,7 +145,7 @@ fn bench(
                     n_normal_benchmarks_remaining(benchmarks.len() - nth_benchmark)
                 )
             },
-            &|processor| benchmark.measure(processor, profiles, scenarios, compiler, iterations),
+            &|processor| benchmark.measure(processor, profiles, scenarios, toolchain, iterations),
         )
     }
 
@@ -155,7 +155,7 @@ fn bench(
             &BenchmarkName("rustc".to_string()),
             Category::Primary,
             &|| eprintln!("Special benchmark commencing (due to `--bench-rustc`)"),
-            &|processor| processor.measure_rustc(compiler).context("measure rustc"),
+            &|processor| processor.measure_rustc(toolchain).context("measure rustc"),
         );
     }
 
@@ -332,16 +332,15 @@ fn cg_annotate(cgout: &Path, path: &Path) -> anyhow::Result<()> {
 
 #[allow(clippy::too_many_arguments)]
 fn profile(
-    compiler: Compiler,
-    id: &str,
+    toolchain: &Toolchain,
     profiler: Profiler,
     out_dir: &Path,
     benchmarks: &[Benchmark],
     profiles: &[Profile],
     scenarios: &[Scenario],
     errors: &mut BenchmarkErrors,
 ) {
-    eprintln!("Profiling {} with {:?}", id, profiler);
+    eprintln!("Profiling {} with {:?}", toolchain.id, profiler);
     if let Profiler::SelfProfile = profiler {
         check_measureme_installed().unwrap();
     }
@@ -352,8 +351,8 @@ fn profile(
         .map(|(i, benchmark)| {
             let benchmark_id = format!("{} ({}/{})", benchmark.name, i + 1, benchmarks.len());
             eprintln!("Executing benchmark {benchmark_id}");
-            let mut processor = ProfileProcessor::new(profiler, out_dir, id);
-            let result = benchmark.measure(&mut processor, profiles, scenarios, compiler, Some(1));
+            let mut processor = ProfileProcessor::new(profiler, out_dir, &toolchain.id);
+            let result = benchmark.measure(&mut processor, profiles, scenarios, toolchain, Some(1));
             eprintln!("Finished benchmark {benchmark_id}");
 
             if let Err(ref s) = result {
@@ -717,6 +716,7 @@ fn main_result() -> anyhow::Result<i32> {
                 local.cargo.as_deref(),
                 local.id.as_deref(),
                 "",
+                target_triple,
             )?;
             let pool = Pool::open(&db.db);
 
@@ -769,6 +769,7 @@ fn main_result() -> anyhow::Result<i32> {
                 local.cargo.as_deref(),
                 local.id.as_deref(),
                 "",
+                target_triple,
             )?;
 
             let mut benchmarks = get_compile_benchmarks(
@@ -792,7 +793,7 @@ fn main_result() -> anyhow::Result<i32> {
                 conn,
                 profiles,
                 scenarios,
-                Compiler::from_toolchain(&toolchain, &target_triple),
+                &toolchain,
                 &benchmarks,
                 Some(iterations),
                 self_profile.self_profile,
@@ -842,7 +843,8 @@ fn main_result() -> anyhow::Result<i32> {
                     exclude,
                     runs,
                 } => {
-                    let sysroot = Sysroot::install(commit.sha.to_string(), &target_triple)
+                    let sha = commit.sha.to_string();
+                    let sysroot = Sysroot::install(sha.clone(), &target_triple)
                         .with_context(|| format!("failed to install sysroot for {:?}", commit))?;
 
                     let mut benchmarks = get_compile_benchmarks(
@@ -865,7 +867,7 @@ fn main_result() -> anyhow::Result<i32> {
                         conn,
                         &Profile::all(),
                         &Scenario::all(),
-                        Compiler::from_sysroot(&sysroot),
+                        &Toolchain::from_sysroot(&sysroot, sha),
                         &benchmarks,
                         runs.map(|v| v as usize),
                         self_profile.self_profile,
@@ -937,19 +939,19 @@ fn main_result() -> anyhow::Result<i32> {
                         local.cargo.as_deref(),
                         local.id.as_deref(),
                         suffix,
+                        target_triple.clone(),
                     )?;
-                    let compiler = Compiler::from_toolchain(&toolchain, &target_triple);
+                    let id = toolchain.id.clone();
                     profile(
-                        compiler,
-                        &toolchain.id,
+                        &toolchain,
                         profiler,
                         &out_dir,
                         &benchmarks,
                         profiles,
                         scenarios,
                         &mut errors,
                     );
-                    Ok(toolchain.id)
+                    Ok(id)
                 };
 
             if let Some(rustc2) = rustc2 {
@@ -1096,7 +1098,7 @@ fn bench_published_artifact(
     let mut benchmarks = get_compile_benchmarks(benchmark_dir, None, None, None)?;
     benchmarks.retain(|b| b.category().is_stable());
 
-    let artifact_id = ArtifactId::Tag(toolchain);
+    let artifact_id = ArtifactId::Tag(toolchain.clone());
     let (conn, collector) = rt.block_on(init_compile_collector(
         &pool,
         &benchmarks,
@@ -1108,12 +1110,12 @@ fn bench_published_artifact(
         conn,
         &profiles,
         &scenarios,
-        Compiler {
-            rustc: Path::new(rustc.trim()),
-            rustdoc: Some(Path::new(rustdoc.trim())),
-            cargo: Path::new(cargo.trim()),
-            is_nightly: false,
-            triple: target_triple,
+        &Toolchain {
+            rustc: PathBuf::from(rustc.trim()),
+            rustdoc: Some(PathBuf::from(rustdoc.trim())),
+            cargo: PathBuf::from(cargo.trim()),
+            id: toolchain,
+            triple: target_triple.to_string(),
         },
         &benchmarks,
         Some(3),
diff --git a/collector/src/compile/benchmark/mod.rs b/collector/src/compile/benchmark/mod.rs
@@ -3,7 +3,7 @@ use crate::compile::benchmark::patch::Patch;
 use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
 use crate::compile::execute::{CargoProcess, Processor};
-use crate::toolchain::Compiler;
+use crate::toolchain::Toolchain;
 use anyhow::{bail, Context};
 use log::debug;
 use std::collections::{HashMap, HashSet};
@@ -143,7 +143,7 @@ impl Benchmark {
 
     fn mk_cargo_process<'a>(
         &'a self,
-        compiler: Compiler<'a>,
+        toolchain: &'a Toolchain,
         cwd: &'a Path,
         profile: Profile,
     ) -> CargoProcess<'a> {
@@ -163,7 +163,7 @@ impl Benchmark {
         }
 
         CargoProcess {
-            compiler,
+            toolchain,
             processor_name: self.name.clone(),
             cwd,
             profile,
@@ -194,7 +194,7 @@ impl Benchmark {
         processor: &mut dyn Processor,
         profiles: &[Profile],
         scenarios: &[Scenario],
-        compiler: Compiler<'_>,
+        toolchain: &Toolchain,
         iterations: Option<usize>,
     ) -> anyhow::Result<()> {
         if self.config.disabled {
@@ -261,7 +261,7 @@ impl Benchmark {
             for (profile, prep_dir) in &profile_dirs {
                 let server = server.clone();
                 let thread = s.spawn::<_, anyhow::Result<()>>(move || {
-                    self.mk_cargo_process(compiler, prep_dir.path(), *profile)
+                    self.mk_cargo_process(toolchain, prep_dir.path(), *profile)
                         .jobserver(server)
                         .run_rustc(false)?;
                     Ok(())
@@ -308,7 +308,7 @@ impl Benchmark {
 
                 // A full non-incremental build.
                 if scenarios.contains(&Scenario::Full) {
-                    self.mk_cargo_process(compiler, cwd, profile)
+                    self.mk_cargo_process(toolchain, cwd, profile)
                         .processor(processor, Scenario::Full, "Full", None)
                         .run_rustc(true)?;
                 }
@@ -318,15 +318,15 @@ impl Benchmark {
                     // An incremental  from scratch (slowest incremental case).
                     // This is required for any subsequent incremental builds.
                     if scenarios.iter().any(|s| s.is_incr()) {
-                        self.mk_cargo_process(compiler, cwd, profile)
+                        self.mk_cargo_process(toolchain, cwd, profile)
                             .incremental(true)
                             .processor(processor, Scenario::IncrFull, "IncrFull", None)
                             .run_rustc(true)?;
                     }
 
                     // An incremental build with no changes (fastest incremental case).
                     if scenarios.contains(&Scenario::IncrUnchanged) {
-                        self.mk_cargo_process(compiler, cwd, profile)
+                        self.mk_cargo_process(toolchain, cwd, profile)
                             .incremental(true)
                             .processor(processor, Scenario::IncrUnchanged, "IncrUnchanged", None)
                             .run_rustc(true)?;
@@ -340,7 +340,7 @@ impl Benchmark {
                             // An incremental build with some changes (realistic
                             // incremental case).
                             let scenario_str = format!("IncrPatched{}", i);
-                            self.mk_cargo_process(compiler, cwd, profile)
+                            self.mk_cargo_process(toolchain, cwd, profile)
                                 .incremental(true)
                                 .processor(
                                     processor,
diff --git a/collector/src/compile/execute/bencher.rs b/collector/src/compile/execute/bencher.rs
@@ -6,7 +6,7 @@ use crate::compile::execute::{
     rustc, DeserializeStatError, PerfTool, ProcessOutputData, Processor, Retry, SelfProfile,
     SelfProfileFiles, Stats, Upload,
 };
-use crate::toolchain::Compiler;
+use crate::toolchain::Toolchain;
 use crate::utils::git::get_rustc_perf_commit;
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
@@ -160,11 +160,11 @@ impl<'a> BenchProcessor<'a> {
             .block_on(async move { while let Some(()) = buf.next().await {} });
     }
 
-    pub fn measure_rustc(&mut self, compiler: Compiler<'_>) -> anyhow::Result<()> {
+    pub fn measure_rustc(&mut self, toolchain: &Toolchain) -> anyhow::Result<()> {
         rustc::measure(
             self.rt,
             self.conn,
-            compiler,
+            toolchain,
             self.artifact,
             self.artifact_row_id,
         )
diff --git a/collector/src/compile/execute/mod.rs b/collector/src/compile/execute/mod.rs
@@ -4,7 +4,7 @@ use crate::compile::benchmark::patch::Patch;
 use crate::compile::benchmark::profile::Profile;
 use crate::compile::benchmark::scenario::Scenario;
 use crate::compile::benchmark::BenchmarkName;
-use crate::toolchain::Compiler;
+use crate::toolchain::Toolchain;
 use crate::{command_output, utils};
 use anyhow::Context;
 use bencher::Bencher;
@@ -113,7 +113,7 @@ impl PerfTool {
 }
 
 pub struct CargoProcess<'a> {
-    pub compiler: Compiler<'a>,
+    pub toolchain: &'a Toolchain,
     pub cwd: &'a Path,
     pub profile: Profile,
     pub incremental: bool,
@@ -144,12 +144,12 @@ impl<'a> CargoProcess<'a> {
     }
 
     fn base_command(&self, cwd: &Path, subcommand: &str) -> Command {
-        let mut cmd = Command::new(Path::new(self.compiler.cargo));
+        let mut cmd = Command::new(Path::new(&self.toolchain.cargo));
         cmd
             // Not all cargo invocations (e.g. `cargo clean`) need all of these
             // env vars set, but it doesn't hurt to have them.
             .env("RUSTC", &*FAKE_RUSTC)
-            .env("RUSTC_REAL", self.compiler.rustc)
+            .env("RUSTC_REAL", &self.toolchain.rustc)
             // We separately pass -Cincremental to the leaf crate --
             // CARGO_INCREMENTAL is cached separately for both the leaf crate
             // and any in-tree dependencies, and we don't want that; it wastes
@@ -164,7 +164,7 @@ impl<'a> CargoProcess<'a> {
             .arg("--manifest-path")
             .arg(&self.manifest_path);
 
-        if let Some(r) = &self.compiler.rustdoc {
+        if let Some(r) = &self.toolchain.rustdoc {
             cmd.env("RUSTDOC", &*FAKE_RUSTDOC).env("RUSTDOC_REAL", r);
         }
         cmd
diff --git a/collector/src/compile/execute/rustc.rs b/collector/src/compile/execute/rustc.rs
@@ -7,7 +7,7 @@
 //! no real reason for us to compile the standard library twice, and it avoids
 //! having to think about how to deduplicate results.
 
-use crate::toolchain::Compiler;
+use crate::toolchain::Toolchain;
 use crate::utils::git::get_rustc_perf_commit;
 use anyhow::Context;
 use database::ArtifactId;
@@ -20,23 +20,23 @@ use tokio::runtime::Runtime;
 pub fn measure(
     rt: &mut Runtime,
     conn: &mut dyn database::Connection,
-    compiler: Compiler<'_>,
+    toolchain: &Toolchain,
     artifact: &database::ArtifactId,
     aid: database::ArtifactIdNumber,
 ) -> anyhow::Result<()> {
     eprintln!("Running rustc");
 
     checkout(artifact).context("checking out rust-lang/rust")?;
 
-    record(rt, conn, compiler, artifact, aid)?;
+    record(rt, conn, toolchain, artifact, aid)?;
 
     Ok(())
 }
 
 fn record(
     rt: &mut Runtime,
     conn: &mut dyn database::Connection,
-    compiler: Compiler<'_>,
+    toolchain: &Toolchain,
     artifact: &database::ArtifactId,
     aid: database::ArtifactIdNumber,
 ) -> anyhow::Result<()> {
@@ -95,9 +95,12 @@ fn record(
     .arg("rust.deny-warnings=false")
     .arg("--set")
     .arg(&format!("build.rustc={}", fake_rustc.to_str().unwrap()))
-    .env("RUSTC_PERF_REAL_RUSTC", compiler.rustc)
+    .env("RUSTC_PERF_REAL_RUSTC", &toolchain.rustc)
     .arg("--set")
-    .arg(&format!("build.cargo={}", compiler.cargo.to_str().unwrap()))
+    .arg(&format!(
+        "build.cargo={}",
+        toolchain.cargo.to_str().unwrap()
+    ))
     .status()
     .context("configuring")?;
     assert!(status.success(), "configure successful");
@@ -111,7 +114,7 @@ fn record(
                     .context("x.py script canonicalize")?,
             )
             .current_dir(checkout)
-            .env("RUSTC_PERF_REAL_RUSTC", compiler.rustc)
+            .env("RUSTC_PERF_REAL_RUSTC", &toolchain.rustc)
             .arg("build")
             .arg("--stage")
             .arg("0")
diff --git a/collector/src/runtime/benchmark.rs b/collector/src/runtime/benchmark.rs
diff --git a/collector/src/toolchain.rs b/collector/src/toolchain.rs
