Stream Cargo output interactively when compiling runtime benchmarks

This also formats any compilation errors in runtime benchmarks properly and prints them to stdout.

Author: Kobzol

collector/src/runtime/benchmark.rs

@@ -1,10 +1,12 @@
+use crate::toolchain::LocalToolchain;
 use benchlib::benchmark::passes_filter;
 use cargo_metadata::Message;
 use core::option::Option;
 use core::option::Option::Some;
 use core::result::Result::Ok;
+use std::io::BufReader;
 use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::process::{Child, Command, Stdio};
 
 /// A binary that defines several benchmarks using the `run_benchmark_group` function from
 /// `benchlib`.
@@ -65,10 +67,17 @@ impl BenchmarkFilter {
 /// We assume that each binary defines a benchmark suite using `benchlib`.
 /// We then execute each benchmark suite with the `list-benchmarks` command to find out its
 /// benchmark names.
-pub fn discover_benchmarks(cargo_stdout: &[u8]) -> anyhow::Result<BenchmarkSuite> {
+pub fn discover_benchmarks(
+    toolchain: &LocalToolchain,
+    dir: &Path,
+) -> anyhow::Result<BenchmarkSuite> {
+    log::info!("Compiling runtime benchmarks");
+    let mut child = start_runtime_benchmarks_compilation(toolchain, dir)?;
+
     let mut groups = vec![];
 
-    for message in Message::parse_stream(cargo_stdout) {
+    let stream = BufReader::new(child.stdout.take().unwrap());
+    for message in Message::parse_stream(stream) {
         let message = message?;
         match message {
             Message::CompilerArtifact(artifact) => {
@@ -81,23 +90,57 @@ pub fn discover_benchmarks(cargo_stdout: &[u8]) -> anyhow::Result<BenchmarkSuite
                                 path.display()
                             )
                         })?;
+                        log::info!("Compiled {}", path.display());
                         groups.push(BenchmarkGroup {
                             binary: path,
                             benchmark_names: benchmarks,
                         });
                     }
                 }
             }
-            _ => {}
+            Message::TextLine(line) => println!("{}", line),
+            Message::CompilerMessage(msg) => {
+                print!("{}", msg.message.rendered.unwrap_or(msg.message.message))
+            }
+            _ => {
+                log::debug!("Cargo metadata output: {:?}", message);
+            }
         }
     }
 
+    let output = child.wait()?;
+    if output.success() {
+        log::info!("Successfully compiled runtime benchmarks");
+    } else {
+        return Err(anyhow::anyhow!("Failed to compile runtime benchmarks"));
+    }
+
     groups.sort_unstable_by(|a, b| a.binary.cmp(&b.binary));
     log::debug!("Found binaries: {:?}", groups);
 
     Ok(BenchmarkSuite { groups })
 }
 
+/// Compiles all runtime benchmark binaries (groups) and returns the stdout output stream of Cargo.
+fn start_runtime_benchmarks_compilation(
+    toolchain: &LocalToolchain,
+    dir: &Path,
+) -> anyhow::Result<Child> {
+    let child = Command::new(&toolchain.cargo)
+        .env("RUSTC", &toolchain.rustc)
+        .arg("build")
+        .arg("--release")
+        .arg("--message-format")
+        .arg("json-diagnostic-rendered-ansi")
+        .current_dir(dir)
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .map_err(|error| anyhow::anyhow!("Failed to start cargo: {:?}", error))?;
+    Ok(child)
+}
+
 /// Uses a command from `benchlib` to find the benchmark names from the given
 /// benchmark binary.
 fn gather_benchmarks(binary: &Path) -> anyhow::Result<Vec<String>> {

collector/src/runtime/mod.rs

@@ -1,7 +1,7 @@
 mod benchmark;
 
 use crate::benchmark::profile::Profile;
-use crate::toolchain::{get_local_toolchain, LocalToolchain};
+use crate::toolchain::get_local_toolchain;
 use benchlib::comm::messages::{BenchmarkMessage, BenchmarkResult, BenchmarkStats};
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
@@ -20,8 +20,7 @@ pub fn bench_runtime(
     benchmark_dir: PathBuf,
 ) -> anyhow::Result<()> {
     let toolchain = get_local_toolchain(&[Profile::Opt], rustc, None, None, id, "")?;
-    let output = compile_runtime_benchmark_binaries(&toolchain, &benchmark_dir)?;
-    let suite = benchmark::discover_benchmarks(&output)?;
+    let suite = benchmark::discover_benchmarks(&toolchain, &benchmark_dir)?;
 
     let total_benchmark_count = suite.total_benchmark_count();
     let filtered = suite.filtered_benchmark_count(&filter);
@@ -92,32 +91,6 @@ fn execute_runtime_benchmark_binary(
     Ok(iterator)
 }
 
-/// Compiles all runtime benchmark binaries (groups) and returns the stdout output of Cargo.
-fn compile_runtime_benchmark_binaries(
-    toolchain: &LocalToolchain,
-    dir: &Path,
-) -> anyhow::Result<Vec<u8>> {
-    let result = Command::new(&toolchain.cargo)
-        .env("RUSTC", &toolchain.rustc)
-        .arg("build")
-        .arg("--release")
-        .arg("--message-format")
-        .arg("json")
-        .current_dir(dir)
-        .output()?;
-
-    if !result.status.success() {
-        anyhow::bail!(
-            "Failed to compile runtime benchmarks\n{}\n{}",
-            String::from_utf8_lossy(&result.stdout),
-            String::from_utf8_lossy(&result.stderr)
-        );
-    } else {
-        log::info!("Successfully compiled runtime benchmarks");
-        return Ok(result.stdout);
-    }
-}
-
 fn calculate_mean<I: Iterator<Item = f64> + Clone>(iter: I) -> f64 {
     let sum: f64 = iter.clone().sum();
     let count = iter.count();