Merge pull request #1456 from nnethercote/rm-time-passes

Remove the `time-passes` profiling mode.

Author: Kobzol

ci/check-profiling.sh

@@ -22,18 +22,6 @@ cargo build -p collector --bin rustc-fake
 
 # TODO: self-profile.
 
-# time-passes.
-RUST_BACKTRACE=1 RUST_LOG=raw_cargo_messages=trace,collector=debug,rust_sysroot=debug \
-    cargo run -p collector --bin collector -- \
-    profile_local time-passes $bindir/rustc \
-        --id Test \
-        --profiles Check \
-        --cargo $bindir/cargo \
-        --include helloworld \
-        --scenarios Full
-test -f results/Ztp-Test-helloworld-Check-Full
-grep -q "time:.*total" results/Ztp-Test-helloworld-Check-Full
-
 # perf-record: untested because we get "The instructions:u event is not
 # supported" on GitHub Actions when the code below is run. Maybe because the
 # hardware is virtualized and performance counters aren't available?

collector/README.md

@@ -267,14 +267,6 @@ The mandatory `<PROFILER>` argument must be one of the following.
     `flamegraph`, viewable with a web browser, is written to a file with a
     `flamegraph` prefix. Output from `crox`, viewable with Chromium's profiler,
     is written to a file with a `crox` prefix.
-- `time-passes`: Profile with rustc's `-Ztime-passes`.
-  - **Purpose**. This gives a high-level indication of compiler performance by
-    showing how long each compilation pass takes.
-  - **Slowdown**. None.
-  - **Output**. Human-readable text output is written to files with a `Ztp`
-    prefix. Note that the parents of indented sub-passes are shown below those
-    passes, rather than above. Note also that the LLVM passes run in parallel,
-    which can make the output confusing.
 - `perf-record`: Profile with
     [`perf-record`](https://perf.wiki.kernel.org/index.php/Main_Page), a
     sampling profiler.
@@ -374,16 +366,18 @@ The mandatory `<PROFILER>` argument must be one of the following.
   - **Slowdown**. Roughly 2--4x.
   - **Output**. Raw output is written to files with a `bytehound` prefix. Those
     files can be viewed with the `bytehound server <filename>` command.
-- `eprintln`: Profile with `eprintln!` statements.
+- `eprintln`: Profile via stderr, e.g. by using `eprintln!` statements.
   - **Purpose**. Sometimes it is useful to do ad hoc profiling by inserting
     `eprintln!` statements into rustc, e.g. to count how often particular paths
     are hit, or to see what values particular expressions have each time they
-    are executed.
-  - **Slowdown**. Depends where the `eprintln!` statements are inserted.
-  - **Output**. The output of these `eprintln!` statements (and everything else
-    written to `stderr`) is written to files with an `eprintln` prefix. Those
-    files can be post-processed in any appropriate fashion;
-    [`counts`](https://github.com/nnethercote/counts) is one possibility.
+    are executed. Alternatively, you can trigger some of rustc's built-in
+    profiling modes via environment variables, such as
+    `RUSTFLAGS=-Ztime-passes` or `RUSTFLAGS=-Zhir-stats`.
+  - **Slowdown**. Depends on how much extra output is being produced on stderr.
+  - **Output**. Everything written to stderr is copied to files with an
+    `eprintln` prefix. Those files can be post-processed in any appropriate
+    fashion; [`counts`](https://github.com/nnethercote/counts) is one
+    possibility.
 - `llvm-lines`: Profile with [`cargo
   llvm-lines`](https://github.com/dtolnay/cargo-llvm-lines/) a code size
   measurer.

collector/src/bin/rustc-fake.rs

@@ -205,17 +205,6 @@ fn main() {
                 run_with_determinism_env(cmd);
             }
 
-            "TimePasses" => {
-                let mut cmd = Command::new(&tool);
-                cmd.arg("-Ztime-passes")
-                    .args(args)
-                    .stderr(std::process::Stdio::from(
-                        std::fs::File::create("Ztp").unwrap(),
-                    ));
-
-                run_with_determinism_env(cmd);
-            }
-
             "PerfRecord" => {
                 let mut cmd = Command::new("perf");
                 let has_perf = cmd.output().is_ok();
@@ -345,12 +334,12 @@ fn main() {
 
             "LlvmLines" => {
                 // `cargo llvm-lines` writes its output to stdout. But we can't
-                // redirect it to a file here like we do for "time-passes" and
-                // "eprintln". This is because `cargo llvm-lines` invokes rustc
-                // as part of its processing and then it does some analysis of
-                // its output and then it prints out some results. Because
-                // `rustc` (which this file wraps) doesn't produce the output,
-                // this file can't redirect that output.
+                // redirect it to a file here like we do for "eprintln". This
+                // is because `cargo llvm-lines` invokes rustc as part of its
+                // processing and then it does some analysis of its output and
+                // then it prints out some results. Because `rustc` (which this
+                // file wraps) doesn't produce the output, this file can't
+                // redirect that output.
                 let mut cmd = Command::new(&tool);
                 cmd.args(&args);
 

collector/src/execute/mod.rs

@@ -49,7 +49,6 @@ impl PerfTool {
             | BenchTool(XperfStat)
             | BenchTool(XperfStatSelfProfile)
             | ProfileTool(SelfProfile)
-            | ProfileTool(TimePasses)
             | ProfileTool(PerfRecord)
             | ProfileTool(Oprofile)
             | ProfileTool(Cachegrind)
@@ -85,7 +84,6 @@ impl PerfTool {
             | BenchTool(XperfStat)
             | BenchTool(XperfStatSelfProfile)
             | ProfileTool(SelfProfile)
-            | ProfileTool(TimePasses)
             | ProfileTool(PerfRecord)
             | ProfileTool(Oprofile)
             | ProfileTool(Cachegrind)

collector/src/execute/profiler.rs

@@ -12,7 +12,6 @@ use std::{fs, process};
 #[derive(Clone, Copy, Debug, PartialEq, clap::ArgEnum)]
 pub enum Profiler {
     SelfProfile,
-    TimePasses,
     PerfRecord,
     Oprofile,
     Cachegrind,
@@ -157,15 +156,6 @@ impl<'a> Processor for ProfileProcessor<'a> {
                 utils::fs::rename("chrome_profiler.json", crox_file)?;
             }
 
-            // `-Ztime-passes` output is redirected (via rustc-fake) to a file
-            // called `Ztp`. We copy that output into a file in the output dir.
-            Profiler::TimePasses => {
-                let tmp_ztp_file = filepath(data.cwd.as_ref(), "Ztp");
-                let ztp_file = filepath(self.output_dir, &out_file("Ztp"));
-
-                fs::copy(&tmp_ztp_file, &ztp_file)?;
-            }
-
             // perf-record produces (via rustc-fake) a data file called `perf`.
             // We copy it from the temp dir to the output dir, giving it a new
             // name in the process.