refactor: wrap external callgrind graph

Author: not-matthias

callgrind-utils/Cargo.lock

@@ -6,6 +6,8 @@ edition = "2024"
 [dependencies]
 inferno = { version = "0.12.6", default-features = false }
 callgrind-parser = { git = "ssh://git@github.com/CodSpeedHQ/platform.git", package = "callgrind-parser" }
+callgraph-shared = { git = "ssh://git@github.com/CodSpeedHQ/platform.git", package = "callgraph-shared" }
+petgraph = "0.7.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "2"

callgrind-utils/Cargo.toml

@@ -1,59 +1,61 @@
+use std::collections::HashMap;
+
+use callgraph_shared::interfaces::CostVec;
 use inferno::flamegraph::{self, Options};
+use petgraph::{
+    graph::NodeIndex,
+    visit::{EdgeRef, IntoEdgeReferences},
+};
 
 use super::{error::FlamegraphError, model::CallGraph};
 
-/// Below this incoming budget a frame rounds to zero cost, so descending
-/// further would only emit empty lines.
 const MIN_BUDGET: f64 = 1.0;
-
-/// Fraction of the total cost below which a branch is pruned. Budget is
-/// conserved and splits across a node's children, so a relative floor bounds
-/// the number of surviving paths to ~1/this, keeping the fold tractable on
-/// large graphs with heavily-shared subtrees (e.g. a real Node/V8 profile).
 const MIN_BUDGET_FRACTION: f64 = 0.0005;
 
 impl CallGraph {
-    /// Fold the graph into Brendan-Gregg "collapsed stack" lines
-    /// (`root;child;leaf <count>`), the input format for flamegraph tools.
-    ///
-    /// Each line carries a node's SELF cost for one call path; a frame's width
-    /// in the rendered graph is the sum of the self costs of everything beneath
-    /// it, i.e. its inclusive cost. Because Callgrind aggregates cost per
-    /// function (not per call path), a node's self cost is distributed across
-    /// its incoming paths in proportion to each call's inclusive cost.
     pub fn to_folded(&self) -> Vec<String> {
-        let n = self.nodes.len();
-        let names: Vec<&str> = self
-            .nodes
+        let graph = self.inner.graph.borrow();
+        let indices: Vec<NodeIndex> = graph.node_indices().collect();
+        let index_by_node: HashMap<NodeIndex, usize> = indices
+            .iter()
+            .enumerate()
+            .map(|(index, node)| (*node, index))
+            .collect();
+
+        let names: Vec<&str> = indices
+            .iter()
+            .map(|index| graph[*index].name.as_str())
+            .collect();
+        let self_costs: Vec<u64> = indices
             .iter()
-            .map(|node| node.function.as_str())
+            .map(|index| first_cost(&graph[*index].costs.aggregated_cost()))
             .collect();
 
-        // Adjacency + incoming inclusive cost, keyed by sorted-node index.
-        let mut out: Vec<Vec<(usize, u64)>> = vec![Vec::new(); n];
-        let mut incoming_incl: Vec<u64> = vec![0; n];
-        for e in &self.edges {
-            let (Some(c), Some(d)) = (self.node_index(&e.caller), self.node_index(&e.callee))
-            else {
+        let n = indices.len();
+        let mut out = vec![Vec::<(usize, u64)>::new(); n];
+        let mut incoming_incl = vec![0; n];
+        for edge in graph.edge_references() {
+            let Some(&caller) = index_by_node.get(&edge.source()) else {
                 continue;
             };
-            let ic = e.inclusive_cost.unwrap_or(0);
-            out[c].push((d, ic));
-            incoming_incl[d] += ic;
+            let Some(&callee) = index_by_node.get(&edge.target()) else {
+                continue;
+            };
+            let inclusive_cost = first_cost(&edge.weight().costs.aggregated_cost());
+            out[caller].push((callee, inclusive_cost));
+            incoming_incl[callee] += inclusive_cost;
         }
 
-        // incl[i] = self[i] + sum of outgoing inclusive costs; the total cost
-        // attributed to node i across all call paths.
         let incl: Vec<u64> = (0..n)
-            .map(|i| self.self_cost(i) + out[i].iter().map(|(_, c)| *c).sum::<u64>())
+            .map(|i| self_costs[i] + out[i].iter().map(|(_, cost)| *cost).sum::<u64>())
             .collect();
 
-        let roots = self.roots(&incoming_incl, &incl);
-        let total: f64 = roots.iter().map(|(_, b)| *b).sum();
+        let roots = roots(&incoming_incl, &incl);
+        let total: f64 = roots.iter().map(|(_, budget)| *budget).sum();
         let min_budget = MIN_BUDGET.max(total * MIN_BUDGET_FRACTION);
 
         let mut lines = Vec::new();
-        let mut stack: Vec<usize> = Vec::new();
+        let mut stack = Vec::new();
         let mut on_path = vec![false; n];
         for (root, budget) in roots {
             fold_dfs(
@@ -64,15 +66,14 @@ impl CallGraph {
                 &mut on_path,
                 &out,
                 &incl,
-                &self.self_costs,
+                &self_costs,
                 &names,
                 &mut lines,
             );
         }
         lines
     }
 
-    /// Render the graph to a flamegraph SVG string.
     pub fn to_flamegraph(&self) -> Result<String, FlamegraphError> {
         let lines = self.to_folded();
         if lines.is_empty() {
@@ -83,13 +84,12 @@ impl CallGraph {
         opts.title = "Callgrind".to_string();
         opts.count_name = "instructions".to_string();
 
-        let mut svg: Vec<u8> = Vec::new();
+        let mut svg = Vec::new();
         flamegraph::from_lines(&mut opts, lines.iter().map(String::as_str), &mut svg)
             .map_err(|e| FlamegraphError::Inferno(e.to_string()))?;
         String::from_utf8(svg).map_err(|e| FlamegraphError::Inferno(e.to_string()))
     }
 
-    /// Render the graph to a flamegraph SVG file at `path`.
     pub fn to_flamegraph_file(
         &self,
         path: impl AsRef<std::path::Path>,
@@ -98,39 +98,30 @@ impl CallGraph {
         std::fs::write(path, svg)?;
         Ok(())
     }
+}
 
-    /// Entry points for the flame stacks, as `(node, budget)` pairs.
-    ///
-    /// A node's `budget` is the part of its inclusive cost NOT accounted for by
-    /// any recorded incoming call, i.e. `incl - sum(incoming edge inclusive)`.
-    /// This is nonzero for true roots (no caller) and, crucially, for frames
-    /// that were already on the stack when `--instr-atstart=no` instrumentation
-    /// began: their entry call predates measurement, so no edge carries their
-    /// cost and they would otherwise be dropped. A fully-cyclic graph has no
-    /// such node, so fall back to the single costliest node.
-    fn roots(&self, incoming_incl: &[u64], incl: &[u64]) -> Vec<(usize, f64)> {
-        let roots: Vec<(usize, f64)> = (0..self.nodes.len())
-            .filter_map(|i| {
-                let uncovered = incl[i].saturating_sub(incoming_incl[i]);
-                (uncovered > 0).then_some((i, uncovered as f64))
-            })
-            .collect();
-        if !roots.is_empty() {
-            return roots;
-        }
-        (0..self.nodes.len())
-            .filter(|&i| incl[i] > 0)
-            .max_by_key(|&i| incl[i])
-            .map(|i| (i, incl[i] as f64))
-            .into_iter()
-            .collect()
+fn first_cost(cost: &CostVec) -> u64 {
+    cost.0.first().copied().unwrap_or(0)
+}
+
+fn roots(incoming_incl: &[u64], incl: &[u64]) -> Vec<(usize, f64)> {
+    let roots: Vec<(usize, f64)> = (0..incl.len())
+        .filter_map(|i| {
+            let uncovered = incl[i].saturating_sub(incoming_incl[i]);
+            (uncovered > 0).then_some((i, uncovered as f64))
+        })
+        .collect();
+    if !roots.is_empty() {
+        return roots;
     }
+    (0..incl.len())
+        .filter(|&i| incl[i] > 0)
+        .max_by_key(|&i| incl[i])
+        .map(|i| (i, incl[i] as f64))
+        .into_iter()
+        .collect()
 }
 
-/// Emit one collapsed-stack line per node reachable from `node`, distributing
-/// self cost by `budget / incl` (the share of this node's total cost that flows
-/// through the current path). A node already on the path is a recursion edge:
-/// emit it as a leaf carrying the incoming budget rather than descend.
 #[allow(clippy::too_many_arguments)]
 fn fold_dfs(
     node: usize,
@@ -151,10 +142,6 @@ fn fold_dfs(
     stack.push(node);
     on_path[node] = true;
 
-    // Share of this node's aggregated cost that flows through the current path.
-    // In consistent Callgrind data a single incoming edge never exceeds the
-    // node's total inclusive cost, so frac <= 1; clamp guards against malformed
-    // input amplifying cost down the tree.
     let frac = (budget / incl[node] as f64).min(1.0);
     let self_here = (self_costs[node] as f64 * frac).round() as u64;
     if self_here >= 1 {
@@ -178,7 +165,6 @@ fn fold_dfs(
             );
             continue;
         }
-        // Recursion: represent the recursive cost without looping.
         let recursive = child_budget.round() as u64;
         if recursive >= 1 {
             stack.push(child);
@@ -191,7 +177,6 @@ fn fold_dfs(
     stack.pop();
 }
 
-/// `name0;name1;...;nameK <count>` for the current index stack.
 fn fold_line(stack: &[usize], names: &[&str], count: u64) -> String {
     let mut line = String::new();
     for (i, &idx) in stack.iter().enumerate() {

callgrind-utils/src/flamegraph.rs

@@ -1,7 +1,6 @@
 pub mod error;
 pub mod flamegraph;
 pub mod model;
-mod normalize;
 pub mod parser;
 mod redact;
 pub mod serialize;