phanerozoic commited on Aug 11

Commit

8aed2e2

verified ·

1 Parent(s): c34937e

Uploaded using `kernel-builder`.

Browse files

Files changed (39) hide show

.gitattributes +6 -0
build/torch212-cxx11-cu126-x86_64-linux/__init__.py +935 -300
build/torch212-cxx11-cu126-x86_64-linux/{_metakernel_cuda_b62a1ce.abi3.so → _metakernel_cuda_0b9de42.abi3.so} +2 -2
build/torch212-cxx11-cu126-x86_64-linux/_ops.py +3 -3
build/torch212-cxx11-cu126-x86_64-linux/_pinned.py +194 -102
build/torch212-cxx11-cu126-x86_64-linux/metadata.json +8 -8
build/torch212-cxx11-cu126-x86_64-linux/metakernel/__init__.py +0 -26
build/torch212-cxx11-cu130-x86_64-linux/__init__.py +935 -300
build/{torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so → torch212-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so} +2 -2
build/torch212-cxx11-cu130-x86_64-linux/_ops.py +3 -3
build/torch212-cxx11-cu130-x86_64-linux/_pinned.py +194 -102
build/torch212-cxx11-cu130-x86_64-linux/metadata.json +8 -8
build/torch212-cxx11-cu130-x86_64-linux/metakernel/__init__.py +0 -26
build/torch212-cxx11-cu132-x86_64-linux/__init__.py +935 -300
build/{torch212-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so → torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so} +2 -2
build/torch212-cxx11-cu132-x86_64-linux/_ops.py +3 -3
build/torch212-cxx11-cu132-x86_64-linux/_pinned.py +194 -102
build/torch212-cxx11-cu132-x86_64-linux/metadata.json +8 -8
build/torch212-cxx11-cu132-x86_64-linux/metakernel/__init__.py +0 -26
build/torch213-cxx11-cu126-x86_64-linux/__init__.py +935 -300
build/torch213-cxx11-cu126-x86_64-linux/{_metakernel_cuda_b62a1ce.abi3.so → _metakernel_cuda_0b9de42.abi3.so} +2 -2
build/torch213-cxx11-cu126-x86_64-linux/_ops.py +3 -3
build/torch213-cxx11-cu126-x86_64-linux/_pinned.py +194 -102
build/torch213-cxx11-cu126-x86_64-linux/metadata.json +8 -8
build/torch213-cxx11-cu126-x86_64-linux/metakernel/__init__.py +0 -26
build/torch213-cxx11-cu130-x86_64-linux/__init__.py +935 -300
build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so +3 -0
build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so +0 -3
build/torch213-cxx11-cu130-x86_64-linux/_ops.py +3 -3
build/torch213-cxx11-cu130-x86_64-linux/_pinned.py +194 -102
build/torch213-cxx11-cu130-x86_64-linux/metadata.json +8 -8
build/torch213-cxx11-cu130-x86_64-linux/metakernel/__init__.py +0 -26
build/torch213-cxx11-cu132-x86_64-linux/__init__.py +935 -300
build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so +3 -0
build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so +0 -3
build/torch213-cxx11-cu132-x86_64-linux/_ops.py +3 -3
build/torch213-cxx11-cu132-x86_64-linux/_pinned.py +194 -102
build/torch213-cxx11-cu132-x86_64-linux/metadata.json +8 -8
build/torch213-cxx11-cu132-x86_64-linux/metakernel/__init__.py +0 -26

.gitattributes CHANGED Viewed

@@ -96,3 +96,9 @@ build/torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=
 build/torch213-cxx11-cu126-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text

 build/torch213-cxx11-cu126-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text
 build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch212-cxx11-cu126-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch212-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch213-cxx11-cu126-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text
+build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so filter=lfs diff=lfs merge=lfs -text

build/torch212-cxx11-cu126-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/torch212-cxx11-cu126-x86_64-linux/{_metakernel_cuda_b62a1ce.abi3.so → _metakernel_cuda_0b9de42.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c32d09147828150170b96b8f23e17ed9b6a3400a9edf3231f8f0a7fa56a60921
-size 743832

 version https://git-lfs.github.com/spec/v1
+oid sha256:b143b103b2bf8dfa9129c62d7ef7b33155749eea06f7f0f3ee009a8e5e7736c5
+size 900560

build/torch212-cxx11-cu126-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch212-cxx11-cu126-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch212-cxx11-cu126-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -16,21 +17,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "wy0JFHgoFQFwuWuPI+F+2bajQAqe3zIx+PCn+lamCSE=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "sUOxA7K/jfqRKcYtfvezMVV0nuoG9/Dz7gCajl53NsU=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch212-cxx11-cu126-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch212-cxx11-cu130-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/{torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so → torch212-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a0c457291c297cb5d91dffc19192ab490dbfd9cbb78cc0381b7dfc343f7624a1
-size 1192744

 version https://git-lfs.github.com/spec/v1
+oid sha256:43c0a08aedf84b5774061ee641a2244f265695210389af8a04402849511d99c2
+size 1426264

build/torch212-cxx11-cu130-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch212-cxx11-cu130-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch212-cxx11-cu130-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -18,21 +19,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "1Y6NPGyDQe/N1E5YvWt+4IjBUPeIfmXnS4GZr+1KUto=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "Q8Cgiu34S1d0Bh7mQaIkTyZWlSEDia+KBEAoSVEdmcI=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch212-cxx11-cu130-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch212-cxx11-cu132-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/{torch212-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so → torch212-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d58e8d3c6c8341efcdd44e58bd6b7ee088c150f7887e65e74b8199afed4a52da
-size 1180120

 version https://git-lfs.github.com/spec/v1
+oid sha256:5db8a870d3df57f2fab7ca97d0d323183a1985635ee09af76797864ecd65520e
+size 1438880

build/torch212-cxx11-cu132-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch212-cxx11-cu132-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch212-cxx11-cu132-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -18,21 +19,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "oMRXKRwpfLXZHf/BkZKrSQ2/2cu3jMA4G338ND92JKE=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "XbiocNPfV/L6t8qX0NMjGDoZhWNe4Jr3Z5eGTs1lUg4=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch212-cxx11-cu132-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu126-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/torch213-cxx11-cu126-x86_64-linux/{_metakernel_cuda_b62a1ce.abi3.so → _metakernel_cuda_0b9de42.abi3.so} RENAMED Viewed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2abef05bfc6a31613189774aeb6133563c7c563475a19128863a55db715d93a0
-size 743672

 version https://git-lfs.github.com/spec/v1
+oid sha256:e88c26a134c137ab36fc4580d338ee0a75ac9306710d4681f34b6ac43b6e60c6
+size 900400

build/torch213-cxx11-cu126-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch213-cxx11-cu126-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch213-cxx11-cu126-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -16,21 +17,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "Kr7wW/xqMWExiXdK62EzVjx8VjR1oZEohjpV23Fdk6A=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "6IwmoTTBN6s2/EWA0zjuCnWskwZxDUaB80tqxDtuYMY=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch213-cxx11-cu126-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu130-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8120f29036953f429c2640dbe6dcb057d44ff3ac89944c849d07f5abe6616c8d
+size 1426104

build/torch213-cxx11-cu130-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:88438dc3c8221430094a0874eb102dc4eadcdfda40ba1c176ba9ff9ab3c21fef
-size 1179960

build/torch213-cxx11-cu130-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch213-cxx11-cu130-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch213-cxx11-cu130-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -18,21 +19,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "iEONw8giFDAJSgh06xAtxOrc39pAuhwXa6n/mrPCH+8=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "gSDykDaVP0KcJkDb5tywV9RP86yJlEyEnQf1q+ZhbI0=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch213-cxx11-cu130-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu132-x86_64-linux/__init__.py CHANGED Viewed

@@ -1,20 +1,4 @@
-"""Measuring instrument for the kernel-design loop: timing, adversarial
-correctness comparison, and measured device facts, as loadable ops.
-    from kernels import get_kernel
-    mk = get_kernel("phanerozoic/metakernel", version=1,
-                    trust_remote_code=True)
-    dossier = mk.probe_device()                       # measured facts
-    report  = mk.bench(lambda: op(x), iters=200)      # throttle-rejected
-    verdict = mk.compare(ref, cand, gen)              # ULP evidence
-    table   = mk.sweep(factory, {"BLOCK": [64, 128]}) # config search
-Every op returns plain dicts and tensors. Every dossier entry is
-measured by a dedicated probe kernel, carries its SM clock, and labels
-throttled samples; no hardware counters, so entries carry a confidence
-field.
-"""
 import math
 import os
 import time
@@ -24,9 +8,7 @@ import torch
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
-    # Subprocess-isolation children re-import this package; in a source
-    # checkout there is no generated _ops module, so rebuild the op table
-    # from the (cached) JIT extension that load_local advertised.
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
@@ -48,24 +30,25 @@ try:
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
-__all__ = ["probe_device", "bench", "compare", "order_shuffles",
-           "fuzz_shapes", "sweep", "alloc_stamps", "read_stamps",
-           "stamped_demo", "measure_clock", "ulp_diff", "dossier_drift",
-           "pinned_dossiers", "ops"]
-# name -> (kind, M*N of the C tile, nominal K, work multiplier, nominal
-# K-lanes per unrolled iteration). The accumulator read-back yields
-# executed K-lanes per op (column sums of B equal K), so flops =
-# 2 x M*N x gain x multiplier with nothing declared trusted; multiplier
-# 2.0 is the sparse dense-equivalent convention. Lanes/iter: wmma K x 4
-# chained ops; PTX kinds x 8 over two chains.
 _MMA_KINDS = {
-    "fp16": (0, 16 * 16, 16, 1.0, 64.0),
-    "bf16": (1, 16 * 16, 16, 1.0, 64.0),
-    "tf32": (2, 16 * 16, 8, 1.0, 32.0),
-    "int8": (3, 16 * 16, 16, 1.0, 64.0),
-    "fp8_e4m3": (4, 16 * 8, 32, 1.0, 256.0),
-    "fp16_sparse_2_4": (5, 16 * 8, 32, 2.0, 128.0),  # dense-equivalent
 }
@@ -74,7 +57,7 @@ def _sync():
 def _events(fn, reps):
-    """Time reps calls of fn with one event pair each; returns ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
@@ -86,8 +69,7 @@ def _events(fn, reps):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
-    """Effective SM clock in GHz under an FMA spin of `ticks` clock64 ticks.
-    Wall time over elapsed ticks is the frequency the ticks ran at."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -120,8 +102,7 @@ def _entry(value, units, method, clock_ghz, confidence, note=""):
 def _sattolo_ring(n, device, generator=None):
-    """A random single-cycle permutation as an int32 next-pointer table, so
-    a pointer chase visits every slot before repeating."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
@@ -129,8 +110,7 @@ def _sattolo_ring(n, device, generator=None):
 def _smi_settings(index):
-    """ECC mode, driver, and power limit via nvidia-smi; None fields
-    when the tool is unavailable."""
     import subprocess
     try:
         out = subprocess.run(
@@ -150,10 +130,19 @@ def _smi_settings(index):
     return {"ecc": None, "driver": None, "power_limit_w": None}
 def mma_tile_check(device="cuda", trials=8):
-    """Random small-integer m16n16k16 tiles through the wmma fragment
-    path, compared exactly to the reference GEMM; pins M, N, K, and
-    operand mapping (integer operands make fp32 accumulation exact)."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
@@ -171,10 +160,83 @@ def mma_tile_check(device="cuda", trials=8):
             "trials": trials}
-def probe_device(device="cuda", quick=False):
-    """Empirical device dossier. Each entry is measured by a dedicated
-    probe kernel and carries units, method, the SM clock it ran under, and
-    a confidence field."""
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
@@ -187,8 +249,7 @@ def probe_device(device="cuda", quick=False):
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
-            # instrument settings: readings depend on them, so the
-            # dossier records them (None when nvidia-smi is unavailable)
             **_smi_settings(torch.device(device).index or 0),
         }
     }
@@ -213,9 +274,8 @@ def probe_device(device="cuda", quick=False):
     }
     clk = max(traj)
-    # ---- device-memory bandwidth: triad per access width, plus read-only,
-    # write-only, and random-gather
-    n4 = 16 << 20  # 16M float4 = 256 MB per buffer
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
@@ -239,7 +299,6 @@ def probe_device(device="cuda", quick=False):
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
-    # traffic accounting: idx reads + 16B random loads + streamed stores
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
@@ -250,9 +309,9 @@ def probe_device(device="cuda", quick=False):
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
-    # ---- L2 bandwidth (working set 3 buffers inside L2)
     ws = max(l2 // 4, 1 << 20)
-    nl2 = ws // 16  # float4 elems per buffer
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
@@ -267,62 +326,61 @@ def probe_device(device="cuda", quick=False):
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
-    # ---- latencies: pointer chase per level. The 2 MB L2 ring exceeds
-    # L1, fits L2 everywhere, and stays TLB-resident after a warm walk;
-    # the DRAM chain touches 2x L2 in lines, so it evicts itself.
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
-    ring_s = _sattolo_ring(8192, device)
-    ops.mk_chase_shared(ring_s, 1 << 14, out64)
-    _sync()
-    hops = 1 << 16
-    ops.mk_chase_shared(ring_s, hops, out64)
-    _sync()
-    lat["smem_cycles"] = round(int(out64[0].item()) / hops, 1)
-    l1_ring_n = (16 << 10) // 4  # 16 KB: L1-resident after a warm walk
-    ring_l1 = _sattolo_ring(l1_ring_n, device)
-    ops.mk_chase_global(ring_l1, l1_ring_n, out64)
-    _sync()
-    hops_l1 = 1 << 15
-    ops.mk_chase_global(ring_l1, hops_l1, out64)
-    _sync()
-    lat["l1_cycles"] = round(int(out64[0].item()) / hops_l1, 1)
-    l2_ring_n = (2 << 20) // 4
-    ring_l2 = _sattolo_ring(l2_ring_n, device)
-    ops.mk_chase_global(ring_l2, l2_ring_n, out64)  # full-cycle warm walk
-    _sync()
-    hops_l2 = 1 << 14
-    ops.mk_chase_global(ring_l2, hops_l2, out64)
-    _sync()
-    lat["l2_cycles"] = round(int(out64[0].item()) / hops_l2, 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
-    ops.mk_chase_global(ring_h, 1 << 14, out64)  # fault pages / warm TLB
-    _sync()
-    ops.mk_chase_global(ring_h, hops_h, out64)
-    _sync()
-    lat["dram_cycles"] = round(int(out64[0].item()) / hops_h, 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
-                          "Sattolo-cycle pointer chase; 16 KB ring for L1, "
-                          "2 MB TLB-resident ring for L2, self-evicting "
-                          "chain (2x L2 in touched lines) for HBM",
-                          idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
-    # ---- fp32 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
-    flops = blocks * 256 * iters * 16 * 2 * 2  # 2 chains x 2 flops x unroll
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
@@ -334,43 +392,88 @@ def probe_device(device="cuda", quick=False):
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
     mma = {}
     mma_klanes = {}
-    for name, (kind, mn, k_nom, mult, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
-        # verification pass: with unit operands the accumulator gain IS
-        # the executed K-lane count (exact at these magnitudes)
-        cal_iters = 512
-        sink[1] = 0.0
-        ops.mk_mma(kind, 1, 1, cal_iters, sink)
-        _sync()
-        gain_per_iter = float(sink[1].item()) / cal_iters
         mma_klanes[name] = {
-            "executed_k_per_iter": round(gain_per_iter, 2),
-            "vs_nominal": round(gain_per_iter / nom_lanes, 3),
         }
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
-        flops = blocks * 8 * it * 2.0 * mn * gain_per_iter * mult
-        mma[name] = round(flops / (ms * 1e-3) / 1e12, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
-                      "2:4-sparse fp16 via inline PTX m16n8k32; sparse "
-                      "counted dense-equivalent, the vendor convention); "
-                      "flops derive from the mean accumulator read-back "
                       "with every fragment element observed, never the "
-                      "declared loop shape",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
-    # ---- shared-memory bandwidth
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
@@ -380,8 +483,23 @@ def probe_device(device="cuda", quick=False):
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
-                          "bank-conflict-light access pattern; a conflicted "
-                          "pattern can be far lower")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
@@ -412,9 +530,7 @@ def probe_device(device="cuda", quick=False):
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
-    # ---- atomic contention curve: throughput vs number of distinct
-    # addresses the whole grid hammers (slots = 1 is full contention;
-    # slots = threads is contention-free), plus the shared-memory point
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
@@ -424,7 +540,7 @@ def probe_device(device="cuda", quick=False):
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
-            lambda s=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
@@ -437,7 +553,7 @@ def probe_device(device="cuda", quick=False):
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
-    # ---- launch overhead
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
@@ -452,10 +568,19 @@ def probe_device(device="cuda", quick=False):
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
     d["launch_overhead"] = _entry(
-        {"queued_us": round(queued, 2), "round_trip_us": round(rt, 2)},
-        "us", "empty-kernel trains, queued vs launch+sync", clk, "high",
-        "host-dependent: includes torch op dispatch")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
@@ -471,9 +596,7 @@ def probe_device(device="cuda", quick=False):
                                    "unavailable or grid too large", clk,
                                    "high")
-    # ---- occupancy table (API) plus timed knees: the same random gather
-    # at every (threads, dyn_smem) point; when the forced blocks/SM stop
-    # covering memory latency, achieved bandwidth falls off the cliff
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
@@ -494,8 +617,8 @@ def probe_device(device="cuda", quick=False):
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
-                lambda t=threads, s=smem_kb: ops.mk_fma_dep(
-                    knee_blocks, t, s * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
@@ -504,27 +627,160 @@ def probe_device(device="cuda", quick=False):
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
     return d
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
-          device="cuda"):
-    """Median-of-N cudaEvent timing with throttle rejection.
-    The SM clock is probed every `clock_stride` samples; samples in a
-    window below `clock_guard` x the best observed clock are rejected
-    and counted. Declared `bytes`/`flops` yield achieved GB/s / TFLOP/s;
-    a `dossier` adds roofline placement. `graph=True` times CUDA-graph
-    replays, stripping Python and torch dispatch (fn must be graph-safe:
-    no sync, no allocation growth, static shapes; a failed capture falls
-    back to eager with the reason reported). `clock_stride=1` probes
-    around every sample, ~0.3 ms each."""
     for _ in range(warmup):
         fn()
     _sync()
     graph_state = "off"
     graph_reason = ""
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
@@ -539,10 +795,7 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
-            # drain the invalidated stream so eager timing can proceed.
-            # On some torch versions a failed capture also wedges the
-            # device RNG with no in-process recovery; timing uses no RNG,
-            # but the caller's later randn may raise.
             rng_ok = True
             for _attempt in range(5):
                 try:
@@ -572,25 +825,51 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
-    kept, rejected = [], 0
     flat = []
-    for group, ci in samples:
-        window_ok = (clocks[ci] >= clock_guard * best_clk and
-                     clocks[min(ci + 1, len(clocks) - 1)] >=
-                     clock_guard * best_clk)
-        for ms in group:
-            flat.append(ms)
-            if window_ok:
                 kept.append(ms)
             else:
                 rejected += 1
-    if not kept:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
-    # order-statistic 95% CI on the median (normal approximation to the
-    # binomial ranks); degenerate at tiny n, where it spans the sample
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
@@ -605,12 +884,25 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
@@ -620,6 +912,8 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
@@ -630,13 +924,12 @@ def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
     return rep
 def _to_ordered_int(t):
-    """Map float bit patterns to integers whose difference is the ULP
-    distance: positive floats keep their bits, negative floats mirror
-    below zero, so the mapping is monotone in the float value."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
@@ -652,11 +945,12 @@ def _to_ordered_int(t):
 def ulp_diff(a, b):
-    """Elementwise ULP distance between same-dtype tensors. For floats,
-    NaNs in the same position count as 0 and a one-sided NaN counts as
-    2**62; for integer and bool tensors the distance is the absolute
-    numeric difference (an exact op must be exactly equal)."""
-    assert a.dtype == b.dtype and a.shape == b.shape
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
@@ -673,9 +967,7 @@ class order_shuffles:
     @staticmethod
     def last_dim():
-        """Permute the last dim of every tensor arg identically: the
-        accumulation order of a last-dim reduction changes, the value
-        does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
@@ -685,8 +977,7 @@ class order_shuffles:
     @staticmethod
     def matmul_k():
-        """Permute K of (A [.., M, K], B [.., K, N]) consistently: the
-        product is unchanged, the accumulation order is not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
@@ -700,37 +991,70 @@ def _as_outputs(x):
     return list(x) if isinstance(x, (tuple, list)) else [x]
-def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
-            ref_variants=None, ulp_tol=None, atol=None, rtol=None,
-            band_margin=4.0, zero_atol=None, worst_k=8, seed=0):
-    """Adversarial correctness comparison with ULP evidence.
-    `gen(seed) -> args`; `ref(*args)` and `cand(*args)` return a tensor
-    or tuple (worst output governs). With `order_shuffle(args, seed)`
-    reordering contractual-noise dimensions (see `order_shuffles`), each
-    element is judged against its own measured POINTWISE reduction-order
-    band: pass is max(ulp / (own_band + 2)) <= band_margin; without a
-    band, max ULP <= ulp_tol (default 2); `atol`/`rtol` are an
-    alternative acceptance route. `zero_atol`: elements with
-    |ref| < zero_atol are judged by absolute difference (ULP explodes
-    across the denormal range). The report carries the top-`worst_k`
-    offenders (index, ref, cand, ULP). Order shuffles cover the
-    reference's own topology; a candidate with a different legitimate
-    topology (split-K) needs `ref_variants`, callables `f(args) -> out`
-    whose outputs widen the pointwise band."""
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
     for t in range(trials):
         args = gen(seed + t)
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
-        assert len(r_outs) == len(c_outs), "output arity mismatch"
-        # pointwise band: each element is judged against its own measured
-        # order sensitivity (cancellation makes near-zero outputs
-        # legitimately order-sensitive while neighbors are stable)
         bands = None
         band = 0
         band_score = 0.0
@@ -754,8 +1078,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
         n_el = 0
         n_above_band = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
@@ -773,8 +1100,11 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
@@ -791,6 +1121,7 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
@@ -810,23 +1141,27 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
-    band_max = max(t["order_band_ulp"] for t in per_trial)
     max_seen = max(t["max_ulp"] for t in per_trial)
-    if order_shuffle is not None or ref_variants:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
@@ -841,8 +1176,34 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
-    return {
-        "pass": bool(ulp_ok or tol_ok),
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
@@ -850,6 +1211,9 @@ def compare(ref, cand, gen, trials=8, order_shuffle=None, order_trials=8,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
@@ -865,6 +1229,30 @@ def _context_alive(device):
         return False
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
@@ -881,7 +1269,7 @@ def _fuzz_variant(x, v):
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
-        # a storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
@@ -895,8 +1283,7 @@ def _fuzz_variant(x, v):
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
-    """All variant cases for one (shape, dtype) group; returns (rows,
-    context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
@@ -933,8 +1320,7 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
-                # bounded comparison: the head plus the high-index tail,
-                # which is where int32 flat indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
@@ -959,20 +1345,30 @@ def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
     return rows, lost
-# isolate child: a plain subprocess that bootstraps its own metakernel
-# (get_kernel, else the dev-root JIT fallback) and unpickles op/ref/make
-# by module reference, so it works under get_kernel's synthetic names
-_REPO_ID = "phanerozoic/metakernel"
-_REPO_VERSION = 1
-_ISOLATE_BOOTSTRAP = r"""
-import json
-import os
-import pickle
-import sys
 meta = json.load(open(sys.argv[1], "r"))
-sys.path[:0] = meta["sys_path"]  # BEFORE unpickling module-ref functions
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
@@ -985,85 +1381,165 @@ except Exception:
     import load_local
     _mk = load_local.load()
 import torch
-op, ref, make = pickle.load(open(sys.argv[2], "rb"))
-rows, _lost = _mk._fuzz_group(
-    op, ref, make, tuple(meta["shape"]), getattr(torch, meta["dtype"]),
-    tuple(meta["variants"]), meta["ulp_tol"], meta["device"],
-    stop_on_context_loss=False)
-pickle.dump(rows, open(sys.argv[3], "wb"))
 """
-def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
-                isolate_timeout_s=180, device="cuda"):
-    """Run op vs ref across edge shapes, dtypes, and layout mutations;
-    report ok / mismatch / exception per case.
-    `make(shape, dtype)` (or `make(shape)`) builds a tensor or tuple;
-    layout variants derive non-contiguous and misaligned views whose
-    content equals a contiguous copy. `overflow_expand` stride-0-expands
-    past 2**31 logical elements to catch int32 indexing (`skipped_vram`
-    when it would not fit). Every case carries a `repro` recipe.
-    In-process, the CUDA context is health-checked after exceptions and
-    remaining cases marked `context_lost` if killed; `isolate=True`
-    spawns each (shape, dtype) group in a subprocess, so a
-    context-killing candidate costs one group (`crashed_isolated`);
-    op/ref/make must be picklable."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
-        import subprocess
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
         with open(fns, "wb") as f:
-            pickle.dump((op, ref, make), f)
-        for dtype in dtypes:
-            for shape in shapes:
-                meta = os.path.join(tmpdir, "meta.json")
-                out = os.path.join(tmpdir, "rows.pkl")
-                if os.path.exists(out):
-                    os.remove(out)
-                with open(meta, "w", encoding="utf-8") as f:
-                    json.dump({
-                        "sys_path": [p for p in _sys.path
-                                     if isinstance(p, str)],
-                        "repo": _REPO_ID, "version": _REPO_VERSION,
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
-                    }, f)
-                group = None
-                stderr_tail = ""
-                try:
-                    r = subprocess.run(
-                        [_sys.executable, "-c", _ISOLATE_BOOTSTRAP, meta,
-                         fns, out], timeout=isolate_timeout_s,
-                        capture_output=True)
-                    if r.returncode == 0 and os.path.exists(out):
                         with open(out, "rb") as f:
-                            group = pickle.load(f)
-                    exitcode = r.returncode
-                    stderr_tail = r.stderr.decode(
-                        errors="replace")[-400:]
-                except subprocess.TimeoutExpired:
-                    exitcode = "timeout"
-                if group is None:
-                    group = [{"shape": tuple(shape), "variant": "*",
-                              "dtype": str(dtype).replace("torch.", ""),
-                              "status": "crashed_isolated",
-                              "exitcode": exitcode,
-                              "stderr_tail": stderr_tail}]
-                rows.extend(group)
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
@@ -1080,21 +1556,27 @@ def fuzz_shapes(op, ref, make, shapes=None, variants=_FUZZ_VARIANTS,
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
-    return {"cases": rows, "failed": n_bad, "total": len(rows),
-            "context_lost": lost}
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
-    """Launch-configuration search: `factory(**point) -> callable`; one
-    bench row per grid point, sorted fastest first. A point whose factory
-    or run raises is reported, not skipped silently. `check(fn) -> bool`
-    is an optional correctness gate recorded per row (a fast wrong config
-    must not win a sweep). `budget_s` caps total sweep time; points not
-    reached are reported as `not_run` rather than silently dropped.
-    `race=True` runs successive halving: a quick pass over every point at
-    iters/4, then the full budget only on the fastest quartile; pruned
-    points keep their quick measurement and status `pruned_race`."""
     keys = list(grid.keys())
     def expand(i, acc):
@@ -1159,13 +1641,71 @@ def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
     return rows
 def alloc_stamps(n, blocks=None, device="cuda"):
-    """Device buffer for the MK_STAMP convention (metakernel_cuda/
-    stamps.cuh): the candidate kernel writes clock64() into slot i. With
-    `blocks`, allocates the [blocks, n] layout for MK_STAMP_BLOCK."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
@@ -1175,8 +1715,7 @@ _DRIFT_SKIP = ("device", "clock", "launch_overhead", "transfer_bw")
 def pinned_dossiers():
-    """Names of the dossiers pinned in this release (one per certified
-    architecture)."""
     return sorted(_PINNED.keys())
@@ -1195,11 +1734,7 @@ def _numeric_leaves(d, prefix=""):
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
-    """Compare a fresh dossier against the release-pinned one for the
-    same architecture: per-leaf relative drift, worst drift, entries
-    over `rel_tol`. Host-dependent entries and raw clocks are skipped by
-    default (`skip=()` compares everything); `pinned=None` auto-selects
-    by sm_arch and raises if no pin exists."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
@@ -1222,16 +1757,19 @@ def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
-    return {"entries": entries, "worst_rel": worst, "over_tol": over,
-            "rel_tol": rel_tol, "compared": len(entries),
-            "pass": len(over) == 0}
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
-    """Run the shipped MK_STAMP_BLOCK example kernel (global load, FMA
-    compute, global store) and decode its stamps; a template for
-    instrumenting a candidate."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
@@ -1244,11 +1782,7 @@ def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
 def read_stamps(stamps, labels=None, clock_ghz=None):
-    """Decode MK_STAMP phases: consecutive deltas in ticks and in
-    microseconds under the measured (or provided) SM clock. A 1-D buffer
-    (MK_STAMP: block 0 only) yields one delta per phase; a 2-D [B, n]
-    buffer (MK_STAMP_BLOCK) yields min / median / max across blocks per
-    phase, with blocks whose stamps stayed zero excluded."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
@@ -1284,3 +1818,104 @@ def read_stamps(stamps, labels=None, clock_ghz=None):
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}

+"""Measuring instrument for the kernel-design loop: measured device facts, throttle-aware timing, adversarial correctness comparison, all as loadable ops returning plain data."""
 import math
 import os
 import time
 try:
     from ._ops import ops
 except ImportError:  # pragma: no cover - spawned child in a source tree
+    # children re-import the package; a source checkout rebuilds the op table from the cached JIT extension
     _root = os.environ.get("METAKERNEL_DEV_ROOT")
     if not _root:
         raise
 except ImportError:  # pragma: no cover - fresh tree before first pin
     _PINNED = {}
+__all__ = ["probe_device", "probe_all_devices", "bench", "compare", "judge",
+           "order_shuffles", "fuzz_shapes", "sweep", "alloc_stamps",
+           "read_stamps", "stamped_demo", "measure_clock", "ulp_diff",
+           "dossier_drift", "pinned_dossiers", "mma_tile_check", "schema",
+           "probe_capturable", "ops"]
+_REPO_ID = "phanerozoic/metakernel"
+_REPO_VERSION = 1
+_PROBE_SCHEMA = 2
+# kind id, C-tile M*N, nominal K, nominal K-lanes per unrolled loop iteration
 _MMA_KINDS = {
+    "fp16": (0, 16 * 16, 16, 64.0),
+    "bf16": (1, 16 * 16, 16, 64.0),
+    "tf32": (2, 16 * 16, 8, 32.0),
+    "int8": (3, 16 * 16, 16, 64.0),
+    "fp8_e4m3": (4, 16 * 8, 32, 256.0),
+    "fp16_sparse_2_4": (5, 16 * 8, 32, 128.0),
+    "fp8_e5m2": (6, 16 * 8, 32, 256.0),
 }
 def _events(fn, reps):
+    """Time reps calls of fn with one cudaEvent pair each; returns a ms list."""
     starts = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     stops = [torch.cuda.Event(enable_timing=True) for _ in range(reps)]
     for s, e in zip(starts, stops):
 def measure_clock(device="cuda", ticks=4_000_000, blocks=None):
+    """Effective SM clock in GHz from clock64 ticks over wall time under an FMA spin."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def _sattolo_ring(n, device, generator=None):
+    """Random single-cycle permutation as an int32 next-pointer table."""
     perm = torch.randperm(n, generator=generator)
     ring = torch.empty(n, dtype=torch.int32)
     ring[perm] = torch.roll(perm, -1).to(torch.int32)
 def _smi_settings(index):
+    """ECC mode, driver, power limit via nvidia-smi; None fields when unavailable."""
     import subprocess
     try:
         out = subprocess.run(
     return {"ecc": None, "driver": None, "power_limit_w": None}
+def _unravel(flat, shape):
+    """Multi-dimensional index for a flat index into shape."""
+    if not shape:
+        return []
+    out = []
+    for s in reversed(list(shape)):
+        out.append(int(flat % s))
+        flat //= s
+    return list(reversed(out))
 def mma_tile_check(device="cuda", trials=8):
+    """Random small-integer m16n16k16 tiles through the wmma path, compared exactly to the reference GEMM."""
     worst = 0.0
     for t in range(trials):
         g = torch.Generator(device=device).manual_seed(1000 + t)
             "trials": trials}
+def _tenancy_canary(device, rel_tol=0.10, attempts=3):
+    """Fixed-cost triad timed in paired rounds; busy only when every attempt disagrees."""
+    n4 = 4 << 20
+    a = torch.rand(n4 * 4, device=device)
+    b = torch.rand(n4 * 4, device=device)
+    c = torch.empty(n4 * 4, device=device)
+    ops.mk_triad(a, b, c, 4, 1.5)
+    rels = []
+    for _ in range(attempts):
+        r1 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        r2 = _median(_events(lambda: ops.mk_triad(a, b, c, 4, 1.5), 3))
+        rel = abs(r1 - r2) / min(r1, r2)
+        rels.append(round(rel, 4))
+        if rel <= rel_tol:
+            return False, {"rel_diffs": rels, "rel_tol": rel_tol}
+    return True, {"rel_diffs": rels, "rel_tol": rel_tol}
+def _cache_dir():
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/.cache")
+    d = os.path.join(base, "metakernel")
+    os.makedirs(d, exist_ok=True)
+    return d
+def _cache_path(device, quick):
+    import re
+    props = torch.cuda.get_device_properties(device)
+    smi = _smi_settings(torch.device(device).index or 0)
+    slug = re.sub(r"[^a-z0-9]+", "", props.name.lower())[:24]
+    key = "sm%d%d_%s_drv%s_cu%s_q%d_s%d" % (
+        props.major, props.minor, slug, smi["driver"] or "na",
+        torch.version.cuda, int(quick), _PROBE_SCHEMA)
+    return os.path.join(_cache_dir(), key + ".json")
+def _mma_calibrate(kind_id, sink):
+    """Executed K-lanes per loop iteration from a sub-saturation accumulator read-back, with a linearity check."""
+    gains = []
+    for cal in (4, 32):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, cal, sink)
+        _sync()
+        gains.append(float(sink[1].item()) / cal)
+    linear = gains[0] > 0 and abs(gains[1] - gains[0]) / gains[0] < 0.02
+    return gains[0], linear
+def _fp8_accum_stall(kind_id, sink, k_exec):
+    """Growth curve of the fp8 accumulator; a stall reveals the effective accumulate mantissa width."""
+    vals = []
+    for it in (32, 64, 128, 256, 512):
+        sink[1] = 0.0
+        ops.mk_mma(kind_id, 1, 1, it, sink)
+        _sync()
+        vals.append(float(sink[1].item()) / 2.0)
+    if vals[-1] == vals[-2] and vals[-1] < vals[0] * 16 * 0.99:
+        bits = int(round(math.log2(vals[-1] / (2.0 * k_exec))))
+        return {"stall_element_value": vals[-1],
+                "effective_accum_mantissa_bits": bits}
+    return {"stall_element_value": None,
+            "effective_accum_mantissa_bits": None}
+def probe_device(device="cuda", quick=False, cached=True,
+                 tenancy_check=True):
+    """Empirical device dossier; every entry measured by a dedicated probe kernel and stamped with its SM clock."""
+    cpath = _cache_path(device, quick)
+    if cached and os.path.exists(cpath):
+        import json
+        return json.load(open(cpath, encoding="utf-8"))
+    if tenancy_check:
+        busy, ev = _tenancy_canary(device)
+        if busy:
+            raise RuntimeError("device_busy: canary rounds disagree %s; "
+                               "idle the device or pass "
+                               "tenancy_check=False" % ev)
     props = torch.cuda.get_device_properties(device)
     sm = props.multi_processor_count
     l2 = props.L2_cache_size
             "vram_bytes": props.total_memory,
             "torch": torch.__version__,
             "cuda_runtime": torch.version.cuda,
+            # instrument settings recorded because readings depend on them
             **_smi_settings(torch.device(device).index or 0),
         }
     }
     }
     clk = max(traj)
+    # ---- device-memory bandwidth per access width plus read/write/gather
+    n4 = 16 << 20
     if props.total_memory < 4 << 30:
         n4 = 4 << 20
     a = torch.rand(n4 * 4, device=device)
                         dtype=torch.int32).to(device)
     ops.mk_gather(a, idx, c, 256, 0)
     ms = _median(_events(lambda: ops.mk_gather(a, idx, c, 256, 0), reps))
     hbm["random_gather_16B"] = round(
         (idx.numel() * 4 + 2 * n4 * 16) / (ms * 1e-3) / 1e9, 1)
     d["dram_bw"] = _entry(hbm, "GB/s", "streaming triad c=a+s*b per access "
                          "so its nominal number is the achievable rate for "
                          "random access, not a line-efficiency claim")
+    # ---- L2 bandwidth over an L2-resident working set
     ws = max(l2 // 4, 1 << 20)
+    nl2 = ws // 16
     al = a[:nl2 * 4].contiguous()
     bl = b[:nl2 * 4].contiguous()
     cl = c[:nl2 * 4].contiguous()
                         "medium", "first pass streams from HBM; amortized "
                         f"over {passes} passes")
+    # ---- latencies: min of 3 chases per level so a co-tenant burst cannot land in the dossier
     lat = {}
     idle_clk = measure_clock(device, ticks=2_000_000, blocks=1)
+    def chase(op, ring, warm_hops, hops, extra=None):
+        best = None
+        for _ in range(3):
+            if extra is None:
+                op(ring, warm_hops, out64)
+                _sync()
+                op(ring, hops, out64)
+            else:
+                op(ring, extra, warm_hops, out64)
+                _sync()
+                op(ring, extra, hops, out64)
+            _sync()
+            t = int(out64[0].item()) / hops
+            best = t if best is None else min(best, t)
+        return best
+    ring_s = _sattolo_ring(8192, device)
+    lat["smem_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_shared(r, h, o), ring_s,
+              1 << 14, 1 << 16), 1)
+    ring_l1 = _sattolo_ring((16 << 10) // 4, device)
+    lat["l1_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l1,
+              ring_l1.numel(), 1 << 15), 1)
+    ring_l2 = _sattolo_ring((2 << 20) // 4, device)
+    lat["l2_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_l2,
+              ring_l2.numel(), 1 << 14), 1)
     hbm_bytes = min(max(4 * l2, 64 << 20), props.total_memory // 8)
     ring_h = _sattolo_ring(int(hbm_bytes) // 4, device)
     hops_h = max((2 * l2) // 128, 1 << 17)
+    lat["dram_cycles"] = round(
+        chase(lambda r, h, o: ops.mk_chase_global(r, h, o), ring_h,
+              1 << 14, hops_h), 1)
     lat["ns_per_cycle"] = round(1.0 / idle_clk, 3)
     d["latency"] = _entry(lat, "cycles (single-lane dependent loads)",
+                          "Sattolo-cycle pointer chase, min of 3 runs; 16 "
+                          "KB ring for L1, 2 MB TLB-resident ring for L2, "
+                          "self-evicting chain (2x L2 in touched lines) "
+                          "for HBM", idle_clk, "high",
                           "smem includes index arithmetic; HBM includes "
                           "residual TLB effects at large footprints")
     del ring_h, ring_l2, ring_l1, ring_s
+    # ---- fp32/fp64 FMA and tensor-core throughput
     blocks = sm * 4
     iters = 20_000 if quick else 60_000
     ops.mk_fma_f32(blocks, 256, iters, sink)
     ms = _median(_events(lambda: ops.mk_fma_f32(blocks, 256, iters, sink),
                          reps))
+    flops = blocks * 256 * iters * 16 * 2 * 2
     d["fma_f32"] = _entry(round(flops / (ms * 1e-3) / 1e12, 2), "TFLOP/s",
                           "register-resident FMA chains", clk, "high")
     sink64 = torch.zeros(2, dtype=torch.float64, device=device)
     d["fma_f64"] = _entry(round(flops64 / (ms * 1e-3) / 1e12, 3), "TFLOP/s",
                           "register-resident double FMA chains (the DFMA "
                           "pipe)", clk, "high")
+    # ---- ILP ladder: 1/2/4 chains at low occupancy separates latency-bound from pipe-bound
+    ilp = {}
+    it_ilp = 20_000 if quick else 60_000
+    for ch in (1, 2, 4):
+        ops.mk_fma_ilp(ch, sm, 64, it_ilp, sink)
+        ms = _median(_events(
+            lambda c2=ch: ops.mk_fma_ilp(c2, sm, 64, it_ilp, sink), reps))
+        ilp[f"ilp{ch}"] = round(
+            sm * 64 * it_ilp * 16 * 2 * ch / (ms * 1e-3) / 1e12, 2)
+    ilp["ratio_4_1"] = round(ilp["ilp4"] / ilp["ilp1"], 2)
+    d["fma_ilp"] = _entry(ilp, "TFLOP/s",
+                          "1/2/4 independent dependent FMA chains per "
+                          "thread at one block of 64 threads per SM; a "
+                          "ratio near 4 means latency-bound at that "
+                          "occupancy", clk, "high")
     mma = {}
     mma_klanes = {}
+    fp8_accum = {}
+    for name, (kind, mn, k_nom, nom_lanes) in _MMA_KINDS.items():
         it = 30_000 if quick else 100_000
         r = ops.mk_mma(kind, blocks, 8, 512, sink)
         if r != 0:
             mma[name] = "unsupported"
             continue
         _sync()
+        gain, linear = _mma_calibrate(kind, sink)
         mma_klanes[name] = {
+            "executed_k_per_iter": round(gain, 2),
+            "vs_nominal": round(gain / nom_lanes, 3),
+            "calibration_linear": linear,
         }
+        if name.startswith("fp8"):
+            fp8_accum[name] = _fp8_accum_stall(kind, sink, k_nom)
         ms = _median(_events(
             lambda k=kind, i=it: ops.mk_mma(k, blocks, 8, i, sink), reps))
+        tflops = blocks * 8 * it * 2.0 * mn * gain / (ms * 1e-3) / 1e12
+        if name == "fp16_sparse_2_4":
+            mma[name] = {"executed": round(tflops, 1),
+                         "dense_equivalent": round(2 * tflops, 1)}
+        else:
+            mma[name] = round(tflops, 1)
     d["mma"] = _entry(mma, "TFLOP/s (TOP/s for int8)",
                       "register-fragment mma_sync loops (wmma; fp8 and "
+                      "2:4-sparse fp16 via inline PTX m16n8k32); flops "
+                      "derive from a sub-saturation accumulator read-back "
                       "with every fragment element observed, never the "
+                      "declared loop shape; sparse reports executed and "
+                      "dense-equivalent flops",
                       clk, "medium",
                       "dense-tile rate without memory traffic; real "
                       "kernels see this only when staging hides behind it")
     d["mma"]["verified_k_lanes"] = mma_klanes
+    if fp8_accum:
+        d["mma"]["fp8_accum"] = fp8_accum
+    # ---- fed MMA: smem-staged fp16 tiles under cp.async double buffering
+    if props.major >= 8:
+        gbuf = torch.ones(16 << 20, dtype=torch.float16, device=device)
+        sink[1] = 0.0
+        r = ops.mk_mma_fed(gbuf, 1, 1, 64, sink)
+        if r == 0:
+            _sync()
+            fed_gain = float(sink[1].item()) / 64
+            it_fed = 6_000 if quick else 20_000
+            ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink)
+            ms = _median(_events(
+                lambda: ops.mk_mma_fed(gbuf, sm * 2, 8, it_fed, sink),
+                reps))
+            fed = sm * 2 * 8 * it_fed * 2.0 * 256 * fed_gain / \
+                (ms * 1e-3) / 1e12
+            d["mma_fed"] = _entry(
+                round(fed, 1), "TFLOP/s",
+                "m16n16k16 fp16 tiles fed from an L2-resident buffer "
+                "through cp.async double-buffered shared memory; "
+                "accumulator-verified", clk, "high",
+                "the achieved counterpart to the register peak: staging "
+                "exposed, one dependent accumulator chain per warp")
+        del gbuf
+    # ---- shared-memory bandwidth and the bank-conflict stride sweep
     it_sm = 30_000 if quick else 100_000
     ops.mk_smem_bw(blocks, 256, it_sm, sink)
     ms = _median(_events(lambda: ops.mk_smem_bw(blocks, 256, it_sm, sink),
                           "block-resident read+write streaming (8 B per "
                           "thread-iteration), aggregated across SMs", clk,
                           "medium",
+                          "bank-conflict-light access pattern; the stride "
+                          "sweep below prices the conflicted case")
+    strides = (1, 8, 32) if quick else (1, 2, 4, 8, 16, 32)
+    it_st = 8_000 if quick else 20_000
+    st_ms = {}
+    for s2 in strides:
+        ops.mk_smem_stride(s2, blocks, 256, it_st, sink)
+        st_ms[s2] = _median(_events(
+            lambda s3=s2: ops.mk_smem_stride(s3, blocks, 256, it_st, sink),
+            reps))
+    d["smem_conflict_penalty"] = _entry(
+        {f"stride_{s2}": round(st_ms[s2] / st_ms[1], 2) for s2 in strides},
+        "x (time ratio vs stride 1)",
+        "dependent read-FMA-write per thread at warp-lane bank distance "
+        "`stride`; stride 32 puts every lane in one bank", clk, "high",
+        "the direct conflict measurement that disambiguates a "
+        "bank-conflict signature from an ILP stall")
     # ---- PCIe / host transfer bandwidth
     nbytes = 256 << 20
                               "d2d counts one direction of traffic")
     del host_pin, host_pag, dev_t, dev_u
+    # ---- atomic contention curve
     n_thr = blocks * 256
     buf = torch.zeros(n_thr, dtype=torch.float32, device=device)
     at = {"curve_slots": {}}
         buf.zero_()
         ops.mk_atomics(1, blocks, 256, it_at, buf, slots)
         ms = _median(_events(
+            lambda s4=slots: ops.mk_atomics(1, blocks, 256, it_at, buf, s4),
             reps))
         at["curve_slots"][str(slots)] = round(
             n_thr * it_at / (ms * 1e-3) / 1e9, 2)
                               "of distinct global addresses from 1 (full "
                               "contention) to one per thread", clk, "high")
+    # ---- launch overhead: torch-dispatch path and the raw C++ path
     anchor = sink
     n_launch = 500 if quick else 2000
     _sync()
         ops.mk_empty(anchor)
         _sync()
     rt = (time.perf_counter() - t0) / n_rt * 1e6
+    raw_q = float(ops.mk_launch_raw(n_launch, 0, anchor))
+    raw_rt = float(ops.mk_launch_raw(n_rt, 1, anchor))
     d["launch_overhead"] = _entry(
+        {"torch_queued_us": round(queued, 2),
+         "torch_round_trip_us": round(rt, 2),
+         "raw_queued_us": round(raw_q / n_launch * 1e6, 2)
+         if raw_q >= 0 else None,
+         "raw_round_trip_us": round(raw_rt / n_rt * 1e6, 2)
+         if raw_rt >= 0 else None},
+        "us", "empty-kernel trains; torch path per-launch through op "
+        "dispatch, raw path looped inside one binding call", clk,
+        "medium", "host-state-dependent; the torch-minus-raw gap is the "
+        "dispatch cost a torch-launched candidate pays")
     # ---- grid barrier
     bar_iters = 500 if quick else 2000
                                    "unavailable or grid too large", clk,
                                    "high")
+    # ---- occupancy API table plus timed knees
     occ = {}
     for threads in (128, 256, 512, 1024):
         row = {}
             ops.mk_fma_dep(knee_blocks, threads, smem_kb * 1024,
                            knee_iters, sink)
             ms = _median(_events(
+                lambda t=threads, s5=smem_kb: ops.mk_fma_dep(
+                    knee_blocks, t, s5 * 1024, knee_iters, sink), reps))
             fl = knee_blocks * threads * knee_iters * 16 * 2
             row[f"{smem_kb}KB"] = round(fl / (ms * 1e-3) / 1e12, 2)
         knees[f"t{threads}"] = row
         "at forced (threads, dyn smem) occupancies over fixed total work; "
         "the cliff marks where occupancy stops covering latency",
         clk, "high", "timing-derived counterpart to the API table above")
+    if cached:
+        import json
+        json.dump(d, open(cpath, "w", encoding="utf-8"))
     return d
+def probe_all_devices(quick=True, cached=True, tenancy_check=True):
+    """One dossier per visible device plus a pairwise P2P bandwidth matrix."""
+    n = torch.cuda.device_count()
+    devices = {}
+    for i in range(n):
+        devices[i] = probe_device(f"cuda:{i}", quick=quick, cached=cached,
+                                  tenancy_check=tenancy_check)
+    p2p = {}
+    if n > 1:
+        nbytes = 64 << 20
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                src = torch.rand(nbytes // 4, device=f"cuda:{i}")
+                dst = torch.empty(nbytes // 4, device=f"cuda:{j}")
+                dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                t0 = time.perf_counter()
+                for _ in range(5):
+                    dst.copy_(src)
+                torch.cuda.synchronize(i)
+                torch.cuda.synchronize(j)
+                ms = (time.perf_counter() - t0) / 5 * 1e3
+                p2p[f"{i}->{j}"] = {
+                    "gbs": round(nbytes / (ms * 1e-3) / 1e9, 1),
+                    "peer_access": bool(
+                        torch.cuda.can_device_access_peer(i, j)),
+                }
+                del src, dst
+    return {"devices": devices, "p2p": p2p}
+_CAPTURE_PROBE = r"""
+import pickle, sys, torch
+fn = pickle.load(open(sys.argv[1], "rb"))
+for _ in range(3):
+    fn()
+torch.cuda.synchronize()
+try:
+    g = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(g):
+        fn()
+    print("capturable", flush=True)
+except Exception as e:
+    print("uncapturable: %s: %s" % (type(e).__name__, str(e)[:120]),
+          flush=True)
+"""
+def probe_capturable(fn, timeout_s=180):
+    """Test CUDA-graph capturability of fn in a child process, so a capture-wedged RNG never reaches the caller."""
+    import pickle
+    import subprocess
+    import sys as _sys
+    import tempfile
+    try:
+        blob = pickle.dumps(fn)
+    except Exception:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": "fn is not picklable; probe skipped (define fn "
+                          "at module top level to enable it)"}
+    path = os.path.join(tempfile.mkdtemp(prefix="mk_cap_"), "fn.pkl")
+    with open(path, "wb") as f:
+        f.write(blob)
+    try:
+        r = subprocess.run([_sys.executable, "-c", _CAPTURE_PROBE, path],
+                           capture_output=True, text=True,
+                           timeout=timeout_s)
+    except Exception as e:  # noqa: BLE001
+        return {"capturable": None,
+                "reason": f"probe child failed: {type(e).__name__}"}
+    out = (r.stdout or "").strip()
+    if out == "capturable":
+        return {"capturable": True, "reason": ""}
+    if out.startswith("uncapturable"):
+        return {"capturable": False, "reason": out}
+    return {"capturable": None,
+            "reason": "probe child exit %s: %s" % (
+                r.returncode, (r.stderr or "")[-200:])}
+def _bench_verdict(rep):
+    parts = ["median %.4g ms" % rep["median_ms"]]
+    if "achieved_tflops" in rep:
+        parts.append("%.4g TFLOP/s" % rep["achieved_tflops"])
+    elif "achieved_gbs" in rep:
+        parts.append("%.4g GB/s" % rep["achieved_gbs"])
+    if "roofline" in rep:
+        parts.append("%.0f%% of %s roof" % (rep["roofline"]["pct_of_roof"],
+                                            rep["roofline"]["bound"]))
+    if rep["rejected_throttled"]:
+        parts.append("%d/%d rejected (%s)" % (
+            rep["rejected_throttled"], rep["samples"],
+            rep["rejection_basis"]))
+    if rep.get("no_clean_window"):
+        parts.append("no clean window: the whole run was throttled")
+    if rep.get("alloc_growth_bytes_per_call"):
+        parts.append("fn allocates %d B/call" %
+                     rep["alloc_growth_bytes_per_call"])
+    if rep.get("host_overhead_suspected"):
+        parts.append("fn appears to sync or do host work inside")
+    return "; ".join(parts)
 def bench(fn, iters=100, warmup=10, bytes=None, flops=None, dossier=None,
           dtype="fp16", clock_guard=0.97, clock_stride=8, graph=False,
+          graph_probe_isolated=False, device="cuda"):
+    """Median-of-N cudaEvent timing with throttle rejection, roofline placement, and footgun detection."""
+    for name, v in (("iters", iters), ("warmup", warmup)):
+        if not isinstance(v, int) or v < (1 if name == "iters" else 0):
+            raise ValueError(f"{name} must be a non-negative int; "
+                             f"got {v!r}")
+    for name, v in (("bytes", bytes), ("flops", flops)):
+        if v is not None and (not isinstance(v, (int, float)) or v <= 0):
+            raise ValueError(f"{name} must be a positive number counting "
+                             f"{name} per call of fn; got {v!r}")
     for _ in range(warmup):
         fn()
     _sync()
+    # footgun probes: per-call allocation growth and hidden host work
+    alloc0 = torch.cuda.memory_allocated(device)
+    fn()
+    fn()
+    _sync()
+    alloc_growth = max(0, (torch.cuda.memory_allocated(device) - alloc0)
+                       // 2)
+    # a burst of enqueues that leaves the stream idle means fn drains it; only trustworthy above the launch-overhead floor
+    for _ in range(16):
+        fn()
+    stream_idle = bool(torch.cuda.current_stream(device).query())
+    _sync()
+    t0 = time.perf_counter()
+    pre = _events(fn, 4)
+    wall_ms = (time.perf_counter() - t0) * 1e3
+    ev_ms = sum(pre)
+    host_suspect = (stream_idle and ev_ms / 4 > 0.05) or \
+        wall_ms > ev_ms * 1.5 + 2.0
     graph_state = "off"
     graph_reason = ""
+    if graph and graph_probe_isolated:
+        cap = probe_capturable(fn)
+        if cap["capturable"] is False:
+            graph = False
+            graph_state = "fallback_eager"
+            graph_reason = "isolated probe: " + cap["reason"]
     if graph:
         pre_rng = torch.cuda.get_rng_state(device)
         try:
         except Exception as e:  # noqa: BLE001 - fall back, say why
             graph_state = "fallback_eager"
             graph_reason = f"{type(e).__name__}: {str(e)[:120]}"
+            # drain the invalidated stream; a failed capture can wedge the device RNG on some torch versions
             rng_ok = True
             for _attempt in range(5):
                 try:
         samples.append((_events(fn, n), len(clocks) - 1))
     clocks.append(measure_clock(device, ticks=probe_ticks))
     best_clk = max(clocks)
+    # rejection basis: memory-bound work is judged on its own rate, not the SM clock
+    ridge_memory = False
+    if dossier is not None and bytes and flops:
+        bw0 = max(dossier["dram_bw"]["value"].values()) * 1e9
+        mma_v0 = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v0, dict):
+            mma_v0 = mma_v0.get("dense_equivalent")
+        peak0 = (mma_v0 if isinstance(mma_v0, (int, float))
+                 else dossier["fma_f32"]["value"]) * 1e12
+        ridge_memory = (flops / bytes) * bw0 < peak0
+    basis = "bandwidth_consistency" if (
+        bytes is not None and (flops is None or ridge_memory)) \
+        else "sm_clock"
     flat = []
+    kept = []
+    rejected = 0
+    if basis == "sm_clock":
+        for group, ci in samples:
+            window_ok = (clocks[ci] >= clock_guard * best_clk and
+                         clocks[min(ci + 1, len(clocks) - 1)] >=
+                         clock_guard * best_clk)
+            for ms in group:
+                flat.append(ms)
+                if window_ok:
+                    kept.append(ms)
+                else:
+                    rejected += 1
+    else:
+        for group, _ci in samples:
+            flat.extend(group)
+        floor = sorted(flat)[max(0, int(0.05 * len(flat)) - 1)]
+        for ms in flat:
+            if ms <= floor * 1.15:
                 kept.append(ms)
             else:
                 rejected += 1
+    all_rejected = not kept
+    if all_rejected:
         kept = flat
     med = _median(kept)
     ks = sorted(kept)
     n_k = len(ks)
+    # order-statistic 95% CI on the median; degenerate at tiny n
     half = 1.959964 * (n_k ** 0.5) / 2.0
     lo_i = max(0, int(n_k / 2 - half) - 1)
     hi_i = min(n_k - 1, int(n_k / 2 + half))
         "mean_ms": round(sum(kept) / n_k, 4),
         "samples": len(flat),
         "rejected_throttled": rejected,
+        "rejection_basis": basis,
         "graph_captured": graph_state == "captured",
         "clock_ghz": {"best": round(best_clk, 3),
                       "worst": round(min(clocks), 3)},
     }
+    no_clean = all_rejected
+    if basis == "sm_clock" and dossier is not None:
+        ref_clk = dossier["clock"]["max_ghz"]
+        if best_clk < clock_guard * ref_clk:
+            no_clean = True
+    if no_clean:
+        rep["no_clean_window"] = True
     if graph_reason:
         rep["graph_fallback_reason"] = graph_reason
+    if alloc_growth:
+        rep["alloc_growth_bytes_per_call"] = int(alloc_growth)
+    if host_suspect:
+        rep["host_overhead_suspected"] = True
+        rep["host_wall_over_event"] = round(wall_ms / max(ev_ms, 1e-9), 2)
     if bytes is not None:
         rep["achieved_gbs"] = round(bytes / (med * 1e-3) / 1e9, 1)
     if flops is not None:
     if dossier is not None and bytes and flops:
         bw = max(dossier["dram_bw"]["value"].values()) * 1e9
         mma_v = dossier["mma"]["value"].get(dtype)
+        if isinstance(mma_v, dict):
+            mma_v = mma_v.get("dense_equivalent")
         peak = (mma_v if isinstance(mma_v, (int, float))
                 else dossier["fma_f32"]["value"]) * 1e12
         ai = flops / bytes
             "pct_of_roof": round(100 * (flops / (med * 1e-3)) / roof, 1),
             "peak_dtype": dtype,
         }
+    rep["verdict"] = _bench_verdict(rep)
     return rep
 def _to_ordered_int(t):
+    """Monotone integer mapping of float bit patterns; differences are ULP distances."""
     if t.dtype == torch.float32:
         u = t.view(torch.int32).to(torch.int64) & 0xFFFFFFFF
         half = 1 << 31
 def ulp_diff(a, b):
+    """Elementwise ULP distance; both-NaN counts 0, one-sided NaN 2**62, integers by absolute difference."""
+    if a.dtype != b.dtype or a.shape != b.shape:
+        raise ValueError("ulp_diff needs matching dtype and shape; got "
+                         f"{a.dtype}{tuple(a.shape)} vs "
+                         f"{b.dtype}{tuple(b.shape)}; cast or reshape the "
+                         "candidate to the reference layout")
     if not a.is_floating_point():
         return (a.to(torch.int64) - b.to(torch.int64)).abs()
     ia, ib = _to_ordered_int(a), _to_ordered_int(b)
     @staticmethod
     def last_dim():
+        """Identical permutation of every arg's last dim: reduction order changes, value does not."""
         def shuffle(args, seed):
             g = torch.Generator(device=args[0].device).manual_seed(seed)
             p = torch.randperm(args[0].shape[-1], device=args[0].device,
     @staticmethod
     def matmul_k():
+        """Consistent K permutation of (A [.., M, K], B [.., K, N]): product unchanged, accumulation order not."""
         def shuffle(args, seed):
             a_m, b_m = args[0], args[1]
             g = torch.Generator(device=a_m.device).manual_seed(seed)
     return list(x) if isinstance(x, (tuple, list)) else [x]
+def _compare_hints(trial):
+    hints = []
+    if trial.get("bias_one_sided_frac", 0) >= 0.9 and \
+            trial.get("frac_above_band", 0) > 0.5:
+        hints.append("systematic one-sided bias: check scale factors or "
+                     "the accumulator dtype")
+    if trial["nan_cand"] > trial["nan_ref"]:
+        hints.append("candidate introduces NaN: check uninitialized "
+                     "memory or masking")
+    nd = trial.get("first_divergent_nd")
+    if nd and nd[-1] > 0 and any(nd[-1] % t == 0 for t in (16, 32, 64,
+                                                           128)):
+        hints.append("divergence starts on a tile-aligned index: check "
+                     "boundary indexing")
+    return hints
+def compare(ref, cand, gen=None, trials=8, order_shuffle=None,
+            order_trials=8, ref_variants=None, ulp_tol=None, atol=None,
+            rtol=None, band_margin=4.0, zero_atol=None, worst_k=8, seed=0,
+            inputs=None, frac_above_tol=0.5):
+    """Adversarial correctness comparison with pointwise order bands, ULP evidence, and a one-sided-bias gate; the banded route cannot reject errors under band_margin*(band+2) ULP at order-stable elements."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of gen (a seed -> args "
+                         "callable) or inputs (a tuple of concrete "
+                         "tensors)")
+    if inputs is not None:
+        if isinstance(inputs, torch.Tensor):
+            inputs = (inputs,)
+        if not all(isinstance(x, torch.Tensor) for x in inputs):
+            raise ValueError("inputs must be tensors; wrap scalars with "
+                             "torch.tensor first")
+        fixed = tuple(inputs)
+        gen = lambda seed: fixed  # noqa: E731
+        trials = 1
     worst = {"max_ulp": -1}
     total_hist = {}
     per_trial = []
     max_abs_seen = 0.0
     max_rel_seen = 0.0
+    out_shapes = []
     for t in range(trials):
         args = gen(seed + t)
+        if not isinstance(args, (tuple, list)):
+            raise ValueError("gen(seed) must return a tuple of args; got "
+                             f"{type(args).__name__}; return (x,) for a "
+                             "single-argument op")
         r_outs = _as_outputs(ref(*args))
         c_outs = _as_outputs(cand(*args))
+        if len(r_outs) != len(c_outs):
+            raise ValueError(f"reference returned {len(r_outs)} outputs, "
+                             f"candidate {len(c_outs)}; make the arities "
+                             "match")
+        for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
+            if r.dtype != c.dtype:
+                raise ValueError(f"output {oi} dtype mismatch: ref "
+                                 f"{r.dtype}, cand {c.dtype}; cast the "
+                                 "candidate to the reference dtype")
+            if r.shape != c.shape:
+                raise ValueError(f"output {oi} shape mismatch: ref "
+                                 f"{tuple(r.shape)}, cand "
+                                 f"{tuple(c.shape)}")
+        out_shapes = [tuple(r.shape) for r in r_outs]
+        # pointwise band: each element judged against its own measured order sensitivity
         bands = None
         band = 0
         band_score = 0.0
         max_ulp = 0
         mean_ulp = 0.0
         first_div = -1
+        first_div_nd = None
         n_el = 0
         n_above_band = 0
+        n_diverging = 0
+        n_cand_high = 0
         nan_r = nan_c = inf_r = inf_c = 0
         worst_elements = []
         for oi, (r, c) in enumerate(zip(r_outs, c_outs)):
                 mean_ulp += float(d.double().sum().item())
                 n_el += d.numel()
                 nz = (d > 0)
+                n_diverging += int(nz.sum().item())
+                n_cand_high += int(((c > r) & nz).sum().item())
                 if first_div < 0 and nz.any():
                     first_div = int(nz.flatten().nonzero()[0].item())
+                    first_div_nd = _unravel(first_div, r.shape)
                 if nz.any():
                     buckets = torch.clamp(
                         torch.log2(d[nz].double()).floor(), 0, 62
                         if val > 0:
                             worst_elements.append({
                                 "output": oi, "index": int(ix),
+                                "index_nd": _unravel(int(ix), r.shape),
                                 "ref": float(rf[ix].item()),
                                 "cand": float(cf[ix].item()),
                                 "ulp": int(val)})
                 inf_r += int(torch.isinf(r).sum().item())
                 inf_c += int(torch.isinf(c).sum().item())
         worst_elements.sort(key=lambda w: -w["ulp"])
+        frac_pos = n_cand_high / max(n_diverging, 1)
         trial_rep = {
             "max_ulp": max_ulp,
             "mean_ulp": round(mean_ulp / max(n_el, 1), 3),
             "first_divergent_index": first_div,
+            "first_divergent_nd": first_div_nd,
             "nan_ref": nan_r, "nan_cand": nan_c,
             "inf_ref": inf_r, "inf_cand": inf_c,
             "order_band_ulp": band,
             "band_score": round(band_score, 2),
             "frac_above_band": round(n_above_band / max(n_el, 1), 6),
+            "bias_one_sided_frac": round(max(frac_pos, 1 - frac_pos), 4)
+            if n_diverging else 0.0,
             "worst_elements": worst_elements[:worst_k],
         }
         per_trial.append(trial_rep)
         if max_ulp > worst["max_ulp"]:
             worst = trial_rep
     max_seen = max(t["max_ulp"] for t in per_trial)
+    banded = order_shuffle is not None or ref_variants
+    if banded:
         score = max(t["band_score"] for t in per_trial)
         ulp_ok = score <= band_margin
         criterion = (f"pointwise max(ulp / (order_band + 2)) = "
             max_rel_seen <= (rtol or 0) or max_abs_seen <= (atol or 0)
         criterion += (f"; OR max_abs {max_abs_seen:.3e} <= atol {atol} / "
                       f"max_rel {max_rel_seen:.3e} <= rtol {rtol}")
+    # one-sided bias gate: a uniform small error is above-band nearly everywhere in one direction
+    bias_fail = False
+    if banded and (ulp_ok or tol_ok):
+        w_frac = max(t["frac_above_band"] for t in per_trial)
+        w_side = max(t["bias_one_sided_frac"] for t in per_trial)
+        if w_frac > frac_above_tol and w_side >= 0.9:
+            bias_fail = True
+            criterion += ("; FAILED bias gate: frac_above_band %.3f > %s "
+                          "with one-sided fraction %.2f" %
+                          (w_frac, frac_above_tol, w_side))
+    passed = bool((ulp_ok or tol_ok) and not bias_fail)
+    hints = [] if passed else _compare_hints(worst)
+    if passed:
+        verdict = "pass: " + (
+            f"max {max_seen} ULP within the order band" if banded
+            else f"max {max_seen} ULP")
+    elif bias_fail:
+        verdict = ("fail: uniform bias, %.0f%% of elements above their "
+                   "order band in one direction" %
+                   (100 * max(t["frac_above_band"] for t in per_trial)))
+    else:
+        w0 = worst["worst_elements"][0] if worst["worst_elements"] else None
+        verdict = "fail: max %d ULP" % max_seen + (
+            " at index %s (ref %.6g, cand %.6g)" %
+            (w0["index_nd"], w0["ref"], w0["cand"]) if w0 else "")
+    rep = {
+        "pass": passed,
+        "verdict": verdict,
         "criterion": criterion,
         "worst_trial": worst,
         "max_abs": max_abs_seen,
         "trials": per_trial,
         "ulp_hist_log2": dict(sorted(total_hist.items())),
     }
+    if hints:
+        rep["hints"] = hints
+    return rep
 _FUZZ_VARIANTS = ("contig", "transposed", "strided_rows", "offset_slice",
         return False
+class _RandnMaker:
+    """Picklable default maker: `arity` same-shape randn tensors (zeros for empty shapes)."""
+    def __init__(self, arity=1):
+        self.arity = arity
+    def __call__(self, shape, dtype=torch.float32):
+        n = math.prod(shape)
+        if n:
+            out = tuple(torch.randn(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        else:
+            out = tuple(torch.zeros(tuple(shape), device="cuda",
+                                    dtype=dtype)
+                        for _ in range(self.arity))
+        return out if self.arity > 1 else out[0]
+def _default_make(arity=1):
+    """Default maker instance; a class so isolate=True can transport it."""
+    return _RandnMaker(arity)
 def _fuzz_build(make, shape, dtype):
     try:
         out = make(tuple(shape), dtype)
     if v == "strided_rows":
         return x[::2] if x.dim() >= 1 and x.shape[0] >= 2 else x
     if v == "offset_slice":
+        # storage-offset-1 view: misaligned for vectorized loads
         return x.flatten()[1:] if x.numel() > 1 else x
     if v == "overflow_expand":
         if x.numel() == 0:
 def _fuzz_group(op, ref, make, shape, dtype, variants, ulp_tol, device,
                 stop_on_context_loss=True):
+    """All variant cases for one (shape, dtype) group; returns (rows, context_lost)."""
     rows = []
     bases = _fuzz_build(make, shape, dtype)
     lost = False
             got = op(*xs)
             want = ref(*xs)
             if v == "overflow_expand":
+                # bounded comparison: head plus the high-index tail where int32 indexing wraps
                 w = 1 << 20
                 gf, wf = got.flatten(), want.flatten()
                 pairs = ((gf[:w], wf[:w]), (gf[-w:], wf[-w:]))
     return rows, lost
+def _fn_spec(fn, name):
+    """Picklable transport spec for a callable, with a source fallback for local defs."""
+    import pickle
+    try:
+        return ("pickle", pickle.dumps(fn), None)
+    except Exception:  # noqa: BLE001
+        import inspect
+        import textwrap
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+        except (OSError, TypeError):
+            src = ""
+        if not src.startswith("def "):
+            raise ValueError(
+                f"{name} is not picklable and not a plain def; define "
+                "op/ref/make as top-level functions (not lambdas or "
+                "closures) to use isolate=True") from None
+        return ("source", src, fn.__name__)
+_POOL_BOOTSTRAP = r"""
+import json, os, pickle, sys
 meta = json.load(open(sys.argv[1], "r"))
+sys.path[:0] = meta["sys_path"]
 try:
     import kernels
     _mk = kernels.get_kernel(meta["repo"], version=meta["version"],
     import load_local
     _mk = load_local.load()
 import torch
+_ns = {"torch": torch}
+def _resolve(spec):
+    kind, payload, name = spec
+    if kind == "pickle":
+        return pickle.loads(payload)
+    exec(payload, _ns)
+    return _ns[name]
+_op, _ref, _make = (_resolve(s) for s in
+                    pickle.load(open(meta["fns"], "rb")))
+print("ready", flush=True)
+for line in sys.stdin:
+    job = json.loads(line)
+    rows, _l = _mk._fuzz_group(
+        _op, _ref, _make, tuple(job["shape"]),
+        getattr(torch, job["dtype"]), tuple(job["variants"]),
+        job["ulp_tol"], job["device"], stop_on_context_loss=False)
+    pickle.dump(rows, open(job["out"], "wb"))
+    print("done", flush=True)
 """
+class _FuzzPool:
+    """One persistent isolation worker fed groups over stdin, respawned only after a crash."""
+    def __init__(self, meta_path, stderr_path, timeout_s):
+        self.meta_path = meta_path
+        self.stderr_path = stderr_path
+        self.timeout_s = timeout_s
+        self.proc = None
+        self.q = None
+    def _spawn(self):
+        import queue
+        import subprocess
+        import sys as _sys
+        import threading
+        self.errf = open(self.stderr_path, "ab")
+        self.proc = subprocess.Popen(
+            [_sys.executable, "-c", _POOL_BOOTSTRAP, self.meta_path],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=self.errf, text=True)
+        self.q = queue.Queue()
+        def reader(p, q):
+            for line in p.stdout:
+                q.put(line.strip())
+        threading.Thread(target=reader, args=(self.proc, self.q),
+                         daemon=True).start()
+        try:
+            first = self.q.get(timeout=self.timeout_s)
+        except Exception:  # noqa: BLE001
+            first = None
+        return first == "ready"
+    def run(self, job_line):
+        """Returns True when the worker reports done, False on crash or timeout."""
+        import queue
+        if self.proc is None or self.proc.poll() is not None:
+            if not self._spawn():
+                return False
+        try:
+            self.proc.stdin.write(job_line + "\n")
+            self.proc.stdin.flush()
+        except OSError:
+            return False
+        try:
+            return self.q.get(timeout=self.timeout_s) == "done"
+        except queue.Empty:
+            if self.proc.poll() is None:
+                self.proc.kill()
+            return False
+    def stderr_tail(self):
+        try:
+            self.errf.flush()
+            with open(self.stderr_path, "rb") as f:
+                return f.read()[-400:].decode(errors="replace")
+        except OSError:
+            return ""
+    def close(self):
+        if self.proc is not None and self.proc.poll() is None:
+            self.proc.kill()
+        try:
+            self.errf.close()
+        except Exception:  # noqa: BLE001
+            pass
+def _fuzz_hints(rows):
+    hints = []
+    bad = [c for c in rows if c["status"] == "mismatch"]
+    if bad and all(c["variant"] in ("transposed", "strided_rows",
+                                    "offset_slice") for c in bad):
+        hints.append("mismatches only on non-contiguous variants: the op "
+                     "assumes contiguity; call .contiguous() or honor "
+                     "strides")
+    if any(c["variant"] == "overflow_expand" and
+           c["status"] == "mismatch" for c in rows):
+        hints.append("overflow_expand mismatch: int32 indexing wraps past "
+                     "2^31 elements; use 64-bit index arithmetic")
+    return hints
+def fuzz_shapes(op, ref, make=None, shapes=None, variants=_FUZZ_VARIANTS,
                 dtypes=(torch.float32,), ulp_tol=64, isolate=False,
+                isolate_timeout_s=180, device="cuda", arity=1):
+    """Edge shapes, dtypes, and layout mutations with per-case repro recipes; isolate=True survives context-killing candidates via a pooled worker."""
     if shapes is None:
         shapes = [(), (7,), (0, 8), (1, 1), (1, 17), (3, 63), (17, 129),
                   (128, 128), (1023, 5), (2, 4096), (2, 3, 5)]
+    if make is None:
+        make = _default_make(arity)
     rows = []
     lost = False
     if isolate:
         import json
         import pickle
         import sys as _sys
         import tempfile
         tmpdir = tempfile.mkdtemp(prefix="mk_fuzz_")
         fns = os.path.join(tmpdir, "fns.pkl")
+        specs = [_fn_spec(f, n) for f, n in ((op, "op"), (ref, "ref"),
+                                             (make, "make"))]
         with open(fns, "wb") as f:
+            pickle.dump(specs, f)
+        meta_path = os.path.join(tmpdir, "meta.json")
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump({"sys_path": [p for p in _sys.path
+                                    if isinstance(p, str)],
+                       "repo": _REPO_ID, "version": _REPO_VERSION,
+                       "fns": fns}, f)
+        pool = _FuzzPool(meta_path, os.path.join(tmpdir, "stderr.log"),
+                         isolate_timeout_s)
+        try:
+            for dtype in dtypes:
+                for shape in shapes:
+                    out = os.path.join(tmpdir, "rows.pkl")
+                    if os.path.exists(out):
+                        os.remove(out)
+                    job = json.dumps({
                         "shape": list(shape),
                         "dtype": str(dtype).replace("torch.", ""),
                         "variants": list(variants),
                         "ulp_tol": ulp_tol, "device": device,
+                        "out": out})
+                    ok = pool.run(job)
+                    if ok and os.path.exists(out):
                         with open(out, "rb") as f:
+                            rows.extend(pickle.load(f))
+                    else:
+                        rows.append({
+                            "shape": tuple(shape), "variant": "*",
+                            "dtype": str(dtype).replace("torch.", ""),
+                            "status": "crashed_isolated",
+                            "stderr_tail": pool.stderr_tail()})
+        finally:
+            pool.close()
     else:
         pending = [(dt, sh) for dt in dtypes for sh in shapes]
         for gi, (dtype, shape) in enumerate(pending):
     n_bad = sum(1 for r in rows
                 if r["status"] not in ("ok", "skipped_vram",
                                        "skipped_empty"))
+    rep = {"cases": rows, "failed": n_bad, "total": len(rows),
+           "context_lost": lost}
+    hints = _fuzz_hints(rows)
+    if hints:
+        rep["hints"] = hints
+    if n_bad == 0:
+        rep["verdict"] = "pass: %d/%d cases ok" % (len(rows) - n_bad,
+                                                   len(rows))
+    else:
+        worst_case = next(c for c in rows
+                          if c["status"] not in ("ok", "skipped_vram",
+                                                 "skipped_empty"))
+        rep["verdict"] = "fail: %d/%d cases (%s at %s %s)" % (
+            n_bad, len(rows), worst_case["status"], worst_case["shape"],
+            worst_case["variant"])
+    return rep
 def sweep(factory, grid, iters=30, warmup=5, bytes=None, flops=None,
           check=None, budget_s=None, race=False):
+    """Launch-configuration search, fastest first, with a correctness gate per row and no silently dropped points."""
     keys = list(grid.keys())
     def expand(i, acc):
                 continue
             rows.append(run_point(p, iters))
     rows.sort(key=lambda r: (not r.get("check", True), r["median_ms"]))
+    if rows:
+        n_pruned = sum(1 for r in rows if r.get("status") == "pruned_race")
+        n_skip = sum(1 for r in rows if r.get("status") == "not_run")
+        best = rows[0]
+        rows_verdict = "fastest %s at %.4g ms" % (
+            {k: best[k] for k in keys}, best["median_ms"])
+        if n_pruned:
+            rows_verdict += "; %d pruned" % n_pruned
+        if n_skip:
+            rows_verdict += "; %d not run" % n_skip
+        best["verdict"] = rows_verdict
     return rows
+def judge(cand, ref, inputs=None, gen=None, bytes=None, flops=None,
+          dtype=None, order_shuffle=None, make=None, quick_fuzz=True,
+          device="cuda"):
+    """One-call verdict: compare, a quick fuzz, and a roofline bench against the cached dossier."""
+    if (gen is None) == (inputs is None):
+        raise ValueError("pass exactly one of inputs (concrete tensors) "
+                         "or gen (seed -> args)")
+    if inputs is not None and isinstance(inputs, torch.Tensor):
+        inputs = (inputs,)
+    args0 = tuple(inputs) if inputs is not None else gen(0)
+    arity = len(args0)
+    if dtype is None:
+        dt0 = args0[0].dtype
+        dtype = {torch.float16: "fp16", torch.bfloat16: "bf16"}.get(
+            dt0, "f32")
+    dossier = probe_device(device, quick=True, cached=True,
+                           tenancy_check=False)
+    cmp_rep = compare(ref, cand, gen=gen, inputs=inputs, trials=4,
+                      order_shuffle=order_shuffle)
+    fuzz_rep = None
+    if quick_fuzz:
+        fuzz_rep = fuzz_shapes(
+            cand, ref, make=make, arity=arity,
+            shapes=[(1, 17), (3, 63), (128, 128)],
+            variants=("contig", "transposed", "offset_slice"),
+            dtypes=(args0[0].dtype,))
+    bench_rep = None
+    if inputs is not None:
+        bench_rep = bench(lambda: cand(*inputs), iters=32, warmup=6,
+                          bytes=bytes, flops=flops, dossier=dossier,
+                          dtype=dtype, device=device)
+    passed = cmp_rep["pass"] and (fuzz_rep is None or
+                                  fuzz_rep["failed"] == 0)
+    parts = [cmp_rep["verdict"]]
+    if fuzz_rep is not None:
+        parts.append(fuzz_rep["verdict"])
+    if bench_rep is not None:
+        parts.append(bench_rep["verdict"])
+    rep = {"pass": passed, "verdict" : " | ".join(parts),
+           "compare": cmp_rep, "fuzz": fuzz_rep, "bench": bench_rep,
+           "device": dossier["device"]["name"]}
+    hints = list(cmp_rep.get("hints", []))
+    if fuzz_rep is not None:
+        hints += fuzz_rep.get("hints", [])
+    if hints:
+        rep["hints"] = hints
+    return rep
 def alloc_stamps(n, blocks=None, device="cuda"):
+    """Device buffer for MK_STAMP (1-D) or MK_STAMP_BLOCK ([blocks, n]) stamps."""
     if blocks is not None:
         return torch.zeros(blocks, n, dtype=torch.int64, device=device)
     return torch.zeros(n, dtype=torch.int64, device=device)
 def pinned_dossiers():
+    """Names of the release-pinned dossiers, one per certified architecture."""
     return sorted(_PINNED.keys())
 def dossier_drift(current, pinned=None, rel_tol=0.35, skip=_DRIFT_SKIP):
+    """Per-leaf relative drift of a fresh dossier against the release pin for the same architecture."""
     if pinned is None:
         arch = current["device"]["sm_arch"]
         matches = [k for k, v in _PINNED.items()
                         "rel": round(rel, 4)})
     worst = max((e["rel"] for e in entries), default=0.0)
     over = [e for e in entries if e["rel"] > rel_tol]
+    rep = {"entries": entries, "worst_rel": worst, "over_tol": over,
+           "rel_tol": rel_tol, "compared": len(entries),
+           "pass": len(over) == 0}
+    rep["verdict"] = ("pass: worst drift %.3f over %d entries" %
+                      (worst, len(entries))) if rep["pass"] else \
+        ("fail: %d entries over %.2f, worst %s at %.3f" %
+         (len(over), rel_tol, over[0]["path"], worst))
+    return rep
 def stamped_demo(n=1 << 22, fma_iters=4000, blocks=None, threads=256,
                  device="cuda"):
+    """Run the shipped MK_STAMP_BLOCK example (load, compute, drained store) and decode its stamps."""
     props = torch.cuda.get_device_properties(device)
     if blocks is None:
         blocks = props.multi_processor_count
 def read_stamps(stamps, labels=None, clock_ghz=None):
+    """Decode MK_STAMP deltas to ticks and microseconds; 2-D buffers yield min/median/max across blocks."""
     if clock_ghz is None:
         clock_ghz = measure_clock(stamps.device)
     return {"phases": phases, "clock_ghz": round(clock_ghz, 3),
             "blocks_reporting": int(live.sum().item()),
             "blocks_total": int(live.numel())}
+_SCHEMAS = {
+    "probe_device": {
+        "device": "name, sm_arch, sms, l2_bytes, vram_bytes, torch, "
+                  "cuda_runtime, ecc, driver, power_limit_w",
+        "clock": "max/min/final GHz under sustained FMA load plus sag_pct",
+        "dram_bw": "GB/s: triad_4B/8B/16B, read_only, write_only, "
+                   "random_gather_16B",
+        "l2_bw": "GB/s over an L2-resident working set",
+        "latency": "cycles: smem, l1, l2, dram (min of 3 chases) plus "
+                   "ns_per_cycle",
+        "fma_f32 / fma_f64": "TFLOP/s of the register-resident pipes",
+        "fma_ilp": "TFLOP/s at 1/2/4 chains plus ratio_4_1; near 4 means "
+                   "latency-bound",
+        "mma": "TFLOP/s per dtype; sparse carries executed and "
+               "dense_equivalent; verified_k_lanes carries "
+               "executed_k_per_iter, vs_nominal, calibration_linear; "
+               "fp8_accum carries the accumulate-precision stall",
+        "mma_fed": "TFLOP/s of smem-staged fp16 tiles (staging exposed)",
+        "smem_bw": "GB/s aggregate, conflict-light pattern",
+        "smem_conflict_penalty": "time ratio vs stride 1 per lane stride",
+        "transfer_bw": "GB/s: h2d/d2h pinned and pageable, d2d",
+        "atomics_f32": "Gop/s curve over distinct addresses plus "
+                       "shared_same_addr",
+        "launch_overhead": "us: torch_queued, torch_round_trip, "
+                           "raw_queued, raw_round_trip",
+        "grid_barrier": "us per grid.sync or 'unsupported'",
+        "occupancy_blocks_per_sm": "API table by (threads, dyn smem)",
+        "occupancy_knees_fma_tflops": "timed dependent-chain table",
+    },
+    "bench": {
+        "median_ms": "median over accepted samples",
+        "sustained_ms": "median over all samples",
+        "median_ci95_ms / p05_ms / p95_ms / min_ms / mean_ms":
+            "distribution of accepted samples",
+        "samples / rejected_throttled / rejection_basis":
+            "counts and whether rejection used sm_clock or "
+            "bandwidth_consistency",
+        "no_clean_window": "present when every window ran throttled; the "
+                           "median is then a throttled-regime number",
+        "clock_ghz": "best and worst SM clock probes around the run",
+        "achieved_gbs / achieved_tflops / arithmetic_intensity":
+            "rates from declared traffic",
+        "roofline": "bound, ridge_flops_per_byte, pct_of_roof, peak_dtype",
+        "graph_captured / graph_fallback_reason": "CUDA-graph state",
+        "alloc_growth_bytes_per_call": "present when fn leaks allocations",
+        "host_overhead_suspected": "present when fn syncs or does host "
+                                   "work inside; ops under ~50 us are "
+                                   "below the detection floor",
+        "verdict": "one-sentence summary",
+    },
+    "compare": {
+        "pass": "final verdict incl. the one-sided bias gate",
+        "verdict / criterion / hints": "summary, acceptance rule, and "
+                                       "failure-pattern suggestions",
+        "worst_trial": "max_ulp, mean_ulp, first_divergent_index(+_nd), "
+                       "NaN/Inf census, order_band_ulp, band_score, "
+                       "frac_above_band, bias_one_sided_frac, "
+                       "worst_elements (index, index_nd, ref, cand, ulp)",
+        "max_abs / max_rel / ulp_hist_log2": "aggregate evidence",
+        "floor": "the banded route cannot reject errors under "
+                 "band_margin*(band+2) ULP at order-stable elements",
+    },
+    "fuzz_shapes": {
+        "cases": "per-case shape, variant, dtype, status, repro recipe",
+        "status values": "ok | mismatch | exception | context_killed | "
+                         "context_lost | crashed_isolated | skipped_vram "
+                         "| skipped_empty",
+        "failed / total / context_lost / verdict / hints": "aggregates",
+    },
+    "sweep": {
+        "rows": "grid point plus median_ms, rejected_throttled, check?, "
+                "achieved rates, status in pruned_race | not_run",
+        "verdict": "on the fastest row",
+    },
+    "dossier_drift": {
+        "entries": "path, current, pinned, rel per intersecting leaf",
+        "worst_rel / over_tol / compared / pass / verdict": "aggregates",
+    },
+    "judge": {
+        "pass / verdict / hints": "composite over compare, fuzz, bench",
+        "compare / fuzz / bench": "the full sub-reports",
+    },
+    "read_stamps": {
+        "phases": "ticks and us per phase; 2-D input adds min/median/max "
+                  "across blocks",
+        "note": "stamps record issue; DRAIN variants include the store "
+                "drain to the coherence point",
+    },
+}
+def schema(name=None):
+    """Field layout of every report, so an agent can look up what a number means."""
+    if name is None:
+        return _SCHEMAS
+    if name not in _SCHEMAS:
+        raise KeyError(f"no schema for {name!r}; have "
+                       f"{sorted(_SCHEMAS)}")
+    return _SCHEMAS[name]

build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_0b9de42.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8161b3fe4adbec8d22ecff765130ad6b9893ecca46b1e65c09398d763750b592
+size 1434632

build/torch213-cxx11-cu132-x86_64-linux/_metakernel_cuda_b62a1ce.abi3.so DELETED Viewed

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6ce8f061538f15eb45b47250112237c577a079f3ed6b7c54a5ff6d963ff0ba65
-size 1188488

build/torch213-cxx11-cu132-x86_64-linux/_ops.py CHANGED Viewed

@@ -1,9 +1,9 @@
 import torch
-from . import _metakernel_cuda_b62a1ce
-ops = torch.ops._metakernel_cuda_b62a1ce
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_metakernel_cuda_b62a1ce::{op_name}"

 import torch
+from . import _metakernel_cuda_0b9de42
+ops = torch.ops._metakernel_cuda_0b9de42
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
+    return f"_metakernel_cuda_0b9de42::{op_name}"

build/torch213-cxx11-cu132-x86_64-linux/_pinned.py CHANGED Viewed

@@ -1,8 +1,4 @@
-"""Release-pinned device dossiers, one per certified architecture.
-Generated by dev/pin_dossier.py from full probe_device() runs on idle,
-single-tenant cards; consumed by metakernel.dossier_drift.
-"""
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
@@ -295,7 +291,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
- 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
@@ -308,21 +304,21 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
-                                                   'value': {'curve_slots': {'1': 0.72,
-                                                                             '145408': 483.54,
-                                                                             '4096': 209.84,
-                                                                             '512': 55.6,
-                                                                             '64': 13.82,
-                                                                             '8': 5.77},
-                                                             'shared_same_addr': 12.88}},
                                    'clock': {'confidence': 'high',
-                                             'final_ghz': 2.699,
-                                             'max_ghz': 2.706,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
-                                             'min_ghz': 2.501,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
@@ -336,7 +332,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
-                                   'dram_bw': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
@@ -356,26 +352,41 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
-                                               'value': {'random_gather_16B': 218.5,
-                                                         'read_only': 771.0,
-                                                         'triad_16B': 663.1,
-                                                         'triad_4B': 638.3,
-                                                         'triad_8B': 705.3,
                                                          'write_only': 766.5}},
-                                   'fma_f32': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
-                                               'value': 90.85},
-                                   'fma_f64': {'clock_ghz': 2.706,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
-                                               'value': 1.282},
-                                   'grid_barrier': {'clock_ghz': 2.706,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
@@ -383,8 +394,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
-                                                    'value': 0.54},
-                                   'l2_bw': {'clock_ghz': 2.706,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
@@ -394,14 +405,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
-                                             'value': 9325.3},
-                                   'latency': {'clock_ghz': 2.687,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
-                                                         'pointer chase; 16 '
-                                                         'KB ring for L1, 2 '
-                                                         'MB TLB-resident '
-                                                         'ring for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
@@ -413,40 +425,58 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
-                                               'value': {'dram_cycles': 649.4,
                                                          'l1_cycles': 45.8,
-                                                         'l2_cycles': 291.5,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
-                                   'launch_overhead': {'clock_ghz': 2.706,
-                                                       'confidence': 'high',
                                                        'method': 'empty-kernel '
-                                                                 'trains, '
-                                                                 'queued vs '
-                                                                 'launch+sync',
-                                                       'note': 'host-dependent: '
-                                                               'includes '
-                                                               'torch op '
-                                                               'dispatch',
                                                        'units': 'us',
-                                                       'value': {'queued_us': 5.55,
-                                                                 'round_trip_us': 14.1}},
-                                   'mma': {'clock_ghz': 2.706,
                                            'confidence': 'medium',
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
-                                                     'm16n8k32; sparse '
-                                                     'counted '
-                                                     'dense-equivalent, the '
-                                                     'vendor convention); '
-                                                     'flops derive from the '
-                                                     'mean accumulator '
-                                                     'read-back with every '
-                                                     'fragment element '
-                                                     'observed, never the '
-                                                     'declared loop shape',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
@@ -454,25 +484,54 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
-                                           'value': {'bf16': 365.5,
-                                                     'fp16': 375.9,
-                                                     'fp16_sparse_2_4': 713.4,
-                                                     'fp8_e4m3': 193.7,
-                                                     'int8': 770.4,
-                                                     'tf32': 177.1},
-                                           'verified_k_lanes': {'bf16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'fp16_sparse_2_4': {'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
-                                                                'fp8_e4m3': {'executed_k_per_iter': 64.0,
-                                                                             'vs_nominal': 0.25},
-                                                                'int8': {'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
-                                                                'tf32': {'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
-                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.706,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
@@ -501,7 +560,7 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
-                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.706,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
@@ -521,17 +580,6 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
-                                                                            'throughput '
-                                                                            'is '
-                                                                            'proportional '
-                                                                            'to '
-                                                                            'resident '
-                                                                            'threads '
-                                                                            'until '
-                                                                            'the '
-                                                                            'pipe '
-                                                                            'saturates, '
-                                                                            'so '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
@@ -549,15 +597,15 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
-                                                                                      '32KB': 73.66,
-                                                                                      '48KB': 74.95},
-                                                                            't128': {'0KB': 79.86,
                                                                                      '32KB': 60.31,
-                                                                                     '48KB': 44.57},
-                                                                            't256': {'0KB': 81.69,
-                                                                                     '32KB': 79.48,
-                                                                                     '48KB': 71.47}}},
-                                   'smem_bw': {'clock_ghz': 2.706,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
@@ -566,12 +614,56 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
-                                                       'access pattern; a '
-                                                       'conflicted pattern '
-                                                       'can be far lower',
                                                'units': 'GB/s',
-                                               'value': 21250.0},
-                                   'transfer_bw': {'clock_ghz': 2.706,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
@@ -583,8 +675,8 @@ PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
-                                                   'value': {'d2d': 330.7,
-                                                             'd2h_pageable': 15.6,
-                                                             'd2h_pinned': 26.2,
-                                                             'h2d_pageable': 16.6,
                                                              'h2d_pinned': 24.0}}}}

+'''Release-pinned device dossiers, one per certified architecture; generated by dev/pin_dossier.py from idle single-tenant runs, consumed by dossier_drift.'''
 PINNED = {'sm86_nvidiageforcertx3070tila': {'atomics_f32': {'clock_ghz': 1.785,
                                                    'confidence': 'high',
                                                              'd2h_pinned': 10.8,
                                                              'h2d_pageable': 10.3,
                                                              'h2d_pinned': 11.8}}},
+ 'sm89_nvidiartx6000adagenerati': {'atomics_f32': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': 'atomicAdd '
                                                              'hammer; curve '
                                                              'contention) to '
                                                              'one per thread',
                                                    'units': 'Gop/s',
+                                                   'value': {'curve_slots': {'1': 0.71,
+                                                                             '145408': 413.99,
+                                                                             '4096': 184.9,
+                                                                             '512': 49.84,
+                                                                             '64': 13.25,
+                                                                             '8': 5.74},
+                                                             'shared_same_addr': 12.23}},
                                    'clock': {'confidence': 'high',
+                                             'final_ghz': 2.698,
+                                             'max_ghz': 2.705,
                                              'method': '24 back-to-back FMA '
                                                        'spin windows of 30M '
                                                        'ticks; wall/ticks '
                                                        'per window',
+                                             'min_ghz': 2.5,
                                              'sag_pct': 0.3,
                                              'units': 'GHz'},
                                    'device': {'cuda_runtime': '12.6',
                                               'sms': 142,
                                               'torch': '2.10.0+cu126',
                                               'vram_bytes': 48305274880},
+                                   'dram_bw': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'streaming triad '
                                                          'c=a+s*b per access '
                                                        'line-efficiency '
                                                        'claim',
                                                'units': 'GB/s',
+                                               'value': {'random_gather_16B': 218.1,
+                                                         'read_only': 766.5,
+                                                         'triad_16B': 682.1,
+                                                         'triad_4B': 654.8,
+                                                         'triad_8B': 670.9,
                                                          'write_only': 766.5}},
+                                   'fma_f32': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'FMA chains',
                                                'units': 'TFLOP/s',
+                                               'value': 86.58},
+                                   'fma_f64': {'clock_ghz': 2.705,
                                                'confidence': 'high',
                                                'method': 'register-resident '
                                                          'double FMA chains '
                                                          '(the DFMA pipe)',
                                                'units': 'TFLOP/s',
+                                               'value': 1.257},
+                                   'fma_ilp': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': '1/2/4 independent '
+                                                         'dependent FMA '
+                                                         'chains per thread '
+                                                         'at one block of 64 '
+                                                         'threads per SM; a '
+                                                         'ratio near 4 means '
+                                                         'latency-bound at '
+                                                         'that occupancy',
+                                               'units': 'TFLOP/s',
+                                               'value': {'ilp1': 11.75,
+                                                         'ilp2': 23.37,
+                                                         'ilp4': 43.03,
+                                                         'ratio_4_1': 3.66}},
+                                   'grid_barrier': {'clock_ghz': 2.705,
                                                     'confidence': 'high',
                                                     'method': 'cooperative '
                                                               'kernel, 142 '
                                                               'threads',
                                                     'units': 'us per '
                                                              'grid.sync',
+                                                    'value': 0.55},
+                                   'l2_bw': {'clock_ghz': 2.705,
                                              'confidence': 'medium',
                                              'method': 'in-kernel repeated '
                                                        'triad passes over 72 '
                                                      'from HBM; amortized '
                                                      'over 64 passes',
                                              'units': 'GB/s',
+                                             'value': 9590.6},
+                                   'latency': {'clock_ghz': 2.691,
                                                'confidence': 'high',
                                                'method': 'Sattolo-cycle '
+                                                         'pointer chase, min '
+                                                         'of 3 runs; 16 KB '
+                                                         'ring for L1, 2 MB '
+                                                         'TLB-resident ring '
+                                                         'for L2, '
                                                          'self-evicting '
                                                          'chain (2x L2 in '
                                                          'touched lines) for '
                                                        'footprints',
                                                'units': 'cycles (single-lane '
                                                         'dependent loads)',
+                                               'value': {'dram_cycles': 656.9,
                                                          'l1_cycles': 45.8,
+                                                         'l2_cycles': 292.0,
                                                          'ns_per_cycle': 0.372,
                                                          'smem_cycles': 30.0}},
+                                   'launch_overhead': {'clock_ghz': 2.705,
+                                                       'confidence': 'medium',
                                                        'method': 'empty-kernel '
+                                                                 'trains; '
+                                                                 'torch path '
+                                                                 'per-launch '
+                                                                 'through op '
+                                                                 'dispatch, '
+                                                                 'raw path '
+                                                                 'looped '
+                                                                 'inside one '
+                                                                 'binding '
+                                                                 'call',
+                                                       'note': 'host-state-dependent; '
+                                                               'the '
+                                                               'torch-minus-raw '
+                                                               'gap is the '
+                                                               'dispatch '
+                                                               'cost a '
+                                                               'torch-launched '
+                                                               'candidate '
+                                                               'pays',
                                                        'units': 'us',
+                                                       'value': {'raw_queued_us': 6.75,
+                                                                 'raw_round_trip_us': 13.87,
+                                                                 'torch_queued_us': 7.09,
+                                                                 'torch_round_trip_us': 18.53}},
+                                   'mma': {'clock_ghz': 2.705,
                                            'confidence': 'medium',
+                                           'fp8_accum': {'fp8_e4m3': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0},
+                                                         'fp8_e5m2': {'effective_accum_mantissa_bits': 8,
+                                                                      'stall_element_value': 16384.0}},
                                            'method': 'register-fragment '
                                                      'mma_sync loops (wmma; '
                                                      'fp8 and 2:4-sparse '
                                                      'fp16 via inline PTX '
+                                                     'm16n8k32); flops '
+                                                     'derive from a '
+                                                     'sub-saturation '
+                                                     'accumulator read-back '
+                                                     'with every fragment '
+                                                     'element observed, '
+                                                     'never the declared '
+                                                     'loop shape; sparse '
+                                                     'reports executed and '
+                                                     'dense-equivalent flops',
                                            'note': 'dense-tile rate without '
                                                    'memory traffic; real '
                                                    'kernels see this only '
                                                    'behind it',
                                            'units': 'TFLOP/s (TOP/s for '
                                                     'int8)',
+                                           'value': {'bf16': 369.6,
+                                                     'fp16': 365.3,
+                                                     'fp16_sparse_2_4': {'dense_equivalent': 711.1,
+                                                                         'executed': 355.6},
+                                                     'fp8_e4m3': 772.3,
+                                                     'fp8_e5m2': 771.2,
+                                                     'int8': 750.0,
+                                                     'tf32': 178.3},
+                                           'verified_k_lanes': {'bf16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'fp16_sparse_2_4': {'calibration_linear': True,
+                                                                                    'executed_k_per_iter': 128.0,
                                                                                     'vs_nominal': 1.0},
+                                                                'fp8_e4m3': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'fp8_e5m2': {'calibration_linear': True,
+                                                                             'executed_k_per_iter': 256.0,
+                                                                             'vs_nominal': 1.0},
+                                                                'int8': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 64.0,
                                                                          'vs_nominal': 1.0},
+                                                                'tf32': {'calibration_linear': True,
+                                                                         'executed_k_per_iter': 32.0,
                                                                          'vs_nominal': 1.0}}},
+                                   'mma_fed': {'clock_ghz': 2.705,
+                                               'confidence': 'high',
+                                               'method': 'm16n16k16 fp16 '
+                                                         'tiles fed from an '
+                                                         'L2-resident buffer '
+                                                         'through cp.async '
+                                                         'double-buffered '
+                                                         'shared memory; '
+                                                         'accumulator-verified',
+                                               'note': 'the achieved '
+                                                       'counterpart to the '
+                                                       'register peak: '
+                                                       'staging exposed, one '
+                                                       'dependent '
+                                                       'accumulator chain '
+                                                       'per warp',
+                                               'units': 'TFLOP/s',
+                                               'value': 85.2},
+                                   'occupancy_blocks_per_sm': {'clock_ghz': 2.705,
                                                                'confidence': 'high',
                                                                'method': 'occupancy '
                                                                          'API '
                                                                                   '16KB': 3,
                                                                                   '32KB': 3,
                                                                                   '48KB': 2}}},
+                                   'occupancy_knees_fma_tflops': {'clock_ghz': 2.705,
                                                                   'confidence': 'high',
                                                                   'method': 'a '
                                                                             'single '
                                                                             'fixed '
                                                                             'total '
                                                                             'work; '
                                                                             'the '
                                                                             'cliff '
                                                                             'marks '
                                                                           'above',
                                                                   'units': 'TFLOP/s',
                                                                   'value': {'t1024': {'0KB': 75.5,
+                                                                                      '32KB': 73.71,
+                                                                                      '48KB': 72.69},
+                                                                            't128': {'0KB': 79.72,
                                                                                      '32KB': 60.31,
+                                                                                     '48KB': 45.81},
+                                                                            't256': {'0KB': 78.79,
+                                                                                     '32KB': 78.85,
+                                                                                     '48KB': 72.97}}},
+                                   'smem_bw': {'clock_ghz': 2.705,
                                                'confidence': 'medium',
                                                'method': 'block-resident '
                                                          'read+write '
                                                          'aggregated across '
                                                          'SMs',
                                                'note': 'bank-conflict-light '
+                                                       'access pattern; the '
+                                                       'stride sweep below '
+                                                       'prices the '
+                                                       'conflicted case',
                                                'units': 'GB/s',
+                                               'value': 22244.0},
+                                   'smem_conflict_penalty': {'clock_ghz': 2.705,
+                                                             'confidence': 'high',
+                                                             'method': 'dependent '
+                                                                       'read-FMA-write '
+                                                                       'per '
+                                                                       'thread '
+                                                                       'at '
+                                                                       'warp-lane '
+                                                                       'bank '
+                                                                       'distance '
+                                                                       '`stride`; '
+                                                                       'stride '
+                                                                       '32 '
+                                                                       'puts '
+                                                                       'every '
+                                                                       'lane '
+                                                                       'in '
+                                                                       'one '
+                                                                       'bank',
+                                                             'note': 'the '
+                                                                     'direct '
+                                                                     'conflict '
+                                                                     'measurement '
+                                                                     'that '
+                                                                     'disambiguates '
+                                                                     'a '
+                                                                     'bank-conflict '
+                                                                     'signature '
+                                                                     'from '
+                                                                     'an ILP '
+                                                                     'stall',
+                                                             'units': 'x '
+                                                                      '(time '
+                                                                      'ratio '
+                                                                      'vs '
+                                                                      'stride '
+                                                                      '1)',
+                                                             'value': {'stride_1': 1.0,
+                                                                       'stride_16': 7.13,
+                                                                       'stride_2': 1.07,
+                                                                       'stride_32': 14.08,
+                                                                       'stride_4': 2.04,
+                                                                       'stride_8': 3.91}},
+                                   'transfer_bw': {'clock_ghz': 2.705,
                                                    'confidence': 'high',
                                                    'method': '256 MB torch '
                                                              'copies, '
                                                            'direction of '
                                                            'traffic',
                                                    'units': 'GB/s',
+                                                   'value': {'d2d': 324.0,
+                                                             'd2h_pageable': 7.8,
+                                                             'd2h_pinned': 26.3,
+                                                             'h2d_pageable': 7.6,
                                                              'h2d_pinned': 24.0}}}}

build/torch213-cxx11-cu132-x86_64-linux/metadata.json CHANGED Viewed

@@ -1,9 +1,10 @@
 {
   "name": "metakernel",
-  "id": "_metakernel_cuda_b62a1ce",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
@@ -18,21 +19,20 @@
   "digest": {
     "algorithm": "sha256",
     "files": {
-      "__init__.py": "e/P3LIoxZqzuhgyc26YJRkdLj4OilextyRiU8YbAvIA=",
-      "_metakernel_cuda_b62a1ce.abi3.so": "bOjwYVOPFetFtHJQESI3xXegefPta3xUpf9tlj/wumU=",
-      "_ops.py": "QokZXDYGh+rLEKO/wNDRcMkJPtPWK568RiTlCHopsHM=",
-      "_pinned.py": "4i1FvV3kWanEdFLd9+rGOjHcHDAyOjKnjLt5LUzgASs=",
-      "metakernel/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
-      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
       "dirty": false
     },
     "kernel": {
-      "sha": "b62a1cef64b6e3b2cabf774c82ea7ce61dcac6c0",
       "dirty": false
     }
   }

 {
   "name": "metakernel",
+  "id": "_metakernel_cuda_0b9de42",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],
+  "kernel-depends": [],
   "backend": {
     "type": "cuda",
     "archs": [
   "digest": {
     "algorithm": "sha256",
     "files": {
+      "__init__.py": "lDQ+fJ0JnI3sQGR3UMnDovBbG4ciYBsaFjmgYdKDTKI=",
+      "_metakernel_cuda_0b9de42.abi3.so": "gWGz/krb7I0i7P92UTCta5iT7MpGseZcCTmNdjdQtZI=",
+      "_ops.py": "x88Bkm1nxRli0nIu2u4ztaJopS1IAZWdN9LZPfspJdo=",
+      "_pinned.py": "UyzMniAjfVMIrIbbrSq92KKo5dX5l/GwV3pMVA+eNtM="
     }
   },
   "provenance": {
     "kernel-builder": {
       "version": "0.17.0-dev0",
+      "sha": "2c40e10d3da1392245ee81bd05b55fb3103b2b34",
       "dirty": false
     },
     "kernel": {
+      "sha": "0b9de42fee8a1e52593f2f1f58460c0acc93d7e8",
       "dirty": false
     }
   }

build/torch213-cxx11-cu132-x86_64-linux/metakernel/__init__.py DELETED Viewed

@@ -1,26 +0,0 @@
-import ctypes
-import importlib.util
-import sys
-from pathlib import Path
-from types import ModuleType
-def _import_from_path(file_path: Path) -> ModuleType:
-    # We cannot use the module name as-is, after adding it to `sys.modules`,
-    # it would also be used for other imports. So, we make a module name that
-    # depends on the path for it to be unique using the hex-encoded hash of
-    # the path.
-    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
-    module_name = path_hash
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    if spec is None:
-        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
-    module = importlib.util.module_from_spec(spec)
-    if module is None:
-        raise ImportError(f"Cannot load module {module_name} from spec")
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))