chore: wip [skip ci]

Author: not-matthias

Cargo.lock

@@ -53,8 +53,9 @@ object = "0.36.7"
 linux-perf-data = "0.11.0"
 debugid = "0.8.0"
 memmap2 = "0.9.5"
-nix = { version = "0.29.0", features = ["fs", "user"] }
+nix = { version = "0.29.0", features = ["fs", "time", "user"] }
 futures = "0.3.31"
+runner-shared = { path = "crates/runner-shared" }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 procfs = "0.17.0"
@@ -67,6 +68,9 @@ rstest = { version = "0.25.0", default-features = false }
 rstest_reuse = "0.7.0"
 shell-quote = "0.7.2"
 
+[workspace]
+members = ["crates/runner-shared"]
+
 [workspace.metadata.release]
 sign-tag = true
 sign-commit = true

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "runner-shared"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0.100"
+serde = { version = "1.0.225", features = ["derive"] }
+serde_json = "1.0.145"

crates/runner-shared/Cargo.toml

@@ -0,0 +1,28 @@
+//! WARNING: Has to be in sync with `codspeed-rust/codspeed`.
+
+pub const RUNNER_CTL_FIFO: &str = "/tmp/runner.ctl.fifo";
+pub const RUNNER_ACK_FIFO: &str = "/tmp/runner.ack.fifo";
+
+/// 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.
+#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Copy, Clone)]
+pub enum MarkerType {
+    SampleStart(u64),
+    SampleEnd(u64),
+    BenchmarkStart(u64),
+    BenchmarkEnd(u64),
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
+pub enum Command {
+    CurrentBenchmark { pid: u32, uri: String },
+    StartBenchmark,
+    StopBenchmark,
+    Ack,
+    PingPerf,
+    SetIntegration { name: String, version: String },
+    Err,
+    AddMarker { pid: u32, marker: MarkerType },
+}

crates/runner-shared/src/fifo.rs

@@ -0,0 +1,5 @@
+// This will be accessed from the `parse_callgraph` lambda.
+
+pub mod fifo;
+pub mod metadata;
+pub mod unwind_data;

crates/runner-shared/src/lib.rs

@@ -4,12 +4,20 @@
 // Has to be in sync with `perf-parser`.
 //
 
+use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, path::Path};
 
-use serde::{Deserialize, Serialize};
+use crate::fifo::MarkerType;
+
+pub const PERF_METADATA_CURRENT_VERSION: u64 = 1;
 
 #[derive(Serialize, Deserialize)]
 pub struct PerfMetadata {
+    /// The version of this metadata format.
+    /// Only available in version 1+
+    #[serde(default)]
+    pub version: u64,
+
     /// Name and version of the integration
     pub integration: (String, String),
 
@@ -18,6 +26,11 @@ pub struct PerfMetadata {
 
     /// Modules that should be ignored and removed from the folded trace and callgraph (e.g. python interpreter)
     pub ignored_modules: Vec<(String, u64, u64)>,
+
+    /// Marker for certain regions in the profiling data
+    /// Only available in version 1+
+    #[serde(default)]
+    pub markers: Vec<MarkerType>,
 }
 
 impl PerfMetadata {

src/run/runner/wall_time/perf/metadata.rs crates/runner-shared/src/metadata.rssrc/run/runner/wall_time/perf/metadata.rs renamed to crates/runner-shared/src/metadata.rs

@@ -0,0 +1,49 @@
+use core::{
+    fmt::Debug,
+    hash::{Hash, Hasher},
+};
+use serde::{Deserialize, Serialize};
+use std::{hash::DefaultHasher, ops::Range};
+
+/// Unwind data for a single module.
+#[derive(Serialize, Deserialize)]
+pub struct UnwindData {
+    pub path: String,
+
+    pub avma_range: Range<u64>,
+    pub base_avma: u64,
+
+    pub eh_frame_hdr: Vec<u8>,
+    pub eh_frame_hdr_svma: Range<u64>,
+
+    pub eh_frame: Vec<u8>,
+    pub eh_frame_svma: Range<u64>,
+}
+
+impl Debug for UnwindData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let eh_frame_hdr_hash = {
+            let mut hasher = DefaultHasher::new();
+            self.eh_frame_hdr.hash(&mut hasher);
+            hasher.finish()
+        };
+        let eh_frame_hash = {
+            let mut hasher = DefaultHasher::new();
+            self.eh_frame.hash(&mut hasher);
+            hasher.finish()
+        };
+
+        f.debug_struct("UnwindData")
+            .field("path", &self.path)
+            .field("avma_range", &format_args!("{:x?}", self.avma_range))
+            .field("base_avma", &format_args!("{:x}", self.base_avma))
+            .field(
+                "eh_frame_hdr_svma",
+                &format_args!("{:x?}", self.eh_frame_hdr_svma),
+            )
+            .field("eh_frame_hdr_hash", &format_args!("{eh_frame_hdr_hash:x}"))
+            .field("eh_frame_hash", &format_args!("{eh_frame_hash:x}"))
+            .field("eh_frame_svma", &format_args!("{:x?}", self.eh_frame_svma))
+            .finish()
+    }
+}

crates/runner-shared/src/unwind_data.rs

@@ -1,4 +1,5 @@
-use super::{FifoCommand, RUNNER_ACK_FIFO, RUNNER_CTL_FIFO};
+use super::FifoCommand;
+use runner_shared::fifo::{RUNNER_ACK_FIFO, RUNNER_CTL_FIFO};
 use std::path::PathBuf;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::unix::pipe::OpenOptions as TokioPipeOpenOptions;

src/run/runner/wall_time/perf/fifo.rs

@@ -2,10 +2,11 @@ use crate::{
     prelude::*,
     run::runner::wall_time::perf::{
         perf_map::{ModuleSymbols, Symbol},
-        unwind_data::UnwindData,
+        unwind_data::UnwindDataExt,
     },
 };
 use linux_perf_data::jitdump::{JitDumpReader, JitDumpRecord};
+use runner_shared::unwind_data::UnwindData;
 use std::{
     collections::HashSet,
     path::{Path, PathBuf},