fix(callgrind-utils): bound flamegraph folding on large graphs

Folding expanded every root-to-leaf path; on a real graph with heavily-shared
subtrees (a Node/V8 profile: ~9.5k nodes, 30k edges) this blew up exponentially
and never terminated. Prune any branch whose budget falls below a small fraction
of the total. Because budget is conserved and splits across a node's children, a
relative floor bounds the surviving paths to ~1/fraction, so the same profile now
folds in ~70ms. Small graphs are unaffected (the absolute 1-instruction floor
still dominates).

Author: not-matthias

callgrind-utils/src/flamegraph.rs

@@ -3,10 +3,15 @@ use inferno::flamegraph::{self, Options};
 use super::{error::FlamegraphError, model::CallGraph};
 
 /// Below this incoming budget a frame rounds to zero cost, so descending
-/// further would only emit empty lines. Pruning here also bounds traversal of
-/// deep or heavily-shared subtrees.
+/// 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.
@@ -38,13 +43,18 @@ impl CallGraph {
             .map(|i| self.self_cost(i) + out[i].iter().map(|(_, c)| *c).sum::<u64>())
             .collect();
 
+        let roots = self.roots(&incoming_incl, &incl);
+        let total: f64 = roots.iter().map(|(_, b)| *b).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 on_path = vec![false; n];
-        for (root, budget) in self.roots(&incoming_incl, &incl) {
+        for (root, budget) in roots {
             fold_dfs(
                 root,
                 budget,
+                min_budget,
                 &mut stack,
                 &mut on_path,
                 &out,
@@ -120,6 +130,7 @@ impl CallGraph {
 fn fold_dfs(
     node: usize,
     budget: f64,
+    min_budget: f64,
     stack: &mut Vec<usize>,
     on_path: &mut [bool],
     out: &[Vec<(usize, u64)>],
@@ -128,7 +139,7 @@ fn fold_dfs(
     names: &[&str],
     lines: &mut Vec<String>,
 ) {
-    if budget < MIN_BUDGET || incl[node] == 0 {
+    if budget < min_budget || incl[node] == 0 {
         return;
     }
 
@@ -151,6 +162,7 @@ fn fold_dfs(
             fold_dfs(
                 child,
                 child_budget,
+                min_budget,
                 stack,
                 on_path,
                 out,