bootstrap: at most one rustc running simultaneously

This commit adds another variance reduction strategy to rustc execution as part
of the bootstrap process, namely, rustbuild is configured to launch at most one
rustc (-j1) but then the individual rustc's are configured to have access to
full parallelism. This is not very realistic -- the build overall will likely be
slower than it could have been, when rustcs fight for resources -- but it should
hopefully still be representative of the total amount of work that needs to be
done for each rustc.

We care relatively speaking much more about being deterministic rather than
representative of "true" workloads, though, at least for now. It is relatively
unlikely that most improvements in build times will be major (>20%, which is
roughly the variance we observe today).

Author: Mark-Simulacrum

collector/Cargo.toml

@@ -37,3 +37,7 @@ path = "src/main.rs"
 [[bin]]
 name = "rustc-fake"
 path = "src/rustc-fake.rs"
+
+[[bin]]
+name = "bootstrap-rustc"
+path = "src/bootstrap-rustc.rs"

collector/src/bootstrap-rustc.rs

@@ -0,0 +1,26 @@
+use jobserver::Client;
+use std::env;
+use std::process::Command;
+
+fn run() -> i32 {
+    let server = Client::new(num_cpus::get()).expect("made jobserver");
+
+    let mut cmd = Command::new(env::var_os("RUSTC_PERF_REAL_RUSTC").unwrap());
+    cmd.args(env::args_os());
+
+    // We want the bootstrap rustc to have access to full parallelism, even
+    // though the parent cargo is permitted to spawn at most one rustc (-j1).
+    server.configure(&mut cmd);
+
+    let status = cmd.status().expect("spawned");
+
+    if status.success() {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+fn main() {
+    std::process::exit(run());
+}

collector/src/execute/rustc.rs

@@ -9,6 +9,7 @@
 
 use crate::Compiler;
 use anyhow::Context;
+use std::env;
 use std::{collections::HashMap, process::Command};
 use std::{path::Path, time::Duration};
 use tokio::runtime::Runtime;
@@ -54,6 +55,10 @@ fn record(
         .context("git clean -fxd")?;
     assert!(status.success(), "git clean -fxd successful");
 
+    let mut fake_rustc = env::current_exe().unwrap();
+    fake_rustc.pop();
+    fake_rustc.push("bootstrap-rustc");
+
     // Configure the compiler we're given as the one to use.
     let status = Command::new(
         checkout
@@ -67,7 +72,8 @@ fn record(
     .arg("--set")
     .arg("build.print-step-timings=true")
     .arg("--set")
-    .arg(&format!("build.rustc={}", compiler.rustc.to_str().unwrap()))
+    .arg(&format!("build.rustc={}", fake_rustc.to_str().unwrap()))
+    .env("RUSTC_PERF_REAL_RUSTC", &compiler.rustc)
     .arg("--set")
     .arg(&format!("build.cargo={}", compiler.cargo.to_str().unwrap()))
     .status()
@@ -85,6 +91,11 @@ fn record(
         .arg("build")
         .arg("--stage")
         .arg("0")
+        // We want bootstrap and the Cargos it spawns to have no parallelism --
+        // if multiple rustcs are competing for jobserver tokens, we introduce
+        // quite a bit of variance. Instead, we configure -j1 here, and then
+        // full all vCPU parallelism for each rustc.
+        .arg("-j1")
         .arg("compiler/rustc"),
     )
     .context("building rustc")?;