getting relative paths of the files

Author: xangcastle

benchmark/compare.py

@@ -94,6 +94,38 @@ def _short(name: str, limit: int = 48) -> str:
     return name
 
 
+# Top-level dirs in the rules_py repo; used to reduce noisy pprof file paths
+# (external repo or absolute checkout paths) to a repo-relative, clickable path.
+_RULES_PY_ROOTS = ("py/", "uv/", "docs/", "e2e/", "examples/", "tools/")
+
+
+def _relpath(file: str | None, limit: int = 56) -> str:
+    """Reduce a pprof source file to something locatable.
+
+    <builtin> -> "builtin"; a bzlmod MODULE.bazel URL -> "bzlmod"; otherwise try
+    to find a rules_py top-level dir and return from there (works for both the
+    bzlmod external path and an absolute local-checkout path).
+    """
+    if not file or file in ("<unknown>", ""):
+        return ""
+    if file == "<builtin>":
+        return "builtin"
+    if file.startswith("http"):
+        return "bzlmod"
+    for root in _RULES_PY_ROOTS:
+        idx = file.find("/" + root)
+        if idx != -1:
+            rel = file[idx + 1:]
+            return rel if len(rel) <= limit else rel[: limit - 1] + "\u2026"
+    if "/external/" in file:
+        after = file.split("/external/", 1)[1]
+        parts = after.split("/", 1)
+        rel = parts[1] if len(parts) > 1 else after
+        return rel if len(rel) <= limit else rel[: limit - 1] + "\u2026"
+    base = os.path.basename(file)
+    return base if len(base) <= limit else base[: limit - 1] + "\u2026"
+
+
 def _starlark_section(main_result: dict[str, Any], pr_result: dict[str, Any]) -> str:
     """Diagnostic Starlark CPU diff (PR vs main). Informational, not a gate.
 
@@ -159,24 +191,27 @@ def combined_se(m_std: float, p_std: float) -> float:
         movers.sort(key=lambda x: x[3], reverse=True)
 
         out += "**Top movers (candidates, \u0394 > 3\u03c3 marked):**\n\n"
-        out += "| Function | main ms | PR ms | \u0394 ms | \u00b1 stderr | \u0394 % |\n|---|---|---|---|---|---|\n"
+        out += "| Function | File | main ms | PR ms | \u0394 ms | \u00b1 stderr | \u0394 % |\n|---|---|---|---|---|---|---|\n"
         for name, m_ms, pr_ms, d, se in movers[:10]:
             if m_ms > 0:
                 dpct = f"+{d / m_ms * 100:.0f}%"
             else:
                 dpct = "new"
             flag = " \u26a0\ufe0f" if (se > 0 and d > FN_SIGMA * se) else ""
             out += (
-                f"| `{_short(name)}` | {m_ms:.1f} | {pr_ms:.1f} | "
-                f"+{d:.1f} | \u00b1{se:.1f} | {dpct}{flag} |\n"
+                f"| `{_short(name)}` | `{_relpath(pr_fns[name].get('file'))}` | {m_ms:.1f} | "
+                f"{pr_ms:.1f} | +{d:.1f} | \u00b1{se:.1f} | {dpct}{flag} |\n"
             )
 
     hot = [r for r in pr_fns.values() if r.get("pct", 0.0) >= HOTSPOT_MIN_PCT][:10]
     if hot:
         out += "\n**Top by absolute time (PR):**\n\n"
-        out += "| Function | PR ms | % of total |\n|---|---|---|\n"
+        out += "| Function | File | PR ms | % of total |\n|---|---|---|---|\n"
         for r in hot:
-            out += f"| `{_short(r['name'])}` | {r['mean_ms']:.1f} | {r.get('pct', 0.0):.1f}% |\n"
+            out += (
+                f"| `{_short(r['name'])}` | `{_relpath(r.get('file'))}` | "
+                f"{r['mean_ms']:.1f} | {r.get('pct', 0.0):.1f}% |\n"
+            )
 
     out += (
         "\n> Sample-based attribution (Starlark CPU across the whole `--nobuild` run: "

benchmark/pprof_decode.py

@@ -87,10 +87,12 @@ def _read_payload(path: str) -> bytes:
         return open(path, "rb").read()
 
 
-def decode_starlark_pprof(path: str) -> dict[str, float]:
-    """Return {function_name: cpu_ms} aggregated by leaf Starlark function.
+def decode_starlark_pprof(path: str) -> dict[str, tuple[float, str]]:
+    """Return {function_name: (cpu_ms, source_file)} aggregated by leaf function.
 
-    Returns {} if the profile is missing or unparseable (fail-open).
+    source_file is the pprof Function.filename (e.g. an external repo path, or
+    ``<builtin>`` for native rules/methods). Returns {} on missing/unparseable
+    profile (fail-open).
     """
     data = _read_payload(path)
     top = _fields(data)
@@ -120,13 +122,14 @@ def s(idx: object | int) -> str:
         elif unit == "nanoseconds":
             val_idx, divisor = i, 1000000.0
 
-    # function: id -> name index
+    # function: id -> (name index, filename index)
     fn_name: dict[int, int] = {}
+    fn_file: dict[int, int] = {}
     for chunk in top.get(5, []):
         f = _fields(chunk)
         fid = f.get(1, [0])[0]
-        name_idx = f.get(2, [0])[0]
-        fn_name[fid] = name_idx
+        fn_name[fid] = f.get(2, [0])[0]
+        fn_file[fid] = f.get(4, [0])[0]
 
     # location: id -> leaf function id (first line)
     loc_to_fn: dict[int, int] = {}
@@ -139,6 +142,7 @@ def s(idx: object | int) -> str:
             loc_to_fn[lid] = line.get(1, [0])[0]
 
     totals: dict[str, float] = defaultdict(float)
+    files: dict[str, str] = {}
     for chunk in top.get(2, []):
         loc_ids = _parse_packed_or_singles(chunk, 1)
         values = _parse_packed_or_singles(chunk, 2)
@@ -148,14 +152,15 @@ def s(idx: object | int) -> str:
         fid = loc_to_fn.get(leaf)
         if fid is None:
             continue
-        name_idx = fn_name.get(fid)
-        totals[s(name_idx)] += values[val_idx] / divisor
+        name = s(fn_name.get(fid))
+        totals[name] += values[val_idx] / divisor
+        files.setdefault(name, s(fn_file.get(fid)))
 
-    return dict(totals)
+    return {name: (ms, files.get(name, "<unknown>")) for name, ms in totals.items()}
 
 
 if __name__ == "__main__":
     import sys
-    rows = sorted(decode_starlark_pprof(sys.argv[1]).items(), key=lambda kv: -kv[1])
-    for name, ms in rows[:25]:
-        print(f"{ms:9.2f} ms  {name}")
+    rows = sorted(decode_starlark_pprof(sys.argv[1]).items(), key=lambda kv: -kv[1][0])
+    for name, (ms, _file) in rows[:25]:
+        print(f"{ms:9.2f} ms  {name}  [{_file}]")

benchmark/profile_benchmark.py

@@ -71,27 +71,29 @@ def stats_ms(values_ms: list[float]) -> dict[str, float]:
     }
 
 
-def aggregate_starlark(star_runs: list[dict[str, float]]) -> dict[str, Any]:
-    """Aggregate per-run {fn: ms} dicts into per-function stats + a run-level total.
+def aggregate_starlark(star_runs: list[dict[str, tuple[float, str]]]) -> dict[str, Any]:
+    """Aggregate per-run {fn: (ms, file)} dicts into per-function stats + total.
 
     Returns {'total': {mean_ms, stddev_ms, runs}, 'functions': [...]}. ALL
     functions are kept (truncation is render-time in compare.py) and each carries
-    its stddev across runs so the comparator can flag only statistically
-    significant deltas instead of run-to-run sampling noise.
+    its stddev across runs and source file so the comparator can flag only
+    statistically significant deltas and point at where to read the code.
     """
     runs = len(star_runs)
     names: set[str] = set()
     for d in star_runs:
         names.update(d.keys())
     functions: list[dict[str, Any]] = []
     for name in names:
-        series = [d.get(name, 0.0) for d in star_runs]
+        series = [d[name][0] for d in star_runs if name in d]
+        file = next((d[name][1] for d in star_runs if name in d and d[name][1]), "<unknown>")
         functions.append({
             "name": name,
+            "file": file,
             "mean_ms": statistics.mean(series),
             "stddev_ms": statistics.stdev(series) if len(series) > 1 else 0.0,
         })
-    totals = [sum(d.values()) for d in star_runs]
+    totals = [sum(ms for (ms, _f) in d.values()) for d in star_runs]
     total_mean = statistics.mean(totals)
     total_std = statistics.stdev(totals) if len(totals) > 1 else 0.0
     for r in functions: