--wip-- [skip ci]

Author: GuillaumeLagrange

crates/runner-shared/src/metadata.rs

@@ -1,4 +1,5 @@
 use anyhow::Context;
+use libc::pid_t;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::BufWriter;
@@ -7,7 +8,7 @@ use std::path::PathBuf;
 
 use crate::debug_info::{DebugInfoPidMapping, ModuleDebugInfo};
 use crate::fifo::MarkerType;
-use crate::perf_map::SymbolPidMapping;
+use crate::perf_map::ProcessModuleLoadBias;
 use crate::unwind_data::UnwindDataPidMapping;
 
 #[derive(Serialize, Deserialize)]
@@ -32,23 +33,23 @@ pub struct PerfMetadata {
     /// Kept for backward compatibility, was used before deduplication of debug info entries.
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
     #[deprecated(note = "Use 'debug_info' + 'debug_info_pid_mappings_by_pid' instead")]
-    pub debug_info_by_pid: HashMap<i32, Vec<ModuleDebugInfo>>,
+    pub debug_info_by_pid: HashMap<pid_t, Vec<ModuleDebugInfo>>,
 
     /// Deduplicated debug info entries, keyed by semantic key
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
     pub debug_info: HashMap<String, ModuleDebugInfo>,
 
     /// Per-pid debug info references, mapping PID to list of debug info index + load bias
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub debug_info_pid_mappings_by_pid: HashMap<i32, Vec<DebugInfoPidMapping>>,
+    pub debug_info_pid_mappings_by_pid: HashMap<pid_t, Vec<DebugInfoPidMapping>>,
 
     /// Per-pid unwind data references, mapping PID to list of unwind data index + mounting info
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub unwind_data_pid_mappings_by_pid: HashMap<i32, Vec<UnwindDataPidMapping>>,
+    pub unwind_data_pid_mappings_by_pid: HashMap<pid_t, Vec<UnwindDataPidMapping>>,
 
     /// Per-pid symbol references, mapping PID to list of perf map index + load bias
     #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub symbol_pid_mappings_by_pid: HashMap<i32, Vec<SymbolPidMapping>>,
+    pub symbol_pid_mappings_by_pid: HashMap<pid_t, Vec<ProcessModuleLoadBias>>,
 
     /// Mapping from semantic key to original binary path
     /// Kept for traceability, and if we ever need to reconstruct the original paths from the keys

crates/runner-shared/src/perf_map.rs

@@ -5,7 +5,7 @@ pub const SYMBOLS_MAP_SUFFIX: &str = "symbols.map";
 
 /// Per-pid mounting info referencing a deduplicated perf map entry.
 #[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct SymbolPidMapping {
+pub struct ProcessModuleLoadBias {
     pub perf_map_key: String,
     pub load_bias: u64,
 }

crates/runner-shared/src/unwind_data.rs

@@ -163,14 +163,25 @@ impl Debug for UnwindDataV3 {
 }
 
 /// Per-pid mounting info referencing a deduplicated unwind data entry.
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct UnwindDataPidMapping {
     pub unwind_data_key: String,
     pub timestamp: Option<u64>,
     pub avma_range: Range<u64>,
     pub base_avma: u64,
 }
 
+impl Debug for UnwindDataPidMapping {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("UnwindDataPidMapping")
+            .field("unwind_data_key", &self.unwind_data_key)
+            .field("timestamp", &self.timestamp)
+            .field("avma_range", &format_args!("{:x?}", self.avma_range))
+            .field("base_avma", &format_args!("{:x}", self.base_avma))
+            .finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/executor/wall_time/perf/debug_info.rs

@@ -107,18 +107,19 @@ impl ModuleDebugInfoExt for ModuleDebugInfo {
 /// 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(
-    symbols_by_path: &std::collections::HashMap<
+    mounted_modules_by_path: &std::collections::HashMap<
         std::path::PathBuf,
-        crate::executor::wall_time::perf::perf_map::ModuleSymbols,
+        crate::executor::wall_time::perf::parse_perf_file::MountedModule,
     >,
 ) -> std::collections::HashMap<std::path::PathBuf, ModuleDebugInfo> {
-    symbols_by_path
+    mounted_modules_by_path
         .par_iter()
-        .filter_map(|(path, module_symbols)| {
+        .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}",);
+                    trace!("Failed to load debug info for module {path:?}: {error}");
                     None
                 }
             }
@@ -134,7 +135,8 @@ 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,
@@ -144,7 +146,7 @@ mod tests {
         let module_debug_info = ModuleDebugInfo::from_symbols(
             "testdata/perf_map/go_fib.bin",
             &module_symbols,
-            module_symbols.load_bias(),
+            load_bias,
         )
         .unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
@@ -154,7 +156,9 @@ mod tests {
     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,
@@ -164,7 +168,7 @@ mod tests {
         let mut module_debug_info = ModuleDebugInfo::from_symbols(
             "testdata/perf_map/cpp_my_benchmark.bin",
             &module_symbols,
-            module_symbols.load_bias(),
+            load_bias,
         )
         .unwrap();
 
@@ -177,29 +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, module_symbols.load_bias())
-                .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, module_symbols.load_bias())
-                .unwrap();
+            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols, load_bias).unwrap();
         insta::assert_debug_snapshot!(module_debug_info.debug_infos);
     }
 
@@ -209,11 +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_debug_info =
-            ModuleDebugInfo::from_symbols(MODULE_PATH, &module_symbols, module_symbols.load_bias())
+        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, 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)
 }