Remove selected validation and provenance files

Delete the two standalone deployment validators, validation reports and provenance files. Retain component README and benchmark results, and clean obsolete documentation links and commands.

Files changed (10) hide show

PRECISION_ANALYSIS.md +1 -2
README.md +2 -4
gdn/README.md +5 -9
gdn/provenance.json +0 -26
gdn/validate.py +0 -126
gdn/validation_results.json +0 -112
kda/README.md +5 -9
kda/provenance.json +0 -26
kda/validate.py +0 -126
kda/validation_results.json +0 -112

PRECISION_ANALYSIS.md CHANGED Viewed

@@ -268,8 +268,7 @@ than a long chain of each implementation's own outputs.
 - Unmodified TileLang baselines: [GDN](gdn/baseline.py), [KDA](kda/baseline.py).
 - Released CuTe sources: [GDN](build/torch-cuda/_gdn.py), [KDA](build/torch-cuda/_kda.py).
 - Matched measurements: [GDN](gdn/precision_comparison.json), [KDA](kda/precision_comparison.json).
-- Earlier deployment validation: [GDN](gdn/validation_results.json), [KDA](kda/validation_results.json).
-- Source hashes and provenance: [GDN](gdn/provenance.json), [KDA](kda/provenance.json).
 Using the pinned [dependencies](requirements.txt), run on an idle B300:

 - Unmodified TileLang baselines: [GDN](gdn/baseline.py), [KDA](kda/baseline.py).
 - Released CuTe sources: [GDN](build/torch-cuda/_gdn.py), [KDA](build/torch-cuda/_kda.py).
 - Matched measurements: [GDN](gdn/precision_comparison.json), [KDA](kda/precision_comparison.json).
+- Source hashes and release details: [GDN](gdn/README.md#files-and-provenance), [KDA](kda/README.md#files-and-provenance).
 Using the pinned [dependencies](requirements.txt), run on an idle B300:

README.md CHANGED Viewed

@@ -52,8 +52,8 @@ The `main` and `v1` branches both contain the complete release. `v1` is the
 version loaded above. The runtime sources are `build/torch-cuda/_gdn.py` and
 `build/torch-cuda/_kda.py`; metadata, the public import wrapper and the runtime
 license are alongside them. Each component directory contains its README,
-original workload, benchmark, baseline and reference definition, plus validation
-and provenance. Dependency pins and Apache-2.0 licensing are shared at the root.
 ## Precision
@@ -76,10 +76,8 @@ cd leapquant-kernels
 python -m pip install -r requirements.txt
 cd gdn
 python benchmark.py --impl ../build/torch-cuda/_gdn.py
-python validate.py
 cd ../kda
 python benchmark.py --impl ../build/torch-cuda/_kda.py
-python validate.py
 ```
 Run `python benchmark.py` in either component directory for the original

 version loaded above. The runtime sources are `build/torch-cuda/_gdn.py` and
 `build/torch-cuda/_kda.py`; metadata, the public import wrapper and the runtime
 license are alongside them. Each component directory contains its README,
+original workload, benchmark, baseline and reference definition, plus benchmark
+and precision results. Dependency pins and Apache-2.0 licensing are shared at the root.
 ## Precision
 python -m pip install -r requirements.txt
 cd gdn
 python benchmark.py --impl ../build/torch-cuda/_gdn.py
 cd ../kda
 python benchmark.py --impl ../build/torch-cuda/_kda.py
 ```
 Run `python benchmark.py` in either component directory for the original

gdn/README.md CHANGED Viewed

@@ -84,9 +84,7 @@ be scanning the due flags.
 Construct the pool and perform warmup before CUDA graph capture. Refill the
 window buffers and counters before each new window. Calls use the current CUDA
 stream on the pool's device. Keep the pool, index vector and `q0` buffers alive
-while a graph using their addresses is alive. The supplied `validate.py` checks
-mixed due heads, slot 0, reset/no-op behavior, a non-default stream and graph
-replay with changed input contents.
 ## Accuracy and timing
@@ -127,7 +125,6 @@ python -m pip install torch==2.12.1 --index-url https://download.pytorch.org/whl
 python -m pip install -r ../requirements.txt
 python benchmark.py --impl ../build/torch-cuda/_gdn.py  # six original workloads
 python benchmark.py                                    # original TileLang baseline
-python validate.py                                    # package loader and deployment checks
 ```
 TileLang and `nvcc` on `PATH` are needed only to benchmark the original baseline.
@@ -136,9 +133,8 @@ steady-state timings or perform first-use compilation inside graph capture.
 The unchanged kernel passed all six original workloads (three input families
-each) and deployment checks on B300 before consolidation; the original reports
-are retained in `validation_results.json`. The speedup table retains the paired
-optimization-run measurement, not a new baseline comparison.
 ## Matched precision comparison
@@ -158,14 +154,14 @@ Reproduce from the repository root with `python compare_precision.py gdn`.
 The combined runtime is in `../build/torch-cuda/`; this component's unchanged
 kernel is `_gdn.py`. The files in this directory provide its original
-benchmark, baseline, definition, workloads, results, validation and provenance.
 Shared dependencies and licenses are at the repository root.
 The runtime kernel is byte-for-byte the final accepted submission
 `8f705942197446f4` (SHA-256 `a734b59e75a8c8e870d68280c59c4fe05e9e3d2334c4d7e62d7101c67c9cd9b6`), from a 48-hour KDA experiment
 with GPT 6.1 and Claude Opus 5.5. Request sources are pinned to public commit
 `48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326`. The release adds a public import wrapper, metadata
-and validation scripts; it does not change the kernel algorithm. Apache-2.0;
 see `../LICENSE.txt` and `../NOTICE`.
 ## Available functions

 Construct the pool and perform warmup before CUDA graph capture. Refill the
 window buffers and counters before each new window. Calls use the current CUDA
 stream on the pool's device. Keep the pool, index vector and `q0` buffers alive
+while a graph using their addresses is alive.
 ## Accuracy and timing
 python -m pip install -r ../requirements.txt
 python benchmark.py --impl ../build/torch-cuda/_gdn.py  # six original workloads
 python benchmark.py                                    # original TileLang baseline
 ```
 TileLang and `nvcc` on `PATH` are needed only to benchmark the original baseline.
 The unchanged kernel passed all six original workloads (three input families
+each) and deployment checks on B300 before consolidation. The speedup table
+retains the paired optimization-run measurement, not a new baseline comparison.
 ## Matched precision comparison
 The combined runtime is in `../build/torch-cuda/`; this component's unchanged
 kernel is `_gdn.py`. The files in this directory provide its original
+benchmark, baseline, definition, workloads, benchmark and precision results.
 Shared dependencies and licenses are at the repository root.
 The runtime kernel is byte-for-byte the final accepted submission
 `8f705942197446f4` (SHA-256 `a734b59e75a8c8e870d68280c59c4fe05e9e3d2334c4d7e62d7101c67c9cd9b6`), from a 48-hour KDA experiment
 with GPT 6.1 and Claude Opus 5.5. Request sources are pinned to public commit
 `48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326`. The release adds a public import wrapper, metadata
+and precision comparison tooling; it does not change the kernel algorithm. Apache-2.0;
 see `../LICENSE.txt` and `../NOTICE`.
 ## Available functions

gdn/provenance.json DELETED Viewed

@@ -1,26 +0,0 @@
-{
-  "repo_id": "humanfia-lab/leapquant",
-  "version": 1,
-  "source_url": "https://github.com/NVlabs/kda/pull/10",
-  "source_commit": "48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326",
-  "upstream_sha256": {
-    "baseline.py": "b53f30426a9647e523fc6463a5a8d1ba1a9c0f9a09d83599b10abf631346712f",
-    "benchmark.py": "58c5404386dd121ef7e2dca73c3488c7e23b1e0d16f69e23dc1d33b563d3d62f",
-    "definition.json": "313e8b7d2d7305fb09aaa6771eb6482ee2182567339a4d7c33388e9db68296d7",
-    "workloads.jsonl": "4fb72f317e2eabd9752907e6bd0d4cebc4e9a23c6c48c5a4a95750e13e805145"
-  },
-  "kernel_sha256": "a734b59e75a8c8e870d68280c59c4fe05e9e3d2334c4d7e62d7101c67c9cd9b6",
-  "kernel_git_commit": "06975ceabe46d5122fe76b742f71d1eeb841a9bd",
-  "official_submission_id": "8f705942197446f4",
-  "official_artifact_digest": "8d7d94ad883d3c95960eea61a2b63cb85b9633f900ed26394cb1bd82ccc2ef11",
-  "official_benchmarks_sha": "3ac105d12ef108513555f8eac2a39203c0a18c5af3a8b6f77cb12751274ede75",
-  "official_evaluation_utc": "2026-10-24T10:57:39Z",
-  "experiment_hours": 48,
-  "models": [
-    "codex/gpt-6.1-sol:max",
-    "claude/claude-opus-5-5:max"
-  ],
-  "packaging": "Unmodified accepted kernel; exposed as a module of the combined HF package.",
-  "component": "gdn",
-  "kernel_path": "build/torch-cuda/_gdn.py"
-}

gdn/validate.py DELETED Viewed

@@ -1,126 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Validate the local HF package and caller-owned deployment contract on CUDA."""
-from __future__ import annotations
-import base64
-import hashlib
-import json
-from pathlib import Path
-import torch
-from kernels import get_local_kernel
-import benchmark as bench
-def main() -> None:
-    here = Path(__file__).resolve().parent
-    runtime = here.parent / "build/torch-cuda"
-    metadata = json.loads((runtime / "metadata.json").read_text())
-    for filename, expected in metadata["digest"]["files"].items():
-        actual = base64.b64encode(hashlib.sha256((runtime / filename).read_bytes()).digest()).decode()
-        assert actual == expected, f"digest mismatch: {filename}"
-    op = get_local_kernel(here.parent, trust_remote_code=True).gdn
-    assert all(hasattr(op, name) for name in ("Pool", "flush_inplace", "run"))
-    namespace = {}
-    exec(json.loads((here / "definition.json").read_text())["reference"], namespace)
-    reference = namespace["run"]
-    device = torch.device("cuda")
-    ns = 8
-    pool = op.Pool(ns, device=device)
-    is_kda = hasattr(pool, "gbuf")
-    idx = torch.tensor([0, 7, 2, 5, 1, 3], dtype=torch.int32, device=device)
-    counters = torch.where(torch.arange(ns * 32, device=device).reshape(ns, 32) % 3 == 0, 16, 7).int()
-    selected = torch.zeros(ns, dtype=torch.bool, device=device)
-    selected[idx.long()] = True
-    selected[0] = False
-    due = selected[:, None] & (counters == 16)
-    fields = ["codes", "s_k", "s_v", "uq", "kbuf", "ubuf", "w", "hcnt"] + (["gbuf", "pcum"] if is_kda else ["p"])
-    q0 = torch.empty(128, 4, device=device)
-    def restore(inputs):
-        pool.codes.copy_(inputs[0]); pool.s_k.copy_(inputs[1]); pool.s_v.copy_(inputs[2])
-        pool.uq[..., :128].copy_(inputs[3]); pool.uq[..., 128:].copy_(inputs[4])
-        pool.kbuf.copy_(inputs[5]); pool.ubuf.copy_(inputs[6])
-        if is_kda:
-            pool.gbuf.copy_(inputs[7]); pool.w.copy_(inputs[8]); pool.pcum.copy_(inputs[9])
-        else:
-            pool.w.copy_(inputs[7]); pool.p[..., 0].copy_(inputs[8])
-        pool.hcnt.copy_(counters)
-        q0.copy_(inputs[-1])
-    def snapshot():
-        return {name: getattr(pool, name).clone() for name in fields}
-    def verify(inputs, before):
-        ref = reference(*[tensor.clone() for tensor in inputs])
-        actual = (pool.codes, pool.s_k, pool.s_v, pool.uq[..., :128], pool.uq[..., 128:])
-        # Each selected (slot, head) is a separate checked head, never averaged across slots.
-        out = tuple(tensor[due].unsqueeze(0) for tensor in actual)
-        ref = tuple(tensor[due].unsqueeze(0) for tensor in ref)
-        exact = bench.exact_state(inputs)[due].unsqueeze(0)
-        passed, ratio = bench.judge(out, ref, exact)
-        assert passed, f"deployment accuracy failed: {ratio}"
-        for name in fields:
-            assert torch.equal(getattr(pool, name)[~due], before[name][~due]), f"non-due/slot-0 write: {name}"
-        for name in ("kbuf", "ubuf"):
-            assert torch.equal(getattr(pool, name), before[name]), f"update buffer changed: {name}"
-        # The serving contract leaves hcnt at L ("flushed, empty"); the decode
-        # step consumes that sentinel. Clearing it in flush would race scanners.
-        assert torch.equal(pool.hcnt, before["hcnt"]), "flush changed fill counters"
-        assert bool((pool.w[due] == 0).all())
-        if is_kda:
-            assert bool((pool.gbuf[due] == 1).all())
-            assert bool((pool.pcum[due] == 0).all())
-        else:
-            assert bool((pool.p[due] == 1).all())
-        return float(ratio)
-    stream = torch.cuda.Stream()
-    inputs = bench.structured_inputs(ns, device, seed=91)
-    restore(inputs)
-    torch.cuda.synchronize()
-    before = snapshot()
-    torch.cuda.synchronize()
-    with torch.cuda.stream(stream):
-        op.flush_inplace(pool, idx, q0)
-    stream.synchronize()
-    ratios = [verify(inputs, before)]
-    before = snapshot()
-    op.flush_inplace(pool, torch.empty(0, dtype=torch.int32, device=device), q0)
-    torch.cuda.synchronize()
-    assert all(torch.equal(getattr(pool, name), before[name]) for name in fields), "empty idx is not a no-op"
-    restore(inputs)
-    torch.cuda.synchronize()
-    graph = torch.cuda.CUDAGraph()
-    with torch.cuda.graph(graph, stream=stream):
-        op.flush_inplace(pool, idx, q0)
-    for seed in (92, 93):
-        inputs = bench.structured_inputs(ns, device, seed=seed)
-        # structured_inputs always uses the same q0; vary it explicitly here.
-        generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = (*inputs[:-1], torch.randn(128, 4, device=device, generator=generator))
-        restore(inputs)
-        before = snapshot()
-        torch.cuda.synchronize()
-        graph.replay()
-        torch.cuda.synchronize()
-        ratios.append(verify(inputs, before))
-        # Simulate the caller advancing the counters so no head is due.
-        pool.hcnt[due] = 0
-        after = snapshot()
-        torch.cuda.synchronize()
-        graph.replay()
-        torch.cuda.synchronize()
-        assert all(torch.equal(getattr(pool, name), after[name]) for name in fields), "replay with no due heads is not a no-op"
-    print(json.dumps({
-        "status": "pass", "gpu": torch.cuda.get_device_name(),
-        "compute_capability": list(torch.cuda.get_device_capability()),
-        "checks": ["runtime digests", "HF get_local_kernel", "mixed due heads", "unselected slots", "reserved slot 0", "window resets", "fill counters unchanged", "empty idx", "non-default stream", "graph capture", "graph replay with changed inputs and q0", "no-op replay with no due heads"],
-        "deployment_worst_head_error_ratios": ratios,
-    }, indent=2))
-if __name__ == "__main__":
-    main()

gdn/validation_results.json DELETED Viewed

@@ -1,112 +0,0 @@
-{
-  "validated_at_utc": "2026-10-25T20:03:16.823824+00:00",
-  "kernel_sha256": "a734b59e75a8c8e870d68280c59c4fe05e9e3d2334c4d7e62d7101c67c9cd9b6",
-  "deployment": {
-    "status": "pass",
-    "gpu": "NVIDIA B300 SXM6 AC",
-    "compute_capability": [
-      10,
-      3
-    ],
-    "checks": [
-      "runtime digests",
-      "HF get_local_kernel",
-      "mixed due heads",
-      "unselected slots",
-      "reserved slot 0",
-      "window resets",
-      "fill counters unchanged",
-      "empty idx",
-      "non-default stream",
-      "graph capture",
-      "graph replay with changed inputs and q0",
-      "no-op replay with no due heads"
-    ],
-    "deployment_worst_head_error_ratios": [
-      1.0022517222625789,
-      1.0016240993273937,
-      1.0018801265800452
-    ]
-  },
-  "original_benchmark": {
-    "workloads_passed": 6,
-    "input_families_per_workload": 3,
-    "thresholds_modified": false,
-    "workloads": [
-      {
-        "batch_size": 16,
-        "programs": 512,
-        "error_ratios": [
-          1.0004,
-          1.0003,
-          1.0004
-        ],
-        "latency_ms": 0.0121,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 32,
-        "programs": 1024,
-        "error_ratios": [
-          1.0004,
-          1.0002,
-          1.0002
-        ],
-        "latency_ms": 0.0183,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 64,
-        "programs": 2048,
-        "error_ratios": [
-          1.0002,
-          1.0002,
-          1.0002
-        ],
-        "latency_ms": 0.029,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 128,
-        "programs": 4096,
-        "error_ratios": [
-          1.0002,
-          1.0004,
-          1.0001
-        ],
-        "latency_ms": 0.0499,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 256,
-        "programs": 8192,
-        "error_ratios": [
-          1.0001,
-          1.0004,
-          1.0001
-        ],
-        "latency_ms": 0.091,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 512,
-        "programs": 16384,
-        "error_ratios": [
-          1.0001,
-          1.0003,
-          1.0001
-        ],
-        "latency_ms": 0.1706,
-        "correctness_passed": true
-      }
-    ]
-  },
-  "environment": {
-    "python": "3.12.13",
-    "torch": "2.12.1+cu130",
-    "cutlass_dsl": "4.6.0",
-    "cuda_bindings": "13.3.1",
-    "kernels": "0.17.2",
-    "huggingface_hub": "2.2.0"
-  }
-}

kda/README.md CHANGED Viewed

@@ -86,9 +86,7 @@ be scanning the due flags.
 Construct the pool and perform warmup before CUDA graph capture. Refill the
 window buffers and counters before each new window. Calls use the current CUDA
 stream on the pool's device. Keep the pool, index vector and `q0` buffers alive
-while a graph using their addresses is alive. The supplied `validate.py` checks
-mixed due heads, slot 0, reset/no-op behavior, a non-default stream and graph
-replay with changed input contents.
 ## Accuracy and timing
@@ -129,7 +127,6 @@ python -m pip install torch==2.12.1 --index-url https://download.pytorch.org/whl
 python -m pip install -r ../requirements.txt
 python benchmark.py --impl ../build/torch-cuda/_kda.py  # six original workloads
 python benchmark.py                                    # original TileLang baseline
-python validate.py                                    # package loader and deployment checks
 ```
 TileLang and `nvcc` on `PATH` are needed only to benchmark the original baseline.
@@ -138,9 +135,8 @@ steady-state timings or perform first-use compilation inside graph capture.
 The unchanged kernel passed all six original workloads (three input families
-each) and deployment checks on B300 before consolidation; the original reports
-are retained in `validation_results.json`. The speedup table retains the paired
-optimization-run measurement, not a new baseline comparison.
 ## Matched precision comparison
@@ -160,14 +156,14 @@ Reproduce from the repository root with `python compare_precision.py kda`.
 The combined runtime is in `../build/torch-cuda/`; this component's unchanged
 kernel is `_kda.py`. The files in this directory provide its original
-benchmark, baseline, definition, workloads, results, validation and provenance.
 Shared dependencies and licenses are at the repository root.
 The runtime kernel is byte-for-byte the final accepted submission
 `e797d585430d45e1` (SHA-256 `2f635896b70d13ddfd76822d711f75c8c3abb4606f0ccd25dd04b583b95b7ec6`), from a 48-hour KDA experiment
 with GPT 6.1 and Claude Opus 5.5. Request sources are pinned to public commit
 `48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326`. The release adds a public import wrapper, metadata
-and validation scripts; it does not change the kernel algorithm. Apache-2.0;
 see `../LICENSE.txt` and `../NOTICE`.
 ## Available functions

 Construct the pool and perform warmup before CUDA graph capture. Refill the
 window buffers and counters before each new window. Calls use the current CUDA
 stream on the pool's device. Keep the pool, index vector and `q0` buffers alive
+while a graph using their addresses is alive.
 ## Accuracy and timing
 python -m pip install -r ../requirements.txt
 python benchmark.py --impl ../build/torch-cuda/_kda.py  # six original workloads
 python benchmark.py                                    # original TileLang baseline
 ```
 TileLang and `nvcc` on `PATH` are needed only to benchmark the original baseline.
 The unchanged kernel passed all six original workloads (three input families
+each) and deployment checks on B300 before consolidation. The speedup table
+retains the paired optimization-run measurement, not a new baseline comparison.
 ## Matched precision comparison
 The combined runtime is in `../build/torch-cuda/`; this component's unchanged
 kernel is `_kda.py`. The files in this directory provide its original
+benchmark, baseline, definition, workloads, benchmark and precision results.
 Shared dependencies and licenses are at the repository root.
 The runtime kernel is byte-for-byte the final accepted submission
 `e797d585430d45e1` (SHA-256 `2f635896b70d13ddfd76822d711f75c8c3abb4606f0ccd25dd04b583b95b7ec6`), from a 48-hour KDA experiment
 with GPT 6.1 and Claude Opus 5.5. Request sources are pinned to public commit
 `48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326`. The release adds a public import wrapper, metadata
+and precision comparison tooling; it does not change the kernel algorithm. Apache-2.0;
 see `../LICENSE.txt` and `../NOTICE`.
 ## Available functions

kda/provenance.json DELETED Viewed

@@ -1,26 +0,0 @@
-{
-  "repo_id": "humanfia-lab/leapquant",
-  "version": 1,
-  "source_url": "https://github.com/NVlabs/kda/pull/10",
-  "source_commit": "48f02e6ba0e98a1841ab6f0a2d99a90b2de1a326",
-  "upstream_sha256": {
-    "baseline.py": "97b4e538674bd5a9310e41c3e7dfa19a9c76314f511acd5f5c29fdce95bfffb5",
-    "benchmark.py": "69e24658f3091c9fdd23873498dcbc6b243ce3816a7480435bd59cd0ef82751d",
-    "definition.json": "f25aac78d32ccc50401e2fb1a56d2c0a3ee27548b5d91f9e4d7e5a7c9d2dc323",
-    "workloads.jsonl": "ee5c437eeca601e5a83f5b3a4c07a6c11822e4e9438487a893ad6668a7075dfe"
-  },
-  "kernel_sha256": "2f635896b70d13ddfd76822d711f75c8c3abb4606f0ccd25dd04b583b95b7ec6",
-  "kernel_git_commit": "61f43860e7a487c9d9cbaccc043f270f2eb8693c",
-  "official_submission_id": "e797d585430d45e1",
-  "official_artifact_digest": "ac983001fb75c5ae2f66b557dcacf40332493853f741d812245839bb7110849d",
-  "official_benchmarks_sha": "3ac105d12ef108513555f8eac2a39203c0a18c5af3a8b6f77cb12751274ede75",
-  "official_evaluation_utc": "2026-10-24T12:38:34Z",
-  "experiment_hours": 48,
-  "models": [
-    "codex/gpt-6.1-sol:max",
-    "claude/claude-opus-5-5:max"
-  ],
-  "packaging": "Unmodified accepted kernel; exposed as a module of the combined HF package.",
-  "component": "kda",
-  "kernel_path": "build/torch-cuda/_kda.py"
-}

kda/validate.py DELETED Viewed

@@ -1,126 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Validate the local HF package and caller-owned deployment contract on CUDA."""
-from __future__ import annotations
-import base64
-import hashlib
-import json
-from pathlib import Path
-import torch
-from kernels import get_local_kernel
-import benchmark as bench
-def main() -> None:
-    here = Path(__file__).resolve().parent
-    runtime = here.parent / "build/torch-cuda"
-    metadata = json.loads((runtime / "metadata.json").read_text())
-    for filename, expected in metadata["digest"]["files"].items():
-        actual = base64.b64encode(hashlib.sha256((runtime / filename).read_bytes()).digest()).decode()
-        assert actual == expected, f"digest mismatch: {filename}"
-    op = get_local_kernel(here.parent, trust_remote_code=True).kda
-    assert all(hasattr(op, name) for name in ("Pool", "flush_inplace", "run"))
-    namespace = {}
-    exec(json.loads((here / "definition.json").read_text())["reference"], namespace)
-    reference = namespace["run"]
-    device = torch.device("cuda")
-    ns = 8
-    pool = op.Pool(ns, device=device)
-    is_kda = hasattr(pool, "gbuf")
-    idx = torch.tensor([0, 7, 2, 5, 1, 3], dtype=torch.int32, device=device)
-    counters = torch.where(torch.arange(ns * 32, device=device).reshape(ns, 32) % 3 == 0, 16, 7).int()
-    selected = torch.zeros(ns, dtype=torch.bool, device=device)
-    selected[idx.long()] = True
-    selected[0] = False
-    due = selected[:, None] & (counters == 16)
-    fields = ["codes", "s_k", "s_v", "uq", "kbuf", "ubuf", "w", "hcnt"] + (["gbuf", "pcum"] if is_kda else ["p"])
-    q0 = torch.empty(128, 4, device=device)
-    def restore(inputs):
-        pool.codes.copy_(inputs[0]); pool.s_k.copy_(inputs[1]); pool.s_v.copy_(inputs[2])
-        pool.uq[..., :128].copy_(inputs[3]); pool.uq[..., 128:].copy_(inputs[4])
-        pool.kbuf.copy_(inputs[5]); pool.ubuf.copy_(inputs[6])
-        if is_kda:
-            pool.gbuf.copy_(inputs[7]); pool.w.copy_(inputs[8]); pool.pcum.copy_(inputs[9])
-        else:
-            pool.w.copy_(inputs[7]); pool.p[..., 0].copy_(inputs[8])
-        pool.hcnt.copy_(counters)
-        q0.copy_(inputs[-1])
-    def snapshot():
-        return {name: getattr(pool, name).clone() for name in fields}
-    def verify(inputs, before):
-        ref = reference(*[tensor.clone() for tensor in inputs])
-        actual = (pool.codes, pool.s_k, pool.s_v, pool.uq[..., :128], pool.uq[..., 128:])
-        # Each selected (slot, head) is a separate checked head, never averaged across slots.
-        out = tuple(tensor[due].unsqueeze(0) for tensor in actual)
-        ref = tuple(tensor[due].unsqueeze(0) for tensor in ref)
-        exact = bench.exact_state(inputs)[due].unsqueeze(0)
-        passed, ratio = bench.judge(out, ref, exact)
-        assert passed, f"deployment accuracy failed: {ratio}"
-        for name in fields:
-            assert torch.equal(getattr(pool, name)[~due], before[name][~due]), f"non-due/slot-0 write: {name}"
-        for name in ("kbuf", "ubuf"):
-            assert torch.equal(getattr(pool, name), before[name]), f"update buffer changed: {name}"
-        # The serving contract leaves hcnt at L ("flushed, empty"); the decode
-        # step consumes that sentinel. Clearing it in flush would race scanners.
-        assert torch.equal(pool.hcnt, before["hcnt"]), "flush changed fill counters"
-        assert bool((pool.w[due] == 0).all())
-        if is_kda:
-            assert bool((pool.gbuf[due] == 1).all())
-            assert bool((pool.pcum[due] == 0).all())
-        else:
-            assert bool((pool.p[due] == 1).all())
-        return float(ratio)
-    stream = torch.cuda.Stream()
-    inputs = bench.structured_inputs(ns, device, seed=91)
-    restore(inputs)
-    torch.cuda.synchronize()
-    before = snapshot()
-    torch.cuda.synchronize()
-    with torch.cuda.stream(stream):
-        op.flush_inplace(pool, idx, q0)
-    stream.synchronize()
-    ratios = [verify(inputs, before)]
-    before = snapshot()
-    op.flush_inplace(pool, torch.empty(0, dtype=torch.int32, device=device), q0)
-    torch.cuda.synchronize()
-    assert all(torch.equal(getattr(pool, name), before[name]) for name in fields), "empty idx is not a no-op"
-    restore(inputs)
-    torch.cuda.synchronize()
-    graph = torch.cuda.CUDAGraph()
-    with torch.cuda.graph(graph, stream=stream):
-        op.flush_inplace(pool, idx, q0)
-    for seed in (92, 93):
-        inputs = bench.structured_inputs(ns, device, seed=seed)
-        # structured_inputs always uses the same q0; vary it explicitly here.
-        generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = (*inputs[:-1], torch.randn(128, 4, device=device, generator=generator))
-        restore(inputs)
-        before = snapshot()
-        torch.cuda.synchronize()
-        graph.replay()
-        torch.cuda.synchronize()
-        ratios.append(verify(inputs, before))
-        # Simulate the caller advancing the counters so no head is due.
-        pool.hcnt[due] = 0
-        after = snapshot()
-        torch.cuda.synchronize()
-        graph.replay()
-        torch.cuda.synchronize()
-        assert all(torch.equal(getattr(pool, name), after[name]) for name in fields), "replay with no due heads is not a no-op"
-    print(json.dumps({
-        "status": "pass", "gpu": torch.cuda.get_device_name(),
-        "compute_capability": list(torch.cuda.get_device_capability()),
-        "checks": ["runtime digests", "HF get_local_kernel", "mixed due heads", "unselected slots", "reserved slot 0", "window resets", "fill counters unchanged", "empty idx", "non-default stream", "graph capture", "graph replay with changed inputs and q0", "no-op replay with no due heads"],
-        "deployment_worst_head_error_ratios": ratios,
-    }, indent=2))
-if __name__ == "__main__":
-    main()

kda/validation_results.json DELETED Viewed

@@ -1,112 +0,0 @@
-{
-  "validated_at_utc": "2026-10-25T20:03:16.828102+00:00",
-  "kernel_sha256": "2f635896b70d13ddfd76822d711f75c8c3abb4606f0ccd25dd04b583b95b7ec6",
-  "deployment": {
-    "status": "pass",
-    "gpu": "NVIDIA B300 SXM6 AC",
-    "compute_capability": [
-      10,
-      3
-    ],
-    "checks": [
-      "runtime digests",
-      "HF get_local_kernel",
-      "mixed due heads",
-      "unselected slots",
-      "reserved slot 0",
-      "window resets",
-      "fill counters unchanged",
-      "empty idx",
-      "non-default stream",
-      "graph capture",
-      "graph replay with changed inputs and q0",
-      "no-op replay with no due heads"
-    ],
-    "deployment_worst_head_error_ratios": [
-      1.00270965549408,
-      1.0036139557099675,
-      1.0016564812747861
-    ]
-  },
-  "original_benchmark": {
-    "workloads_passed": 6,
-    "input_families_per_workload": 3,
-    "thresholds_modified": false,
-    "workloads": [
-      {
-        "batch_size": 16,
-        "programs": 512,
-        "error_ratios": [
-          1.0004,
-          1.0006,
-          1.0011
-        ],
-        "latency_ms": 0.0118,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 32,
-        "programs": 1024,
-        "error_ratios": [
-          1.0004,
-          1.0004,
-          1.0005
-        ],
-        "latency_ms": 0.0181,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 64,
-        "programs": 2048,
-        "error_ratios": [
-          1.0004,
-          1.0003,
-          1.0007
-        ],
-        "latency_ms": 0.0303,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 128,
-        "programs": 4096,
-        "error_ratios": [
-          1.0004,
-          1.0002,
-          1.0004
-        ],
-        "latency_ms": 0.0546,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 256,
-        "programs": 8192,
-        "error_ratios": [
-          1.0002,
-          1.0001,
-          1.0002
-        ],
-        "latency_ms": 0.1024,
-        "correctness_passed": true
-      },
-      {
-        "batch_size": 512,
-        "programs": 16384,
-        "error_ratios": [
-          1.0001,
-          1.0001,
-          1.0002
-        ],
-        "latency_ms": 0.1934,
-        "correctness_passed": true
-      }
-    ]
-  },
-  "environment": {
-    "python": "3.12.13",
-    "torch": "2.12.1+cu130",
-    "cutlass_dsl": "4.6.0",
-    "cuda_bindings": "13.3.1",
-    "kernels": "0.17.2",
-    "huggingface_hub": "2.2.0"
-  }
-}