Print runtime benchmark measurement statistics

Author: Kobzol

collector/benchlib/src/measure/perf_counter/windows.rs

@@ -1,8 +1,5 @@
-use crate::messages::BenchmarkStats;
+use crate::comm::messages::BenchmarkMeasurement;
 
-pub fn benchmark_function<F: FnOnce() -> R, R>(
-    _name: &'static str,
-    _func: F,
-) -> anyhow::Result<BenchmarkStats> {
+pub fn benchmark_function<F: FnOnce() -> R, R>(_func: F) -> anyhow::Result<BenchmarkMeasurement> {
     panic!("Runtime benchmarking is not supported on Windows");
 }

collector/src/runtime/benchmark.rs

@@ -86,6 +86,7 @@ pub fn discover_benchmarks(cargo_stdout: &[u8]) -> anyhow::Result<BenchmarkDatab
         }
     }
 
+    binaries.sort_unstable_by(|a, b| a.path.cmp(&b.path));
     log::debug!("Found binaries: {:?}", binaries);
 
     Ok(BenchmarkDatabase { binaries })

collector/src/runtime/mod.rs

@@ -2,7 +2,7 @@ mod benchmark;
 
 use crate::benchmark::profile::Profile;
 use crate::toolchain::{get_local_toolchain, LocalToolchain};
-use benchlib::comm::messages::BenchmarkMessage;
+use benchlib::comm::messages::{BenchmarkMeasurement, BenchmarkMessage, BenchmarkStats};
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -50,6 +50,7 @@ pub fn bench_runtime(
                         benchmark_index,
                         filtered
                     );
+                    print_stats(&stats);
                 }
             }
         }
@@ -113,3 +114,32 @@ fn compile_runtime_benchmarks(toolchain: &LocalToolchain, dir: &Path) -> anyhow:
         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();
+    sum / count as f64
+}
+
+fn print_stats(stats: &BenchmarkStats) {
+    fn print_metric<F: Fn(&BenchmarkMeasurement) -> u64>(stats: &BenchmarkStats, name: &str, f: F) {
+        let mean = calculate_mean(stats.measurements.iter().map(&f).map(|v| v as f64));
+        let stddev = calculate_mean(
+            stats
+                .measurements
+                .iter()
+                .map(&f)
+                .map(|v| (v as f64 - mean).powf(2.0)),
+        )
+        .sqrt();
+
+        let name = format!("[{name}]");
+        println!("{name:>20}: {:>16} (+/- {:>8})", mean as u64, stddev as u64);
+    }
+
+    print_metric(stats, "Instructions", |m| m.instructions);
+    print_metric(stats, "Cycles", |m| m.cycles);
+    print_metric(stats, "Wall time [us]", |m| m.wall_time.as_micros() as u64);
+    print_metric(stats, "Branch misses", |m| m.branch_misses);
+    print_metric(stats, "Cache misses", |m| m.cache_misses);
+}