Remove exp-DHAT support, DHAT is much better.

Author: nnethercote

collector/README.md

@@ -276,31 +276,8 @@ except that `$PROFILER` is one of the following.
     text output is also written to files with a `clgann` prefix; this output is
     much the same as the `cgann`-prefixed files produced by Cachegrind, but
     with extra annotations showing function call counts.
-- `exp-dhat`: Profile with [ExpDHAT](http://valgrind.org/docs/manual/dh-manual.html),
-  an experimental heap profiler that came with Valgrind (`--tool=exp-dhat`)
-  prior to version 3.15.
-  - **Purpose**. ExpDHAT is good for finding which parts of the code are
-    causing a lot of allocations. This is relevant if another profiler such as
-    `perf-record` or Cachegrind tell you that `malloc` and `free` are hot
-    functions (as they often are).
-  - **Slowdown**. Roughly 5--20x.
-  - **Prerequisites**. ExpDHAT may require a rustc configured with `jemalloc =
-    false` to work well.
-  - **Configuration**. ExpDHAT is configured within `profile` to run with the
-    non-default `--tot-blocks-allocd` option, so that it sorts its output by
-    the number of blocks allocated rather than the number of bytes allocated.
-    This is because the number of allocations typically has a greater effect on
-    speed than the size of those allocations; many small allocations will
-    typically be slower than a few large allocations.
-  - **Output**. Human-readable text output is written to files with a `dhat`
-    prefix. This file includes summary statistics followed by numerous records,
-    each of which aggregates data about all the allocations associated with a
-    particular stack trace: the number of allocations, their average size, and
-    how often they are read from and written to.
 - `dhat`: Profile with [DHAT](http://valgrind.org/docs/manual/dh-manual.html),
-  a heap profiler that comes with Valgrind (`--tool=dhat`) in versions 3.15
-  and later. It has the same purpose as ExpDHAT, but is significantly more
-  powerful.
+  a heap profiler. Requires Valgrind 3.15 or later.
   - **Purpose**. DHAT is good for finding which parts of the code are causing a
     lot of allocations. This is relevant if another profiler such as
     `perf-record` or Cachegrind tell you that `malloc` and `free` are hot

collector/src/bin/rustc-fake.rs

@@ -155,20 +155,6 @@ fn main() {
                 assert!(cmd.status().expect("failed to spawn").success());
             }
 
-            "exp-dhat" => {
-                let mut cmd = Command::new("valgrind");
-                let has_valgrind = cmd.output().is_ok();
-                assert!(has_valgrind);
-                cmd.arg("--tool=exp-dhat")
-                    .arg("--show-top-n=500")
-                    .arg("--num-callers=4")
-                    .arg("--sort-by=tot-blocks-allocd")
-                    .arg(&rustc)
-                    .args(&args);
-
-                assert!(cmd.status().expect("failed to spawn").success());
-            }
-
             "dhat" => {
                 let mut cmd = Command::new("valgrind");
                 let has_valgrind = cmd.output().is_ok();

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

@@ -79,7 +79,6 @@ pub enum Profiler {
     OProfile,
     Cachegrind,
     Callgrind,
-    ExpDHAT,
     DHAT,
     Massif,
     Eprintln,
@@ -105,7 +104,6 @@ impl Profiler {
             "oprofile" => Ok(Profiler::OProfile),
             "cachegrind" => Ok(Profiler::Cachegrind),
             "callgrind" => Ok(Profiler::Callgrind),
-            "exp-dhat" => Ok(Profiler::ExpDHAT),
             "dhat" => Ok(Profiler::DHAT),
             "massif" => Ok(Profiler::Massif),
             "eprintln" => Ok(Profiler::Eprintln),
@@ -122,7 +120,6 @@ impl Profiler {
             Profiler::OProfile => "oprofile",
             Profiler::Cachegrind => "cachegrind",
             Profiler::Callgrind => "callgrind",
-            Profiler::ExpDHAT => "exp-dhat",
             Profiler::DHAT => "dhat",
             Profiler::Massif => "massif",
             Profiler::Eprintln => "eprintln",
@@ -607,14 +604,6 @@ impl<'a> Processor for ProfileProcessor<'a> {
                 fs::write(clgann_file, &output.stdout)?;
             }
 
-            // ExpDHAT writes its output to stderr. We copy that output into a
-            // file in the output dir.
-            Profiler::ExpDHAT => {
-                let exp_dhat_file = filepath(self.output_dir, &out_file("exp-dhat"));
-
-                fs::write(exp_dhat_file, &output.stderr)?;
-            }
-
             // DHAT produces (via rustc-fake) a data file called 'dhout'. We
             // copy it from the temp dir to the output dir, giving it a new
             // name in the process.

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

@@ -447,7 +447,7 @@ fn main_result() -> anyhow::Result<i32> {
             'BaseIncr', 'CleanIncr', 'PatchedIncrs', 'All'")
            (@arg PROFILER: +required +takes_value
             "One of: 'time-passes', 'perf-record', 'cachegrind',\n\
-            'callgrind', 'exp-dhat', 'dhat', 'massif', 'eprintln'")
+            'callgrind', ''dhat', 'massif', 'eprintln'")
            (@arg ID: +required +takes_value "Identifier to associate benchmark results with")
        )
        (@subcommand remove_benchmark =>