Allow profiling rustdoc

- Distinguish between rustdoc and rustc
- Use `rustdoc` instead of `doc` subcommand

This only profiles the last crate and also avoids special casing
RUSTDOCFLAGS.

- Add a fake rustdoc
- Create symlink automatically if it doesn't already exist

Author: jyn514

collector/src/bin/rustc-fake.rs

@@ -4,8 +4,18 @@ use std::process::Command;
 use std::time::{Duration, Instant};
 
 fn main() {
-    let mut args = env::args_os().skip(1).collect::<Vec<_>>();
+    let mut args_os = env::args_os();
+    let name = args_os.next().unwrap().into_string().unwrap();
+
+    let mut args = args_os.collect::<Vec<_>>();
     let rustc = env::var_os("RUSTC_REAL").unwrap();
+    let rustdoc = env::var_os("RUSTDOC_REAL").unwrap();
+    let actually_rustdoc = name.ends_with("rustdoc-fake");
+    let tool = if actually_rustdoc {
+        rustdoc
+    } else {
+        rustc
+    };
 
     if let Some(count) = env::var("RUSTC_THREAD_COUNT")
         .ok()
@@ -36,7 +46,7 @@ fn main() {
                     .arg("instructions:u,cycles:u,task-clock,cpu-clock,faults")
                     .arg("--log-fd")
                     .arg("1")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 let prof_out_dir = std::env::current_dir().unwrap().join("self-profile-output");
@@ -91,14 +101,14 @@ fn main() {
             }
 
             "self-profile" => {
-                let mut cmd = Command::new(&rustc);
+                let mut cmd = Command::new(&tool);
                 cmd.arg("-Zself-profile=Zsp").args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
             }
 
             "time-passes" => {
-                let mut cmd = Command::new(&rustc);
+                let mut cmd = Command::new(&tool);
                 cmd.arg("-Ztime-passes").args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -113,7 +123,7 @@ fn main() {
                     .arg("--output=perf")
                     .arg("--freq=299")
                     .arg("--event=cycles:u,instructions:u")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -124,7 +134,7 @@ fn main() {
                 let has_oprofile = cmd.output().is_ok();
                 assert!(has_oprofile);
                 // Other possibly useful args: --callgraph, --separate-thread
-                cmd.arg("operf").arg(&rustc).args(&args);
+                cmd.arg("operf").arg(&tool).args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
             }
@@ -140,7 +150,7 @@ fn main() {
                     .arg("--cache-sim=no")
                     .arg("--branch-sim=no")
                     .arg("--cachegrind-out-file=cgout")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -157,7 +167,7 @@ fn main() {
                     .arg("--cache-sim=no")
                     .arg("--branch-sim=no")
                     .arg("--callgrind-out-file=clgout")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -170,7 +180,7 @@ fn main() {
                 cmd.arg("--tool=dhat")
                     .arg("--num-callers=4")
                     .arg("--dhat-out-file=dhout")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -186,14 +196,14 @@ fn main() {
                     .arg("--threshold=0.2")
                     .arg("--massif-out-file=msout")
                     .arg("--alloc-fn=__rdl_alloc")
-                    .arg(&rustc)
+                    .arg(&tool)
                     .args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
             }
 
             "eprintln" | "llvm-lines" => {
-                let mut cmd = Command::new(&rustc);
+                let mut cmd = Command::new(&tool);
                 cmd.args(&args);
 
                 assert!(cmd.status().expect("failed to spawn").success());
@@ -204,7 +214,7 @@ fn main() {
             }
         }
     } else {
-        let mut cmd = Command::new(&rustc);
+        let mut cmd = Command::new(&tool);
         cmd.args(&args);
         exec(&mut cmd);
     }

collector/src/bin/rustc-perf-collector/execute.rs

@@ -236,7 +236,9 @@ impl<'a> CargoProcess<'a> {
             // 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("RUSTDOC", &*FAKE_RUSTDOC)
             .env("RUSTC_REAL", &self.compiler.rustc)
+            .env("RUSTDOC_REAL", dbg!(&self.compiler.rustdoc))
             .env(
                 "CARGO_INCREMENTAL",
                 &format!("{}", self.incremental as usize),
@@ -280,7 +282,7 @@ impl<'a> CargoProcess<'a> {
                 }
 
                 if self.build_kind == BuildKind::Doc {
-                    dbg!("doc")
+                    "rustdoc"
                 } else {
                     profiler.subcommand()
                 }
@@ -309,8 +311,9 @@ impl<'a> CargoProcess<'a> {
             // onto rustc for the final crate, which is exactly the crate for which
             // we want to wrap rustc.
             if let Some((ref mut processor, ..)) = self.processor_etc {
+                let profiler = processor.profiler().name();
                 cmd.arg("--wrap-rustc-with");
-                cmd.arg(processor.profiler().name());
+                cmd.arg(profiler);
                 cmd.args(&self.rustc_args);
             }
 
@@ -347,6 +350,16 @@ lazy_static::lazy_static! {
         fake_rustc.push("rustc-fake");
         fake_rustc
     };
+    static ref FAKE_RUSTDOC: PathBuf = {
+        let mut fake_rustdoc = env::current_exe().unwrap();
+        fake_rustdoc.pop();
+        fake_rustdoc.push("rustdoc-fake");
+        // link from rustc-fake to rustdoc-fake
+        if !fake_rustdoc.exists() {
+            std::fs::hard_link(&*FAKE_RUSTC, &fake_rustdoc).expect("failed to make hard link");
+        }
+        fake_rustdoc
+    };
 }
 
 /// Used to indicate if we need to retry a run.

collector/src/bin/rustc-perf-collector/main.rs

@@ -29,6 +29,7 @@ use sysroot::Sysroot;
 #[derive(Debug, Copy, Clone)]
 pub struct Compiler<'a> {
     pub rustc: &'a Path,
+    pub rustdoc: &'a Path,
     pub cargo: &'a Path,
     pub triple: &'a str,
     pub is_nightly: bool,
@@ -38,6 +39,7 @@ impl<'a> Compiler<'a> {
     fn from_sysroot(sysroot: &'a Sysroot) -> Compiler<'a> {
         Compiler {
             rustc: &sysroot.rustc,
+            rustdoc: &sysroot.rustdoc,
             cargo: &sysroot.cargo,
             triple: &sysroot.triple,
             is_nightly: true,
@@ -86,6 +88,7 @@ pub enum KindError {
 const STRINGS_AND_BUILD_KINDS: &[(&str, BuildKind)] = &[
     ("Check", BuildKind::Check),
     ("Debug", BuildKind::Debug),
+    ("Doc", BuildKind::Doc),
     ("Opt", BuildKind::Opt),
 ];
 
@@ -395,6 +398,7 @@ fn main_result() -> anyhow::Result<i32> {
        (@subcommand bench_local =>
            (about: "benchmark a local rustc")
            (@arg RUSTC: --rustc +required +takes_value "The path to the local rustc to benchmark")
+           (@arg RUSTDOC: --rustdoc +required +takes_value "The path to the local rustdoc to benchmark")
            (@arg CARGO: --cargo +required +takes_value "The path to the local Cargo to use")
            (@arg BUILDS: --builds +takes_value
             "One or more (comma-separated) of: 'Check', 'Debug',\n\
@@ -482,12 +486,14 @@ fn main_result() -> anyhow::Result<i32> {
 
         ("bench_local", Some(sub_m)) => {
             let rustc = sub_m.value_of("RUSTC").unwrap();
+            let rustdoc = sub_m.value_of("RUSTDOC").unwrap();
             let cargo = sub_m.value_of("CARGO").unwrap();
             let build_kinds = build_kinds_from_arg(&sub_m.value_of("BUILDS"))?;
             let run_kinds = run_kinds_from_arg(&sub_m.value_of("RUNS"))?;
             let id = sub_m.value_of("ID").unwrap();
 
             let rustc_path = PathBuf::from(rustc).canonicalize()?;
+            let rustdoc_path = PathBuf::from(rustdoc).canonicalize()?;
             let cargo_path = PathBuf::from(cargo).canonicalize()?;
             let conn = rt.block_on(pool.expect("--db passed").connection());
             bench_commit(
@@ -498,6 +504,7 @@ fn main_result() -> anyhow::Result<i32> {
                 &run_kinds,
                 Compiler {
                     rustc: &rustc_path,
+                    rustdoc: &rustdoc_path,
                     cargo: &cargo_path,
                     triple: "x86_64-unknown-linux-gnu",
                     is_nightly: true,
@@ -520,28 +527,22 @@ fn main_result() -> anyhow::Result<i32> {
                 anyhow::bail!("failed to install toolchain for {}", id);
             }
 
-            let rustc = String::from_utf8(
-                Command::new("rustup")
-                    .arg("which")
-                    .arg("--toolchain")
-                    .arg(&id)
-                    .arg("rustc")
-                    .output()
-                    .context("rustup which rustc")?
-                    .stdout,
-            )
-            .context("utf8")?;
-            let cargo = String::from_utf8(
-                Command::new("rustup")
-                    .arg("which")
-                    .arg("--toolchain")
-                    .arg(&id)
-                    .arg("cargo")
-                    .output()
-                    .context("rustup which cargo")?
-                    .stdout,
-            )
-            .context("utf8")?;
+            let which = |tool| {
+                String::from_utf8(
+                    Command::new("rustup")
+                        .arg("which")
+                        .arg("--toolchain")
+                        .arg(&id)
+                        .arg(tool)
+                        .output()
+                        .context(format!("rustup which {}", tool))?
+                        .stdout,
+                )
+                .context("utf8")
+            };
+            let rustc = which("rustc")?;
+            let rustdoc = which("rustdoc")?;
+            let cargo = which("cargo")?;
 
             // Remove benchmarks that don't work with a stable compiler.
             benchmarks.retain(|b| b.supports_stable());
@@ -560,6 +561,7 @@ fn main_result() -> anyhow::Result<i32> {
                 &run_kinds,
                 Compiler {
                     rustc: Path::new(rustc.trim()),
+                    rustdoc: Path::new(rustdoc.trim()),
                     cargo: Path::new(cargo.trim()),
                     is_nightly: false,
                     triple: "x86_64-unknown-linux-gnu",
@@ -584,6 +586,7 @@ fn main_result() -> anyhow::Result<i32> {
 
         ("profile", Some(sub_m)) => {
             let rustc = sub_m.value_of("RUSTC").unwrap();
+            let rustdoc = sub_m.value_of("RUSTDOC").unwrap();
             let cargo = sub_m.value_of("CARGO").unwrap();
             let build_kinds = build_kinds_from_arg(&sub_m.value_of("BUILDS"))?;
             let run_kinds = run_kinds_from_arg(&sub_m.value_of("RUNS"))?;
@@ -594,9 +597,11 @@ fn main_result() -> anyhow::Result<i32> {
             eprintln!("Profiling with {:?}", profiler);
 
             let rustc_path = PathBuf::from(rustc).canonicalize()?;
+            let rustdoc_path = PathBuf::from(rustdoc).canonicalize()?;
             let cargo_path = PathBuf::from(cargo).canonicalize()?;
             let compiler = Compiler {
                 rustc: &rustc_path,
+                rustdoc: &rustdoc_path,
                 cargo: &cargo_path,
                 is_nightly: true,
                 triple: "x86_64-unknown-linux-gnu", // XXX: Technically not necessarily true