chore: add instructions event, and use runner_shared for monitored events

Author: GuillaumeLagrange

crates/runner-shared/src/lib.rs

@@ -2,5 +2,6 @@ pub mod artifacts;
 pub mod debug_info;
 pub mod fifo;
 pub mod metadata;
+pub mod perf_event;
 pub mod unwind_data;
 pub mod walltime_results;

crates/runner-shared/src/perf_event.rs

@@ -0,0 +1,44 @@
+/// Subset of perf events that CodSpeed supports.
+#[derive(Debug, Clone, Copy)]
+pub enum PerfEvent {
+    CpuCycles,
+    CacheReferences,
+    CacheMisses,
+    Instructions,
+}
+
+impl PerfEvent {
+    pub fn to_perf_string(&self) -> &'static str {
+        match self {
+            PerfEvent::CpuCycles => "cpu-cycles",
+            PerfEvent::CacheReferences => "cache-references",
+            PerfEvent::CacheMisses => "cache-misses",
+            PerfEvent::Instructions => "instructions",
+        }
+    }
+
+    pub fn from_perf_string(event: &str) -> Option<PerfEvent> {
+        match event {
+            "cpu-cycles" => Some(PerfEvent::CpuCycles),
+            "cache-references" => Some(PerfEvent::CacheReferences),
+            "cache-misses" => Some(PerfEvent::CacheMisses),
+            "instructions" => Some(PerfEvent::Instructions),
+            _ => None,
+        }
+    }
+
+    pub fn all_events() -> Vec<PerfEvent> {
+        vec![
+            PerfEvent::CpuCycles,
+            PerfEvent::CacheReferences,
+            PerfEvent::CacheMisses,
+            PerfEvent::Instructions,
+        ]
+    }
+}
+
+impl std::fmt::Display for PerfEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.to_perf_string())
+    }
+}

src/executor/wall_time/perf/perf_executable.rs

@@ -1,3 +1,5 @@
+use runner_shared::perf_event::PerfEvent;
+
 use crate::prelude::*;
 use std::path::Path;
 
@@ -67,15 +69,7 @@ pub fn get_working_perf_executable() -> Option<OsString> {
 /// Detects if the required perf events are available on this system.
 /// Returns the flags to pass to perf record command if they are available, otherwise returns None.
 pub fn get_event_flags(perf_executable: &OsString) -> anyhow::Result<Option<String>> {
-    const CYCLES_EVENT_NAME: &str = "cycles";
-    const CACHE_REFERENCES_EVENT_NAME: &str = "cache-references";
-    const CACHE_MISSES_EVENT_NAME: &str = "cache-misses";
-
-    let perf_events = [
-        CYCLES_EVENT_NAME,
-        CACHE_REFERENCES_EVENT_NAME,
-        CACHE_MISSES_EVENT_NAME,
-    ];
+    let perf_events = PerfEvent::all_events();
 
     let output = Command::new(perf_executable)
         .arg("list")
@@ -97,29 +91,28 @@ pub fn get_event_flags(perf_executable: &OsString) -> anyhow::Result<Option<Stri
     //  cpu-cycles OR cycles                               [Hardware event]
     //  instructions                                       [Hardware event]
     //  ref-cycles                                         [Hardware event]
-    let missing_events: Vec<&str> = perf_events
+    let missing_events: Vec<PerfEvent> = perf_events
         .iter()
         .filter(|&&event| {
-            !stdout
-                .lines()
-                .any(|line| line.split_whitespace().any(|word| word == event))
+            !stdout.lines().any(|line| {
+                line.split_whitespace()
+                    .any(|word| word == event.to_perf_string())
+            })
         })
         .copied()
         .collect();
 
     if !missing_events.is_empty() {
         warn!(
             "Not all required perf events available. Missing: [{}], using default events",
-            missing_events.join(", ")
+            missing_events.into_iter().join(", ")
         );
         return Ok(None);
     }
 
-    debug!(
-        "All required perf events available: {}",
-        perf_events.join(", ")
-    );
-    Ok(Some(format!("-e {{{}}}", perf_events.join(","))))
+    let events_string = perf_events.into_iter().join(",");
+    debug!("All required perf events available: {events_string}",);
+    Ok(Some(format!("-e {{{events_string}}}")))
 }
 
 pub fn get_compression_flags<S: AsRef<Path>>(perf_executable: S) -> Result<Option<String>> {