Demangle cachegrind files immediately after creating them

This avoids the creation of needless `cgfilt` files when comparing two Cachegrind profiles. It also produces a demangled `cgout` file even without using Cachegrind diff.

Author: Kobzol

collector/src/bin/collector.rs

@@ -39,7 +39,6 @@ use collector::runtime::{profile_runtime, RuntimeCompilationOpts};
 use collector::toolchain::{
     create_toolchain_from_published_version, get_local_toolchain, Sysroot, Toolchain,
 };
-use collector::utils::mangling::demangle_file;
 use collector::utils::wait_for_future;
 
 fn n_normal_benchmarks_remaining(n: usize) -> String {
@@ -162,22 +161,10 @@ fn generate_cachegrind_diffs(
                 let id_diff = format!("{}-{}", id1, id2);
                 let cgout1 = out_dir.join(filename("cgout", id1));
                 let cgout2 = out_dir.join(filename("cgout", id2));
-                let cgfilt1 = out_dir.join(filename("cgfilt", id1));
-                let cgfilt2 = out_dir.join(filename("cgfilt", id2));
                 let cgfilt_diff = out_dir.join(filename("cgfilt-diff", &id_diff));
                 let cgann_diff = out_dir.join(filename("cgann-diff", &id_diff));
 
-                if let Err(e) = demangle_file(&cgout1, &cgfilt1) {
-                    errors.incr();
-                    eprintln!("collector error: {:?}", e);
-                    continue;
-                }
-                if let Err(e) = demangle_file(&cgout2, &cgfilt2) {
-                    errors.incr();
-                    eprintln!("collector error: {:?}", e);
-                    continue;
-                }
-                if let Err(e) = cg_diff(&cgfilt1, &cgfilt2, &cgfilt_diff) {
+                if let Err(e) = cg_diff(&cgout1, &cgout2, &cgfilt_diff) {
                     errors.incr();
                     eprintln!("collector error: {:?}", e);
                     continue;

collector/src/utils/cachegrind.rs

@@ -1,14 +1,18 @@
+use crate::utils::mangling::demangle_file;
+use anyhow::Context;
 use std::io::{BufRead, Write};
 use std::path::Path;
 use std::process::Command;
 use std::{fs, io};
 
-/// Annotate the output of Cachegrind using the `cg_annotate` tool.
+/// Annotate and demangle the output of Cachegrind using the `cg_annotate` tool.
 pub fn cachegrind_annotate(
     input: &Path,
     cgout_output: &Path,
     cgann_output: &Path,
 ) -> anyhow::Result<()> {
+    let tmp_cgout = tempfile::NamedTempFile::new()?.into_temp_path();
+
     // It's useful to filter all `file:function` entries from
     // jemalloc into a single fake
     // `<all-jemalloc-files>:<all-jemalloc-functions>` entry. That
@@ -20,7 +24,7 @@ pub fn cachegrind_annotate(
     // jemalloc is basically a black box whose code we never look
     // at anyway. DHAT is the best way to profile allocations.
     let reader = io::BufReader::new(fs::File::open(input)?);
-    let mut writer = io::BufWriter::new(fs::File::create(cgout_output)?);
+    let mut writer = io::BufWriter::new(fs::File::create(&tmp_cgout)?);
     let mut in_jemalloc_file = false;
 
     // A Cachegrind profile contains `fn=<function-name>` lines,
@@ -50,6 +54,8 @@ pub fn cachegrind_annotate(
     }
     writer.flush()?;
 
+    demangle_file(&tmp_cgout, cgout_output).context("Cannot demangle cgout file")?;
+
     let mut cg_annotate_cmd = Command::new("cg_annotate");
     cg_annotate_cmd
         .arg("--auto=yes")