mjolnir-cli 0.2.0__py3-none-any.whl

mjolnir_cli/verify/ncu.py

@@ -0,0 +1,141 @@
+"""Parse ``ncu --print-summary per-kernel`` logs into per-leg points."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+METRICS = "gpu__time_duration.sum,lts__t_sectors.sum,sm__cycles_active.sum,sm__ctas_launched.sum"
+
+_UNIT_US = {
+    "ns": 1e-3,
+    "nsecond": 1e-3,
+    "us": 1.0,
+    "usecond": 1.0,
+    "ms": 1e3,
+    "msecond": 1e3,
+    "s": 1e6,
+    "second": 1e6,
+}
+_SUMMARY_METRICS = ("gpu__time_duration.sum", "lts__t_sectors.sum", "sm__ctas_launched.sum", "sm__cycles_active.sum")
+
+
+def _num(x: str) -> float:
+    try:
+        return float(x.replace(",", ""))
+    except ValueError:
+        return float("nan")
+
+
+def parse_summary(text: str) -> list[dict]:
+    """Kernel rows from an ncu per-kernel summary: name, invocations,
+    avg/min µs, L2 sectors, CTAs."""
+    rows: list[dict] = []
+    cur: dict | None = None
+    for line in text.splitlines():
+        if "Invocations" in line and "Device" in line:
+            m = re.search(r"Invocations\s+(\d+)", line)
+            cur = {"header": line.strip(), "name": line.strip().split(" (")[0], "inv": int(m.group(1)) if m else 0}
+            rows.append(cur)
+            continue
+        if cur is None:
+            continue
+        p = line.split()
+        if len(p) >= 5 and p[0] in _SUMMARY_METRICS:
+            unit, mn, avg = p[1], _num(p[2]), _num(p[-1])
+            if p[0] == "gpu__time_duration.sum":
+                k = _UNIT_US.get(unit, 1.0)
+                cur["avg_us"], cur["min_us"] = avg * k, mn * k
+            elif p[0] == "lts__t_sectors.sum":
+                cur["sectors"] = avg
+            elif p[0] == "sm__ctas_launched.sum":
+                cur["ctas"] = avg
+            elif p[0] == "sm__cycles_active.sum":
+                cur["cycles"] = avg
+    return [r for r in rows if "avg_us" in r]
+
+
+def point(rows: list[dict], main: tuple[str, ...], merge: tuple[str, ...], L: int, kv_bytes: float) -> dict | None:
+    """One L point of a leg: decode (main) + merge kernel time, L2 sectors,
+    effective KV bandwidth (the leg's real KV bytes / total time)."""
+    mains = [r for r in rows if any(p in r["header"] for p in main)]
+    merges = [r for r in rows if any(p in r["header"] for p in merge) and r not in mains]
+    if not mains:
+        return None
+    main_us = sum(r["avg_us"] for r in mains)
+    merge_us = sum(r["avg_us"] for r in merges)
+    total = main_us + merge_us
+    return {
+        "L": L,
+        "total_us": round(total, 3),
+        "main_us": round(main_us, 3),
+        "merge_us": round(merge_us, 3),
+        "min_us": round(sum(r.get("min_us", r["avg_us"]) for r in mains + merges), 3),
+        "l2_sectors": sum(r.get("sectors", 0.0) for r in mains + merges),
+        "ctas": int(mains[0].get("ctas", 0) or 0),
+        "invocations": int(mains[0].get("inv", 0)),
+        "gbps": round(kv_bytes / (total * 1e3), 2) if total > 0 else 0.0,
+        "kernels": [
+            {"name": r["name"][:120], "avg_us": round(r["avg_us"], 3), "inv": r["inv"]} for r in mains + merges
+        ],
+    }
+
+
+def parse_file(path: Path, main, merge, L: int, kv_bytes: float) -> dict | None:
+    try:
+        return point(parse_summary(Path(path).read_text(errors="replace")), main, merge, L, kv_bytes)
+    except OSError:
+        return None
+
+
+# ── full-profile (fp6prof) CSV pages ─────────────────────────────────────────
+
+
+def parse_raw_csv(text: str) -> tuple[dict[str, float], dict[str, str]]:
+    """``ncu --import x --page raw --csv`` → (metric → mean over launches,
+    metric → unit)."""
+    import csv
+    import io
+
+    rows = list(csv.reader(io.StringIO(text)))
+    hi = next((i for i, r in enumerate(rows) if "Kernel Name" in r or "ID" in r), None)
+    if hi is None or len(rows) < hi + 3:
+        return {}, {}
+    hdr, unit, data = rows[hi], rows[hi + 1], rows[hi + 2 :]
+    acc: dict[str, list[float]] = {}
+    for r in data:
+        for k, v in zip(hdr, r):
+            try:
+                x = float(str(v).replace(",", ""))
+            except ValueError:
+                continue  # text columns, "n/a" — never create an empty bucket
+            acc.setdefault(k, []).append(x)
+    units = dict(zip(hdr, unit))
+    mean = {k: sum(v) / len(v) for k, v in acc.items() if v}
+    # durations -> ns whatever unit this ncu prints
+    tu = units.get("gpu__time_duration.sum", "nsecond").strip().lower()
+    k_ns = {"nsecond": 1, "ns": 1, "usecond": 1e3, "us": 1e3, "msecond": 1e6, "ms": 1e6, "second": 1e9, "s": 1e9}
+    if "gpu__time_duration.sum" in mean:
+        mean["gpu__time_duration.sum"] *= k_ns.get(tu, 1)
+        units["gpu__time_duration.sum"] = "ns"
+    return mean, units
+
+
+def parse_details_csv(text: str) -> dict[str, dict[str, float]]:
+    """``--page details --csv`` → {section: {"metric (unit)": mean}}."""
+    import csv
+    import io
+
+    acc: dict[tuple[str, str], list[float]] = {}
+    for r in csv.DictReader(io.StringIO(text)):
+        try:
+            x = float(str(r.get("Metric Value", "")).replace(",", ""))
+        except ValueError:
+            continue
+        unit = r.get("Metric Unit", "")
+        name = r.get("Metric Name", "") + (f" ({unit})" if unit else "")
+        acc.setdefault((r.get("Section Name", ""), name), []).append(x)
+    out: dict[str, dict[str, float]] = {}
+    for (sec, name), v in acc.items():
+        out.setdefault(sec, {})[name] = sum(v) / len(v)
+    return out

mjolnir_cli/verify/profile.py

@@ -0,0 +1,312 @@
+"""``mjolnir verify profile`` — where a decode step's GPU time goes.
+
+Serves each leg with vLLM's torch profiler on (``--profiler-config``), sends
+a fixed decode workload between ``/start_profile`` and ``/stop_profile``,
+and reads the trace (PyTorch / Kineto chrome-trace JSON) the worker writes:
+
+* **CUDA-graph replays**: every ``cudaGraphLaunch`` and the kernels it ran
+  (they share its CUPTI correlation id), grouped by signature (kernel count)
+  — the target's verify graph, the drafter's prefill graph, the fused draft
+  decode graph — with GPU time per replay;
+* **eager kernels** (not in a graph) per decode step — work that pays a CPU
+  launch each time;
+* GPU busy vs idle time over the window (idle = the CPU did not keep up);
+* kernel time by category (attention, GEMM, linear attention, sampling,
+  copies, …) per generated token, and the top kernels.
+
+Two legs side by side answer "is the drafter graphed, and which kernels make
+its step slower". The raw traces stay in the run's log dir.
+"""
+
+from __future__ import annotations
+
+import gzip
+import json
+import re
+import threading
+import time
+import urllib.request
+from collections import defaultdict
+from pathlib import Path
+
+from mjolnir_cli import dockerctl
+from mjolnir_cli.config import DEFAULT_IMAGE, STOCK_IMAGE, resolve
+from mjolnir_cli.legs import verify_legs
+
+DEFAULT_LEGS = verify_legs("verify.profile")  # mjolnir_cli.legs
+
+CATEGORIES = (  # first match wins: GEMMs before attention (FlashInfer's NVFP4 GEMMs are "flashinfer…gemm")
+    ("gemm", r"gemm|gemv|nvjet|xmma|matmul|cublas|splitK|scaled_mm|_fp8_head"),
+    ("linear-attn", r"gated_delta|delta_rule|fused_recurrent|gdn|mamba|conv1d|causal_conv"),
+    ("attention", r"mjolnir|t5_decode|fmha|flash_attn|flash_fwd|attention|BatchDecode|BatchPrefill|merge_attn|xqa"),
+    ("sampling", r"sample|topk|top_k|argmax|gumbel|softmax|rejection|logits|penalt|exponential"),
+    ("norm/act", r"norm|rms|silu|gelu|swiglu|act_and_mul|rotary|rope"),
+    ("copy", r"copy|memcpy|memset|cat_|index|gather|scatter|fill|Memcpy|Memset"),
+)
+
+
+def categorize(name: str) -> str:
+    for cat, pat in CATEGORIES:
+        if re.search(pat, name, re.I):
+            return cat
+    return "other"
+
+
+def _load_trace(path: Path) -> dict:
+    opener = gzip.open if str(path).endswith(".gz") else open
+    with opener(path, "rt") as f:
+        return json.load(f)
+
+
+def _union(intervals: list[tuple[float, float]]) -> float:
+    total, end = 0.0, None
+    for a, b in sorted(intervals):
+        if end is None or a > end:
+            total += b - a
+            end = b
+        elif b > end:
+            total += b - end
+            end = b
+    return total
+
+
+def parse_trace(path: Path, tokens: int | None = None, top: int = 15) -> dict:
+    """Summarize one Kineto trace (times in ms)."""
+    events = _load_trace(path).get("traceEvents", [])
+    kernels = [e for e in events if e.get("ph") == "X" and e.get("cat") in ("kernel", "gpu_memcpy", "gpu_memset")]
+    runtime = {}
+    for e in events:
+        if e.get("ph") == "X" and e.get("cat") in ("cuda_runtime", "cuda_driver"):
+            c = (e.get("args") or {}).get("correlation")
+            if c is not None:
+                runtime[c] = e
+    if not kernels:
+        return {"kernels": 0}
+    t0 = min(k["ts"] for k in kernels)
+    t1 = max(k["ts"] + k.get("dur", 0) for k in kernels)
+    window = (t1 - t0) / 1000
+    busy = _union([(k["ts"], k["ts"] + k.get("dur", 0)) for k in kernels]) / 1000
+
+    by_cat: dict[str, float] = defaultdict(float)
+    by_name: dict[str, list[float]] = defaultdict(list)
+    graph_kernels: dict[int, list[dict]] = defaultdict(list)
+    eager = []
+    for k in kernels:
+        d = k.get("dur", 0) / 1000
+        by_cat[categorize(k.get("name", ""))] += d
+        by_name[k.get("name", "")].append(d)
+        corr = (k.get("args") or {}).get("correlation")
+        launcher = runtime.get(corr, {}).get("name", "")
+        if "GraphLaunch" in launcher:
+            graph_kernels[corr].append(k)
+        else:
+            eager.append(k)
+
+    # one entry per graph replay: kernel count, GPU span, summed kernel time
+    replays = []
+    for corr, ks in graph_kernels.items():
+        start = min(k["ts"] for k in ks)
+        end = max(k["ts"] + k.get("dur", 0) for k in ks)
+        replays.append(
+            {
+                "corr": corr,
+                "ts": start,
+                "n": len(ks),
+                "span_ms": (end - start) / 1000,
+                "gpu_ms": sum(k.get("dur", 0) for k in ks) / 1000,
+                "attn_ms": sum(k.get("dur", 0) for k in ks if categorize(k.get("name", "")) == "attention") / 1000,
+                "names": defaultdict(float),
+            }
+        )
+        for k in ks:
+            replays[-1]["names"][k.get("name", "")] += k.get("dur", 0) / 1000
+    sigs: dict[int, list[dict]] = defaultdict(list)
+    for r in replays:
+        sigs[r["n"]].append(r)
+    graphs = []
+    for n, rs in sorted(sigs.items(), key=lambda kv: -kv[0]):
+        names: dict[str, float] = defaultdict(float)
+        for r in rs:
+            for nm, v in r["names"].items():
+                names[nm] += v
+        graphs.append(
+            {
+                "kernels": n,
+                "replays": len(rs),
+                "span_ms": round(sum(r["span_ms"] for r in rs) / len(rs), 3),
+                "gpu_ms": round(sum(r["gpu_ms"] for r in rs) / len(rs), 3),
+                "attn_ms": round(sum(r["attn_ms"] for r in rs) / len(rs), 3),
+                "top": [[nm[:90], round(v / len(rs), 4)] for nm, v in sorted(names.items(), key=lambda kv: -kv[1])[:5]],
+            }
+        )
+    # eager kernels between graph replays, per replay of the largest graph
+    n_steps = max((g["replays"] for g in graphs[:1]), default=0) or 1
+    eager_ms = sum(k.get("dur", 0) for k in eager) / 1000
+    eager_names: dict[str, list[float]] = defaultdict(list)
+    for k in eager:
+        eager_names[k.get("name", "")].append(k.get("dur", 0) / 1000)
+
+    def tops(d: dict[str, list[float]]) -> list[list]:
+        rows = sorted(d.items(), key=lambda kv: -sum(kv[1]))[:top]
+        return [[nm[:90], len(v), round(sum(v), 3), round(sum(v) / len(v) * 1000, 1)] for nm, v in rows]
+
+    per_tok = (lambda v: round(v / tokens, 4)) if tokens else (lambda v: None)
+    return {
+        "kernels": len(kernels),
+        "window_ms": round(window, 2),
+        "busy_ms": round(busy, 2),
+        "idle_pct": round((1 - busy / window) * 100, 1) if window > 0 else None,
+        "tokens": tokens,
+        "ms_per_token": per_tok(window),
+        "by_category_ms": {k: round(v, 3) for k, v in sorted(by_cat.items(), key=lambda kv: -kv[1])},
+        "by_category_ms_per_token": {k: per_tok(v) for k, v in sorted(by_cat.items(), key=lambda kv: -kv[1])},
+        "graphs": graphs,
+        "graph_replays": len(replays),
+        "eager_kernels": len(eager),
+        "eager_ms": round(eager_ms, 3),
+        "eager_kernels_per_step": round(len(eager) / n_steps, 1),
+        "eager_kernels_per_token": round(len(eager) / tokens, 1) if tokens else None,
+        "graph_replays_per_token": round(len(replays) / tokens, 2) if tokens else None,
+        "top_kernels": tops(by_name),  # [name, count, total ms, mean µs]
+        "top_eager": tops(eager_names),
+    }
+
+
+# ── the stage ───────────────────────────────────────────────────────────────
+
+
+def _post(url: str, timeout: float = 600.0) -> None:
+    req = urllib.request.Request(url, data=b"", method="POST")
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        r.read()
+
+
+def _context_prompt(words: int) -> str:
+    from mjolnir_cli.verify.spec import long_prompt
+
+    return long_prompt(words) if words > 0 else "Write a detailed essay about the history of computing."
+
+
+def _newest_trace(d: Path, since: float) -> Path | None:
+    cands = [p for p in d.rglob("*.pt.trace.json*") if p.stat().st_mtime >= since - 1]
+    return max(cands, key=lambda p: p.stat().st_mtime) if cands else None
+
+
+def stage_profile(
+    ctx,
+    legs: str = DEFAULT_LEGS,
+    drafts: int = 3,
+    context_words: int = 6000,
+    concurrency: int = 1,
+    requests: int = 2,
+    max_tokens: int = 128,
+    model: str | None = None,
+    restart: bool = False,
+    timeout: float = 1800.0,
+) -> dict:
+    from mjolnir_cli.verify.kvcache import _legs
+    from mjolnir_cli.verify.spec import spec_override, stream_one
+
+    params = {
+        "legs": legs,
+        "drafts": drafts,
+        "context_words": context_words,
+        "concurrency": concurrency,
+        "requests": requests,
+        "max_tokens": max_tokens,
+    }
+    rows, cases = [], []
+    if dockerctl.container_running() and not restart and not ctx.runner.dry_run:
+        ctx.out(
+            "[red]   a vLLM server is running — this stage restarts the server for every leg. "
+            "Stop it in a window you own (mjolnir serve down), or pass --restart.[/red]"
+        )
+        return {"rows": [], "cases": [{"label": "server busy (not restarted)", "passed": False}], "params": params}
+    prompt = _context_prompt(context_words)
+    mj_image = ctx.runner.image or DEFAULT_IMAGE
+    for side, quant in _legs(legs):
+        s = resolve(model, quant, STOCK_IMAGE if side == "official" else mj_image, None)
+        point = f"{side}-{quant}-k{drafts}"
+        sub = f"profiles/{ctx.run_id}/{point}"
+        host_dir = s.data_dir / "cache" / sub
+        prof = json.dumps(
+            {
+                "profiler": "torch",
+                "torch_profiler_dir": f"/data/cache/{sub}",
+                "torch_profiler_with_stack": False,
+                "torch_profiler_use_gzip": True,
+                "torch_profiler_dump_cuda_time_total": False,
+                "ignore_frontend": True,
+            }
+        )
+        serve_args: tuple[str, ...] = ("--profiler-config", prof)
+        override = spec_override(s.config_path, drafts) if drafts > 0 else None
+        if override:
+            serve_args += ("--speculative-config", override)
+        ctx.out(f"   ▸ {point}  ({s.image})")
+        if ctx.runner.dry_run:
+            dockerctl.serve_up(s, wait=False, dry_run=True, serve_args=serve_args)
+            continue
+        log = ctx.logdir / "profile" / f"{point}.log"
+        log.parent.mkdir(parents=True, exist_ok=True)
+        err, summary = None, None
+        try:
+            host_dir.mkdir(parents=True, exist_ok=True)
+            dockerctl.serve_up(s, wait=True, wait_timeout_s=timeout, serve_args=serve_args)
+            root = s.base_url.rsplit("/v1", 1)[0]
+            for _ in range(2):  # warm-up at the same shape: compiles, graphs, allocator
+                stream_one(s.base_url, s.served_model, prompt, 32)
+            t_start = time.time()
+            _post(f"{root}/start_profile")
+            gen = [0]
+            lock = threading.Lock()
+
+            def work():
+                r = stream_one(s.base_url, s.served_model, prompt, max_tokens)
+                with lock:
+                    gen[0] += r.get("tokens") or 0
+
+            for _ in range(requests):
+                ts = [threading.Thread(target=work) for _ in range(concurrency)]
+                for t in ts:
+                    t.start()
+                for t in ts:
+                    t.join()
+            _post(f"{root}/stop_profile")
+            trace = None
+            for _ in range(120):  # the worker writes the trace after stop
+                trace = _newest_trace(host_dir, t_start)
+                if trace is not None:
+                    size = trace.stat().st_size
+                    time.sleep(2)
+                    if trace.stat().st_size == size and size > 0:
+                        break
+                time.sleep(2)
+            if trace is None:
+                err = f"no trace in {host_dir}"
+            else:
+                summary = parse_trace(trace, tokens=gen[0])
+                summary["trace"] = str(trace)
+        except (dockerctl.DockerError, TimeoutError, OSError, ValueError) as e:
+            err = str(e)
+        finally:
+            dockerctl.dump_server_log(None, log)
+            dockerctl.serve_down(s)
+            dockerctl._run_quiet([dockerctl._docker(), "rm", "-f", dockerctl.CONTAINER_NAME], ok_codes=(0, 1))
+        ok = err is None and summary is not None and summary.get("kernels")
+        cases.append({"label": point, "passed": bool(ok), **({"error": err} if err else {}), "log": str(log)})
+        if not ok:
+            ctx.out(f"     ❌ {err or 'empty trace'} — {log}")
+            continue
+        rows.append({"id": point, "side": side, "config": quant, "image": s.image, "k": drafts, **summary})
+        ctx.out(
+            f"     {summary['tokens']} tokens · {summary['ms_per_token']} ms/token · GPU idle "
+            f"{summary['idle_pct']}% · {summary['graph_replays']} graph replays · "
+            f"{summary['eager_kernels_per_token']} eager kernels/token"
+        )
+        for g in summary["graphs"][:4]:
+            ctx.out(
+                f"       graph ×{g['replays']:<4} {g['kernels']:>5} kernels  {g['span_ms']:8.3f} ms span  "
+                f"{g['gpu_ms']:8.3f} ms GPU  (attention {g['attn_ms']:.3f})  top: {g['top'][0][0][:60]}"
+            )
+    return {"rows": rows, "cases": cases, "params": params}

mjolnir_cli/verify/report.py

@@ -0,0 +1,177 @@
+"""Terminal rendering of verify results (rich tables)."""
+
+from __future__ import annotations
+
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from mjolnir_cli.verify import results
+from mjolnir_cli.verify.stages import NOISE_PCT, STAGES
+
+console = Console()
+
+
+def fmt_us(t: float | None) -> str:
+    if t is None:
+        return "—"
+    return f"{t / 1000:.2f} ms" if t >= 1000 else f"{t:.1f} µs"
+
+
+def ratio_cell(r: float | None) -> str:
+    if r is None:
+        return ""
+    noise = NOISE_PCT / 100
+    color = "green" if r >= 1 + noise else ("yellow" if r >= 1 - noise else "red")
+    return f"[{color}]{r:.2f}×[/{color}]"
+
+
+def _bases(doc: dict) -> list[dict]:
+    """Reference series for the ratio columns: the baselines present."""
+    by = results.series_by_id(doc)
+    return [by[i] for i in ("fi", "fi-hnd", "fa2") if i in by]
+
+
+def series_table(doc: dict) -> Table:
+    ser = doc.get("series", [])
+    Ls = sorted({p["L"] for s in ser for p in s.get("points", [])})
+    bases = _bases(doc)
+    t = Table(box=box.SIMPLE_HEAD, pad_edge=False, title=f"{doc['stage']} · {doc['run_id']}", title_justify="left")
+    t.add_column("series", style="bold")
+    for L in Ls:
+        t.add_column(f"L={L:,}", justify="right")
+    best: dict[int, float] = {}
+    for s in ser:
+        for L, v in results.point_map(s).items():
+            best[L] = min(best.get(L, v), v)
+    for s in ser:
+        pm = results.point_map(s)
+        cells = []
+        for L in Ls:
+            v = pm.get(L)
+            if v is None:
+                cells.append("—")
+                continue
+            txt = fmt_us(v)
+            if v == best.get(L):
+                txt = f"[bold green]{txt}[/bold green]"
+            ratios = []
+            for b in bases:
+                if b is s:
+                    continue
+                bv = results.point_map(b).get(L)
+                if bv:
+                    ratios.append(ratio_cell(bv / v))
+            if ratios and s.get("kind") != "fi" and s.get("kind") != "fa2":
+                txt += " " + "/".join(ratios)
+            cells.append(txt)
+        t.add_row(s["label"], *cells)
+    if bases:
+        t.caption = (
+            "ratios = "
+            + " / ".join(f"{b['label']} time ÷ this time" for b in bases)
+            + (f"  (>1 faster · ±{NOISE_PCT:.0f}% is noise)")
+        )
+    return t
+
+
+def rows_table(doc: dict) -> Table | None:
+    rows = doc.get("rows") or []
+    if not rows:
+        return None
+
+    # scalar columns (and short lists like per-position acceptance); nested
+    # summaries (profile graphs, kernel tables) and paths stay in the JSON
+    def shown(k, v) -> bool:
+        if k in ("ok", "log", "trace", "image", "ttft_list_ms"):
+            return False
+        if isinstance(v, dict):
+            return False
+        return not (isinstance(v, list) and (len(v) > 8 or any(isinstance(x, (list, dict)) for x in v)))
+
+    keys = [k for k in rows[0] if shown(k, rows[0][k])]
+    t = Table(box=box.SIMPLE_HEAD, pad_edge=False, title=f"{doc['stage']} rows", title_justify="left")
+    for k in keys:
+        t.add_column(k, justify="right" if isinstance(rows[0][k], (int, float)) else "left")
+    for r in rows:
+        t.add_row(*[_fmt(r.get(k)) for k in keys])
+    return t
+
+
+def _fmt(v) -> str:
+    if v is None:
+        return "—"
+    if isinstance(v, float):
+        return f"{v:.4g}" if abs(v) < 10 else f"{v:,.1f}"
+    return str(v)
+
+
+def cases_summary(doc: dict) -> str:
+    cs = doc.get("cases", [])
+    bad = [c for c in cs if not c.get("passed")]
+    if not bad:
+        return f"[bold green]✅ all {len(cs)} checks passed[/bold green]"
+    lines = [f"[bold red]❌ {len(bad)} failed[/bold red], [green]{len(cs) - len(bad)} passed[/green]"]
+    for c in bad:
+        lines.append(f"   [red]❌ {c.get('q', '')} {c['label']}[/red]  [dim]{c.get('log', '')}[/dim]")
+    return "\n".join(lines)
+
+
+def show(doc: dict) -> None:
+    st = STAGES.get(doc["stage"])
+    console.print(
+        f"\n[bold cyan]━━ {st.title if st else doc['stage']}[/bold cyan]  "
+        f"[dim]{doc['run_id']} · {doc.get('image', '')} · kernel {doc.get('kernel', {}).get('version', '?')}"
+        f"{' (' + doc['kernel']['git'] + ')' if doc.get('kernel', {}).get('git') else ''}"
+        f" · gate {doc.get('gate', {}).get('server', '?')}[/dim]"
+    )
+    if doc.get("series"):
+        console.print(series_table(doc))
+    t = rows_table(doc)
+    if t is not None:
+        console.print(t)
+    if doc.get("profiles"):
+        prof_table(doc)
+    if doc.get("cases"):
+        console.print(cases_summary(doc))
+    if doc.get("summary"):
+        for k, v in doc["summary"].items():
+            if isinstance(v, dict) and "geomean" in v:
+                console.print(
+                    f"  [bold]{k}[/bold]: geomean {v['geomean']:.2f}×  (min {v['min']:.2f}×, max {v['max']:.2f}×)"
+                )
+
+
+def prof_table(doc: dict) -> None:
+    """fp6prof: bytes vs time per KV format, per L (vs the first variant)."""
+    profs = [p for p in doc.get("profiles", []) if p.get("ok")]
+    if not profs:
+        return
+    by_L: dict[int, list[dict]] = {}
+    for p in profs:
+        by_L.setdefault(p["L"], []).append(p)
+    t = Table(box=box.SIMPLE_HEAD, pad_edge=False, title="fp6prof: time vs bytes (ratios vs the first variant)")
+    for c in ("L", "variant", "bits", "µs", "time ratio", "L2 sector ratio", "ideal", "L2 B/request", "top stall"):
+        t.add_column(c, justify="right" if c not in ("variant", "top stall") else "left")
+    for L, ps in sorted(by_L.items()):
+        b = ps[0]
+        bt = b["metrics"].get("gpu__time_duration.sum")
+        bs = b["metrics"].get("lts__t_sectors_op_read.sum") or b["metrics"].get("lts__t_sectors.sum")
+        for p in ps:
+            m = p["metrics"]
+            tm = m.get("gpu__time_duration.sum")
+            sec = m.get("lts__t_sectors_op_read.sum") or m.get("lts__t_sectors.sum")
+            req = m.get("lts__t_requests_srcunit_tex_op_read.sum")
+            stall = max(p.get("stalls", {}).items(), key=lambda kv: kv[1], default=("", 0))
+            t.add_row(
+                f"{L:,}",
+                p["label"],
+                f"{p['kv_bits']:g}",
+                fmt_us(tm / 1e3 if tm else None),
+                f"{tm / bt:.2f}" if tm and bt else "—",
+                f"{sec / bs:.2f}" if sec and bs else "—",
+                f"{p['kv_bits'] / b['kv_bits']:.2f}",
+                f"{sec * 32 / req:.0f}" if sec and req else "—",
+                f"{stall[0]} {stall[1]:.1f}" if stall[0] else "",
+            )
+    console.print(t)