refactor: rename Benchmark FIFO commands/markers to Profiler/Round

Rename `StartBenchmark`/`StopBenchmark` to `StartProfiler`/`StopProfiler`
and `BenchmarkStart`/`BenchmarkEnd` markers to `RoundStart`/`RoundEnd` to
match the profiler-agnostic data format.

Author: not-matthias

crates/runner-shared/src/fifo.rs

@@ -18,15 +18,15 @@ const _: () = assert!(
 /// The different markers that can be set in the perf.data.
 ///
 /// `SampleStart/End`: Marks the start and end of a sampling period. This is used to differentiate between benchmarks.
-/// `BenchmarkStart/End`: Marks the start and end of a benchmark. This is used to measure the duration of a benchmark, without the benchmark harness code.
+/// `RoundStart/End`: Marks the start and end of a measured round. This is used to measure the duration of a benchmark, without the benchmark harness code.
 #[derive(
     serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Copy, Clone,
 )]
 pub enum MarkerType {
     SampleStart(u64),
     SampleEnd(u64),
-    BenchmarkStart(u64),
-    BenchmarkEnd(u64),
+    RoundStart(u64),
+    RoundEnd(u64),
 }
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
@@ -42,8 +42,8 @@ pub enum Command {
         pid: i32,
         uri: String,
     },
-    StartBenchmark,
-    StopBenchmark,
+    StartProfiler,
+    StopProfiler,
     Ack,
     #[deprecated(note = "Use `GetIntegrationMode` instead")]
     PingProfiler,

src/executor/memory/executor.rs

@@ -207,14 +207,14 @@ impl MemoryExecutor {
                         );
                     }
                 }
-                FifoCommand::StartBenchmark => {
+                FifoCommand::StartProfiler => {
                     debug!("Enabling memtrack via IPC");
                     if let Err(e) = ipc_client.enable() {
                         error!("Failed to enable memtrack: {e}");
                         return Ok(Some(FifoCommand::Err));
                     }
                 }
-                FifoCommand::StopBenchmark => {
+                FifoCommand::StopProfiler => {
                     debug!("Disabling memtrack via IPC");
                     if let Err(e) = ipc_client.disable() {
                         // There's a chance that memtrack has already exited here, so just log as debug

src/executor/shared/fifo.rs

@@ -210,21 +210,21 @@ impl RunnerFifo {
                         bench_pids.insert(*pid);
                         self.send_cmd(FifoCommand::Ack).await?;
                     }
-                    FifoCommand::StartBenchmark => {
+                    FifoCommand::StartProfiler => {
                         if !benchmark_started {
                             benchmark_started = true;
                             markers.push(MarkerType::SampleStart(get_current_time()));
                         } else {
-                            warn!("Received duplicate StartBenchmark command, ignoring");
+                            warn!("Received duplicate StartProfiler command, ignoring");
                         }
                         self.send_cmd(FifoCommand::Ack).await?;
                     }
-                    FifoCommand::StopBenchmark => {
+                    FifoCommand::StopProfiler => {
                         if benchmark_started {
                             benchmark_started = false;
                             markers.push(MarkerType::SampleEnd(get_current_time()));
                         } else {
-                            warn!("Received StopBenchmark command before StartBenchmark, ignoring");
+                            warn!("Received StopProfiler command before StartProfiler, ignoring");
                         }
                         self.send_cmd(FifoCommand::Ack).await?;
                     }

src/executor/wall_time/executor.rs

@@ -251,12 +251,12 @@ async fn run_with_profiler(
 
     run_command_with_log_pipe_and_callback(cmd, async move |mut child| {
         let on_cmd = async |c: &FifoCommand| match c {
-            FifoCommand::StartBenchmark => {
-                profiler.on_start_benchmark().await?;
+            FifoCommand::StartProfiler => {
+                profiler.on_start_profiler().await?;
                 Ok(None)
             }
-            FifoCommand::StopBenchmark => {
-                profiler.on_stop_benchmark().await?;
+            FifoCommand::StopProfiler => {
+                profiler.on_stop_profiler().await?;
                 Ok(None)
             }
             #[allow(deprecated)]

src/executor/wall_time/profiler/mod.rs

@@ -54,12 +54,12 @@ pub trait Profiler {
     ) -> anyhow::Result<CommandBuilder>;
 
     /// The benchmarked process signaled the start of a measured region.
-    async fn on_start_benchmark(&mut self) -> anyhow::Result<()> {
+    async fn on_start_profiler(&mut self) -> anyhow::Result<()> {
         Ok(())
     }
 
     /// The benchmarked process signaled the end of a measured region.
-    async fn on_stop_benchmark(&mut self) -> anyhow::Result<()> {
+    async fn on_stop_profiler(&mut self) -> anyhow::Result<()> {
         Ok(())
     }
 

src/executor/wall_time/profiler/perf/mod.rs

@@ -187,11 +187,11 @@ impl Profiler for PerfProfiler {
         Ok(wrapped_builder)
     }
 
-    async fn on_start_benchmark(&mut self) -> anyhow::Result<()> {
+    async fn on_start_profiler(&mut self) -> anyhow::Result<()> {
         self.perf_fifo_mut()?.start_events().await
     }
 
-    async fn on_stop_benchmark(&mut self) -> anyhow::Result<()> {
+    async fn on_stop_profiler(&mut self) -> anyhow::Result<()> {
         self.perf_fifo_mut()?.stop_events().await
     }