Add support for capturing multiple measurements

Previously, only a single measure type could be requested.  Often,
we might want to capture multiple measures on a benchmark run as
different measurements might provide a more complete picture of
a given benchmark iteration.

Author: posborne

crates/cli/src/benchmark.rs

@@ -4,6 +4,7 @@ use rand::{rngs::SmallRng, Rng, SeedableRng};
 use sightglass_data::{Format, Measurement, Phase};
 use sightglass_recorder::bench_api::Engine;
 use sightglass_recorder::cpu_affinity::bind_to_single_core;
+use sightglass_recorder::measure::multi::MultiMeasure;
 use sightglass_recorder::measure::Measurements;
 use sightglass_recorder::{bench_api::BenchApi, benchmark, measure::MeasureType};
 use std::{
@@ -80,9 +81,11 @@ pub struct BenchmarkCommand {
     output_file: Option<String>,
 
     /// The type of measurement to use (cycles, insts-retired, perf-counters, noop, vtune)
-    /// when recording the benchmark performance.
-    #[structopt(long, short, default_value = "cycles")]
-    measure: MeasureType,
+    /// when recording the benchmark performance.  This option can be specified more than
+    /// once if to record multiple measurements.  If no measures are specified,
+    /// the "cycles" measure will be used.
+    #[structopt(long = "measure", short = "m", multiple = true)]
+    measures: Vec<MeasureType>,
 
     /// Pass this flag to only run benchmarks over "small" workloads (rather
     /// than the larger, default workloads).
@@ -194,7 +197,12 @@ impl BenchmarkCommand {
                 let stdin = None;
 
                 let mut measurements = Measurements::new(this_arch(), engine, wasm_file);
-                let mut measure = self.measure.build();
+                let mut measure = if self.measures.len() <= 1 {
+                    let measure = self.measures.first().unwrap_or(&MeasureType::Cycles);
+                    measure.build()
+                } else {
+                    Box::new(MultiMeasure::new(self.measures.iter().map(|m| m.build())))
+                };
 
                 // Create the bench API engine and cache it for reuse across all
                 // iterations of this benchmark.
@@ -354,8 +362,12 @@ impl BenchmarkCommand {
                 .arg(self.iterations_per_process.to_string())
                 .arg("--engine")
                 .arg(&engine)
-                .arg("--measure")
-                .arg(self.measure.to_string())
+                .args(
+                    self.measures
+                        .iter()
+                        .map(|m| ["--measure".to_string(), m.to_string()])
+                        .flatten(),
+                )
                 .arg("--raw")
                 .arg("--output-format")
                 // Always use JSON when privately communicating with a

crates/recorder/src/measure/mod.rs

@@ -83,6 +83,7 @@ pub mod counters;
 pub mod insts;
 
 pub mod cycles;
+pub mod multi;
 pub mod noop;
 pub mod time;
 pub mod vtune;

crates/recorder/src/measure/multi.rs

@@ -0,0 +1,34 @@
+//! Multiplexing measurement in order to take multiple measures
+//! from a single entry point.
+
+use sightglass_data::Phase;
+
+use super::{Measure, Measurements};
+
+pub struct MultiMeasure {
+    measures: Vec<Box<dyn Measure>>
+}
+
+impl MultiMeasure {
+    pub fn new<I>(measures: I) -> Self
+        where I: IntoIterator<Item = Box<dyn Measure>>
+    {
+        Self {
+            measures: measures.into_iter().collect()
+        }
+    }
+}
+
+impl Measure for MultiMeasure {
+    fn start(&mut self, phase: Phase) {
+        for measure in self.measures.iter_mut() {
+            measure.start(phase)
+        }
+    }
+
+    fn end(&mut self, phase: Phase, measurements: &mut Measurements) {
+        for measure in self.measures.iter_mut() {
+            measure.end(phase, measurements)
+        }
+    }
+}