feat: deduplicate symbol maps, unwind_data and debug info

- Store pid-agnostic data in a file or json map under a mapped
`path_key` for each elf
- For each pid, store pid specific data, mostly the computed
load_bias from where each module was loaded into memory at
runtime, alongside a key to retrieve the pid-agnostic data

This way, we only write to disk relevant parts of the information.

Author: GuillaumeLagrange

.gitattributes

@@ -1,4 +1,4 @@
 testdata/perf_map/* filter=lfs diff=lfs merge=lfs -text
 *.gif binary filter=lfs diff=lfs merge=lfs -text
 src/executor/wall_time/perf/snapshots/codspeed_runner__executor__wall_time__perf__debug_info__tests__ruff_debug_info.snap filter=lfs diff=lfs merge=lfs -text
-src/executor/wall_time/perf/snapshots/codspeed_runner__executor__wall_time__perf__perf_map__tests__ruff_symbols.snap filter=lfs diff=lfs merge=lfs -text
+src/executor/wall_time/perf/snapshots/codspeed_runner__executor__wall_time__perf__module_symbols__tests__ruff_symbols.snap filter=lfs diff=lfs merge=lfs -text

.pre-commit-config.yaml

@@ -11,6 +11,7 @@ repos:
       - id: check-yaml
       - id: check-toml
       - id: check-added-large-files
+        args: ["--maxkb=1000"]
   - repo: https://github.com/doublify/pre-commit-rust
     rev: v1.0
     hooks:

Cargo.toml

@@ -10,7 +10,6 @@ default-run = "codspeed"
 name = "codspeed"
 path = "src/main.rs"
 
-
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["env", "color"] }

crates/runner-shared/src/unwind_data.rs

@@ -8,9 +8,8 @@ use std::{hash::DefaultHasher, ops::Range};
 
 pub const UNWIND_FILE_EXT: &str = "unwind_data";
 
-pub type UnwindData = UnwindDataV2;
-
-impl UnwindDataV3 {
+pub type UnwindData = UnwindDataV3;
+impl UnwindData {
     pub fn parse(reader: &[u8]) -> anyhow::Result<Self> {
         let compat: UnwindDataCompat = bincode::deserialize(reader)?;
 
@@ -93,46 +92,6 @@ impl UnwindDataV2 {
             }
         }
     }
-
-    /// Will be removed once the backend has been deployed and we can merge the changes in the
-    /// runner
-    pub fn save_to<P: AsRef<std::path::Path>>(&self, folder: P, pid: i32) -> anyhow::Result<()> {
-        let unwind_data_path = folder.as_ref().join(format!(
-            "{}_{:x}_{:x}_{}.{UNWIND_FILE_EXT}",
-            pid,
-            self.avma_range.start,
-            self.avma_range.end,
-            self.timestamp.unwrap_or_default()
-        ));
-        self.to_file(unwind_data_path)?;
-
-        Ok(())
-    }
-
-    pub fn to_file<P: AsRef<std::path::Path>>(&self, path: P) -> anyhow::Result<()> {
-        if let Ok(true) = std::fs::exists(path.as_ref()) {
-            // This happens in CI for the root `systemd-run` process which execs into bash which
-            // also execs into bash, each process reloading common libraries like `ld-linux.so`.
-            // We detect this when we harvest unwind_data by parsing the perf data (exec-harness).
-            // Until we properly handle the process tree and deduplicate unwind data, just debug
-            // log here
-            // Any relevant occurence should have other symptoms reported by users.
-            log::debug!(
-                "{} already exists, file will be truncated",
-                path.as_ref().display()
-            );
-            log::debug!("{} {:x?}", self.path, self.avma_range);
-        }
-
-        let compat = UnwindDataCompat::V2(self.clone());
-        let file = std::fs::File::create(path.as_ref())?;
-        const BUFFER_SIZE: usize = 256 * 1024 /* 256 KB */;
-
-        let writer = BufWriter::with_capacity(BUFFER_SIZE, file);
-        bincode::serialize_into(writer, &compat)?;
-
-        Ok(())
-    }
 }
 
 impl From<UnwindDataV1> for UnwindDataV2 {
@@ -293,7 +252,7 @@ mod tests {
     #[test]
     fn test_parse_v3_as_v3() {
         // Parse V3 binary artifact as V3 using UnwindData::parse
-        let parsed_v3 = UnwindDataV3::parse(V3_BINARY).expect("Failed to parse V3 data as V3");
+        let parsed_v3 = UnwindData::parse(V3_BINARY).expect("Failed to parse V3 data as V3");
 
         // Should match expected V3 data
         let expected_v3 = create_sample_v3();

src/executor/wall_time/perf/debug_info.rs

@@ -1,14 +1,19 @@
-use crate::executor::wall_time::perf::perf_map::ModuleSymbols;
+use crate::executor::wall_time::perf::module_symbols::ModuleSymbols;
 use crate::prelude::*;
 use addr2line::{fallible_iterator::FallibleIterator, gimli};
 use object::{Object, ObjectSection};
+use rayon::prelude::*;
 use runner_shared::debug_info::{DebugInfo, ModuleDebugInfo};
 use std::path::Path;
 
 type EndianRcSlice = gimli::EndianRcSlice<gimli::RunTimeEndian>;
 
 pub trait ModuleDebugInfoExt {
-    fn from_symbols<P: AsRef<Path>>(path: P, symbols: &ModuleSymbols) -> anyhow::Result<Self>
+    fn from_symbols<P: AsRef<Path>>(
+        path: P,
+        symbols: &ModuleSymbols,
+        load_bias: u64,
+    ) -> anyhow::Result<Self>
     where
         Self: Sized;
 
@@ -36,12 +41,15 @@ pub trait ModuleDebugInfoExt {
 
 impl ModuleDebugInfoExt for ModuleDebugInfo {
     /// Create debug info from existing symbols by looking up file/line in DWARF
-    fn from_symbols<P: AsRef<Path>>(path: P, symbols: &ModuleSymbols) -> anyhow::Result<Self> {
+    fn from_symbols<P: AsRef<Path>>(
+        path: P,
+        symbols: &ModuleSymbols,
+        load_bias: u64,
+    ) -> anyhow::Result<Self> {
         let content = std::fs::read(path.as_ref())?;
         let object = object::File::parse(&*content)?;
 
         let ctx = Self::create_dwarf_context(&object).context("Failed to create DWARF context")?;
-        let load_bias = symbols.load_bias();
         let (mut min_addr, mut max_addr) = (None, None);
         let debug_infos = symbols
             .symbols()
@@ -96,34 +104,27 @@ impl ModuleDebugInfoExt for ModuleDebugInfo {
     }
 }
 
-/// Represents all the modules inside a process and their debug info.
-pub struct ProcessDebugInfo {
-    modules: Vec<ModuleDebugInfo>,
-}
-
-impl ProcessDebugInfo {
-    pub fn new(
-        process_symbols: &crate::executor::wall_time::perf::perf_map::ProcessSymbols,
-    ) -> Self {
-        let mut modules = Vec::new();
-        for (path, module_symbols) in process_symbols.modules_with_symbols() {
-            match ModuleDebugInfo::from_symbols(path, module_symbols) {
-                Ok(module_debug_info) => {
-                    modules.push(module_debug_info);
-                }
+/// Compute debug info once per unique ELF path from deduplicated symbols.
+/// Returns a map of path -> ModuleDebugInfo with `load_bias: 0` (load bias is per-pid).
+pub fn debug_info_by_path(
+    mounted_modules_by_path: &std::collections::HashMap<
+        std::path::PathBuf,
+        crate::executor::wall_time::perf::parse_perf_file::MountedModule,
+    >,
+) -> std::collections::HashMap<std::path::PathBuf, ModuleDebugInfo> {
+    mounted_modules_by_path
+        .par_iter()
+        .filter_map(|(path, mounted_module)| {
+            let module_symbols = mounted_module.module_symbols.as_ref()?;
+            match ModuleDebugInfo::from_symbols(path, module_symbols, 0) {
+                Ok(module_debug_info) => Some((path.clone(), module_debug_info)),
                 Err(error) => {
                     trace!("Failed to load debug info for module {path:?}: {error}");
+                    None
                 }
             }
-        }
-
-        Self { modules }
-    }
-
-    /// Returns the debug info modules for this process
-    pub fn modules(self) -> Vec<ModuleDebugInfo> {
-        self.modules
-    }
+        })
+        .collect()
 }
 
 #[cfg(test)]
@@ -134,23 +135,30 @@ mod tests {
     fn test_golang_debug_info() {
         let (start_addr, end_addr, file_offset) =
             (0x0000000000402000_u64, 0x000000000050f000_u64, 0x2000);
-        let module_symbols = ModuleSymbols::new(
+        let module_symbols = ModuleSymbols::from_elf("testdata/perf_map/go_fib.bin").unwrap();
+        let load_bias = ModuleSymbols::compute_load_bias(
             "testdata/perf_map/go_fib.bin",
             start_addr,
             end_addr,
             file_offset,
         )
         .unwrap();
-        let module_debug_info =
-            ModuleDebugInfo::from_symbols("testdata/perf_map/go_fib.bin", &module_symbols).unwrap();
+        let module_debug_info = ModuleDebugInfo::from_symbols(
+            "testdata/perf_map/go_fib.bin",
+            &module_symbols,
+            load_bias,
+        )
+        .unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
     }
 
     #[test]
     fn test_cpp_debug_info() {
         let (start_addr, end_addr, file_offset) =
             (0x0000000000400000_u64, 0x0000000000459000_u64, 0x0);
-        let module_symbols = ModuleSymbols::new(
+        let module_symbols =
+            ModuleSymbols::from_elf("testdata/perf_map/cpp_my_benchmark.bin").unwrap();
+        let load_bias = ModuleSymbols::compute_load_bias(
             "testdata/perf_map/cpp_my_benchmark.bin",
             start_addr,
             end_addr,
@@ -160,6 +168,7 @@ mod tests {
         let mut module_debug_info = ModuleDebugInfo::from_symbols(
             "testdata/perf_map/cpp_my_benchmark.bin",
             &module_symbols,
+            load_bias,
         )
         .unwrap();
 
@@ -172,27 +181,33 @@ mod tests {
     fn test_rust_divan_debug_info() {
         const MODULE_PATH: &str = "testdata/perf_map/divan_sleep_benches.bin";
 
-        let module_symbols =
-            ModuleSymbols::new(MODULE_PATH, 0x00005555555a2000, 0x0000555555692000, 0x4d000)
-                .unwrap();
+        let module_symbols = ModuleSymbols::from_elf(MODULE_PATH).unwrap();
+        let load_bias = ModuleSymbols::compute_load_bias(
+            MODULE_PATH,
+            0x00005555555a2000,
+            0x0000555555692000,
+            0x4d000,
+        )
+        .unwrap();
         let module_debug_info =
-            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols).unwrap();
+            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols, load_bias).unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
     }
 
     #[test]
     fn test_the_algorithms_debug_info() {
         const MODULE_PATH: &str = "testdata/perf_map/the_algorithms.bin";
 
-        let module_symbols = ModuleSymbols::new(
+        let module_symbols = ModuleSymbols::from_elf(MODULE_PATH).unwrap();
+        let load_bias = ModuleSymbols::compute_load_bias(
             MODULE_PATH,
             0x00005573e59fe000,
             0x00005573e5b07000,
             0x00052000,
         )
         .unwrap();
         let module_debug_info =
-            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols).unwrap();
+            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols, load_bias).unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
     }
 
@@ -202,10 +217,12 @@ mod tests {
 
         let (start_addr, end_addr, file_offset) =
             (0x0000555555e6d000_u64, 0x0000555556813000_u64, 0x918000);
-        let module_symbols =
-            ModuleSymbols::new(MODULE_PATH, start_addr, end_addr, file_offset).unwrap();
+        let module_symbols = ModuleSymbols::from_elf(MODULE_PATH).unwrap();
+        let load_bias =
+            ModuleSymbols::compute_load_bias(MODULE_PATH, start_addr, end_addr, file_offset)
+                .unwrap();
         let module_debug_info =
-            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols).unwrap();
+            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols, load_bias).unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
     }
 }

src/executor/wall_time/perf/elf_helper.rs

@@ -185,18 +185,6 @@ pub fn relative_address_base(object_file: &object::File) -> u64 {
     object_file.relative_address_base()
 }
 
-pub fn compute_base_avma(
-    runtime_start_addr: u64,
-    runtime_end_addr: u64,
-    runtime_file_offset: u64,
-    object: &object::File,
-) -> anyhow::Result<u64> {
-    let bias = compute_load_bias(
-        runtime_start_addr,
-        runtime_end_addr,
-        runtime_file_offset,
-        object,
-    )?;
-    let base_svma = relative_address_base(object);
-    Ok(base_svma.wrapping_add(bias))
+pub fn compute_base_avma(base_svma: u64, load_bias: u64) -> u64 {
+    base_svma.wrapping_add(load_bias)
 }