Keep per-shape definitions and complete mask-free attention curation

Restore per-shape definitions, workloads, tensor paths, configs, solutions
and figures while retaining curated workloads, imported contest GDN tasks,
SGLang wrappers and KDA configs.

Fix both per-shape FA4 baselines after removing the mask input. Make LTX
capture verify an all-visible mask before omitting it. Document the GDN
contracts and retained engine-interface adapters accurately.

Validation: native checks pass all 21 definitions, 1104 workloads and 5506
tensors; repository metadata and 14 capture cases pass; both FA4 baselines
pass all 20 dev workloads on B300 against the independent reference.

README.md

@@ -9,11 +9,11 @@ tags:
 ---
 # Inference Kernels
 
-13 [FlashInfer Trace](https://github.com/flashinfer-ai/flashinfer-bench/tree/main/docs/flashinfer-trace) operator definitions, one per operator except for the empty-prefix case of block-causal attention, with self-contained PyTorch references, open-source baseline solutions, and workloads captured from actual inference: 11 through SGLang, and the 2 gated delta definitions from the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3). Model dimensions are constants, except where one operator serves several model shapes (weight shapes, head dimensions, windows, slot counts); those are runtime axes, like batch sizes, sequence lengths, page sizes, and image grids.
+21 [FlashInfer Trace](https://github.com/flashinfer-ai/flashinfer-bench/tree/main/docs/flashinfer-trace) operator definitions, with self-contained PyTorch references, open-source baseline solutions, and workloads captured from actual inference: 19 through SGLang, and the 2 gated delta definitions from the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3). Model dimensions are constants. Runtime batch sizes, sequence lengths, page sizes, and image grids remain variable.
 
 Every published tensor input references a complete `safetensors` snapshot. Python scalar arguments use scalar descriptors. There are no random-input descriptors or synthetic activation generators. `captures.jsonl` joins each workload UUID to its model revision, request, engine operation, input adaptations, actual outputs, and validation results.
 
-**1,104 real workloads cover all 13 definitions:** 133 Qwen Image, 384 Qwen Flash-Next, 226 DeepSeek, 207 LTX, and 154 Qwen3-Next from the MLSys 2026 contest. The 950 SGLang captures pass complete-output replay; the contest publishes no engine outputs, so its workloads are checked by running the reference. The complete dataset is published at [humanfia-lab/inference-kernels](https://huggingface.co/datasets/humanfia-lab/inference-kernels), including definitions, workloads, capture records, baseline solutions, and tensors. The 5,455 tensor paths contain 5,124 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.
+**1,104 real workloads cover all 21 definitions:** 133 Qwen Image, 384 Qwen Flash-Next, 226 DeepSeek, 207 LTX, and 154 Qwen3-Next from the MLSys 2026 contest. The 950 SGLang captures pass complete-output replay; the contest publishes no engine outputs, so its workloads are checked by running the reference. The complete dataset is published at [humanfia-lab/inference-kernels](https://huggingface.co/datasets/humanfia-lab/inference-kernels), including definitions, workloads, capture records, baseline solutions, and tensors. The 5,506 tensor paths contain 5,124 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.
 
 The dataset was regenerated from full pinned checkpoints through SGLang on NVIDIA B300 GPUs. Definitions, reference code, tolerances, and baseline solutions are unchanged, apart from the [curation](#curation) for kernels that real inference uses.
 
@@ -23,23 +23,23 @@ BF16, FP16, FP32, and FP64 mean 16-bit Brain Floating Point, IEEE half precision
 
 | Family | Model | Fixed dimensions | Definitions | Workloads |
 |---|---|---|---:|---:|
-| Dense matrix multiplication | Qwen Image 2.1 Turbo | `(N,K)`: `(4096,4096)`, `(12288,4096)`, `(4096,12288)`; `M >= 4096` | 1 | 93 |
-| Grouped expert matrix multiplication | DeepSeek V4.1 Flash | 384 experts; `(N,K)`: `(4608,5120)`, `(5120,2304)`; FP8 × FP4 | 1 | 104 |
+| Dense matrix multiplication | Qwen Image 2.1 Turbo | `(N,K)`: `(4096,4096)`, `(12288,4096)`, `(4096,12288)`; `M >= 4096` | 3 | 93 |
+| Grouped expert matrix multiplication | DeepSeek V4.1 Flash | 384 experts; `(N,K)`: `(4608,5120)`, `(5120,2304)`; FP8 × FP4 | 2 | 104 |
 | Mixed-format latent attention | DeepSeek V4.1 Flash | 64 heads × 512 dimensions; 128 FP8 window slots and 512 FP4 compressed slots | 1 | 42 |
-| Sparse multi-head latent attention (MLA), prefill | DeepSeek V4.1 Flash | 64 query heads × 512 dimensions; 1 shared key/value head; BF16; 128 or 640 slots | 1 | 30 |
+| Sparse multi-head latent attention (MLA), prefill | DeepSeek V4.1 Flash | 64 query heads × 512 dimensions; 1 shared key/value head; BF16; separate 128-slot and 640-slot definitions | 2 | 30 |
 | Gated delta recurrence | Qwen3-Next (MLSys 2026 contest) | 4 query/key heads, 8 value heads (TP=4 shard), dimension 128; k-last state; prefill and decode | 2 | 154 |
-| Noncausal dense attention | LTX-2.5 | 32 heads; dimension 128 (video) or 64 (audio); no mask | 1 | 162 |
+| Noncausal dense attention | LTX-2.5 | Video: 32 heads × 128; audio: 32 heads × 64; no mask | 2 | 162 |
 | Qwen sparse attention | Qwen 3.8 Flash-Next | 24 query heads, 2 key/value heads, dimension 256; 512 four-token blocks | 1 | 192 |
 | Prefix-cached block-causal attention | Qwen Image 2.1 Turbo | 32 heads × 128; empty-prefix and cached-prefix cases | 2 | 40 |
 | Sparse index scoring and selection | Qwen 3.8 Flash-Next | 4 query heads × 128; Top-512 complete four-token blocks | 1 | 192 |
 | Expert router | DeepSeek V4.1 Flash | Hidden dimension 5120, 384 experts, Top-6 selection | 1 | 50 |
-| Three-dimensional neighborhood attention | LTX-2.5 diffusion decoder | Dimension 64; `(heads, window)`: `(32,3×7×7)`, `(16,3×7×7)`, `(8,3×5×5)`, `(4,11×11×11)`; the window is an input | 1 | 45 |
+| Three-dimensional neighborhood attention | LTX-2.5 diffusion decoder | Dimension 64; `(heads, window)`: `(32,3×7×7)`, `(16,3×7×7)`, `(8,3×5×5)`, `(4,11×11×11)` | 4 | 45 |
 
-**[Shape distribution histograms for all 13 kernels](docs/shape-distributions/README.md)** show how the 1,104 workloads are distributed across exact runtime shapes. Each bar counts captured workloads with the same complete combination of variable dimensions; fixed model dimensions are listed above the plot. These counts describe this dataset, not AgentX traffic frequencies. Regenerate the figures with `python scripts/plot_shape_distributions.py` (requires Matplotlib; no GPU or tensor files needed).
+**[Shape distribution histograms for all 21 kernels](docs/shape-distributions/README.md)** show how the 1,104 workloads are distributed across exact runtime shapes. Each bar counts captured workloads with the same complete combination of variable dimensions; fixed model dimensions are listed above the plot. These counts describe this dataset, not AgentX traffic frequencies. Regenerate the figures with `python scripts/plot_shape_distributions.py` (requires Matplotlib; no GPU or tensor files needed).
 
 Definitions describe complete logical operators. Captures preserve all model heads and experts; distributed shards must be gathered before publication. Backend padding, layout changes, and page remapping are recorded explicitly. Cache snapshots retain every referenced page, including its unused tail; unreachable allocator pages are omitted. Tensor strides are normalized to contiguous storage without changing values.
 
-The gated delta definitions are the MLSys 2026 contest's: raw Q/K/V with the gate inputs `A_log`, `a`, `dt_bias` and `b`, and the k-last state layout `[sequence, value head, value dimension, key dimension]` that serving engines keep. Prefill takes variable-length sequences through `cu_seqlens`.
+The gated delta definitions are the MLSys 2026 contest's: Q/K/V with the gate inputs `A_log`, `a`, `dt_bias` and `b`, and the k-last state layout `[sequence, value head, value dimension, key dimension]`. Prefill takes variable-length sequences through `cu_seqlens`. These are unchanged Qwen3-Next TP=4 contest contracts, not a layout conversion of the removed Qwen Flash-Next captures. Their references do not perform Q/K L2 normalization, and they accept per-batch states rather than the original SGLang state pool and slot indices.
 
 Quantized byte carriers use `int8` because the trace schema lacks unsigned-byte and exponent-only scale types. The byte patterns remain unchanged. Grouped matrix multiplication uses logical scale layouts with one scale per 32 K elements. Mixed attention preserves the engine's physical pages: each page stores all payload rows followed by all scale rows. Both cache formats share the softmax denominator, including the zero-value attention sink.
 
@@ -104,7 +104,7 @@ The existing baseline implementations and B200 measurements come from the origin
 
 | Kernels | Open-source implementation |
 |---|---|
-| Dense and grouped matrix multiplication | [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d) |
+| Dense and grouped matrix multiplication | [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM/tree/1fc9c66975ee322d628b3288534ca0e9ce12a64d); selected small dense shapes use [FlashInfer](https://github.com/flashinfer-ai/flashinfer) 0.7.2 CuTe DSL |
 | Sparse MLA prefill and mixed-format MLA decode | [FlashMLA](https://github.com/deepseek-ai/FlashMLA/tree/0f11e178da1f67becb087a324b400854931ec3e3) |
 | Dense, block-causal, and sparse grouped-query attention | [FlashAttention-4](https://github.com/Dao-AILab/flash-attention) 4.0.0b35, with runtime masks or sparse-input adapters |
 | Gated delta recurrence | The MLSys 2026 contest's FlashInfer prefill and decode wrappers, unchanged |
@@ -130,6 +130,8 @@ The runner uses the native Trace builder, validates every output element against
 
 Each SGLang-captured definition also has `solutions/<family>/sglang_<definition>.json`: SGLang's own implementation at the capture commit `684fea8a`, called the way the engine calls it, so that a kernel can be timed against what serving actually runs. The module docstring cites the engine call path. Run these solutions inside the capture image `lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8`. Each module also exposes `prepare(*inputs)`, which does the host-side setup the engine does once (layouts, block masks, workspaces) and returns a zero-argument `launch`; `run(*inputs)` does both.
 
+The SGLang solutions adapt the dataset's independent operator interfaces to the pinned engine implementations. Those adapters include padding, layouts, per-rank calls, metadata and output ordering where needed; their module docstrings describe the boundary. A passing standalone workload does not establish that a candidate can replace an engine call without integration work.
+
 ### KDA acceptance configs
 
 `kda/<definition>.json` is how KDA (Kernel Design Agents) judges a candidate kernel on that definition. The definition's reference is the truth, and the SGLang baseline above is timed live on every workload, with only `launch` timed. The fields are:
@@ -139,16 +141,12 @@ Each SGLang-captured definition also has `solutions/<family>/sglang_<definition>
 
 ## Curation
 
-This revision keeps only kernels that real inference uses, as KDA (Kernel Design Agents) tasks require; a kernel written against a definition should drop into an engine.
+This revision curates inference operator tasks for KDA (Kernel Design Agents). Per-shape definitions, workload files and solution names stay separate; model dimensions remain constant axes. Captured interface adaptations are retained explicitly.
 - **Removed `dense_gemm_bf16_nt_n64_k4096` and `dense_gemm_bf16_nt_n4096_k64`.** These are the image output and input projections: memory-bound 8–45 µs GEMMs that run once per forward.
 - **Removed `grouped_gemm_fp8_fp4_e384_n2304_k5120_g32`.** It was cut from the columns of the concatenated gate/up GEMM; no engine runs a separate gate or up GEMM.
-- **Replaced the gated delta definitions.** `gated_delta_rule_{decode,prefill}_h48_dk128_dv128` gave Q/K pre-repeated to 48 heads and a `[B, H, K, V]` state, which is not an engine's interface. They are replaced by the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3) definitions `gdn_{decode,prefill}_qk4_v8_d128_k_last`, with their workloads and FlashInfer baselines unchanged. Each input tensor is stored in its own content-addressed file. Each receipt records the source workload, plus a check that the reference returns finite outputs of the declared shapes.
+- **Replaced the gated delta definitions.** `gated_delta_rule_prefill_h48_dk128_dv128` pre-repeated 16 Q/K heads to 48; the old decode kept 16 raw Q/K heads and included normalization and gating. Both captures extracted states from the engine pool and transposed them to `[B, H, K, V]`. They are replaced by the [MLSys 2026 FlashInfer contest](https://huggingface.co/datasets/flashinfer-ai/mlsys26-contest/tree/5e832ce88dd1013032b22a0e942979d7d2769cc3) definitions `gdn_{decode,prefill}_qk4_v8_d128_k_last`, with their workloads and FlashInfer baselines unchanged. Each input tensor is stored in its own content-addressed file. Each receipt records the source workload, plus a check that the reference returns finite outputs of the declared shapes.
 - **The three remaining dense GEMMs keep only their `M >= 4096` rows.** The `M <= 32` rows were 11–27 µs launches.
 - **The LTX dense attention definitions drop the dense `[B, H, Nq, Nk]` visibility mask.** It was all True on every captured call (up to 839 MB). On one GPU the engine passes no mask, or an all-visible prompt mask. Replay against the captured engine outputs still passes.
-- **One definition per operator.** The per-shape definitions of an operator are merged into one, in which the shape constants are runtime axes: dense GEMM `N`/`K`, grouped GEMM `N`/`K` (with `K_packed`, `K_groups`), dense attention `D`, neighborhood `H`, and sparse MLA `TopK`. Block-causal attention keeps its empty-prefix definition (`Np = 0`), because FlashInfer Trace requires positive runtime axes; KDA judges the two as one task. The references were identical across shapes. The neighborhood window becomes three scalar inputs (`Kt`, `Ky`, `Kx`), because no tensor shape carries it.
-  - Tensors move to the merged definition's directory; identical snapshots collapse into one path each.
-  - Receipts take the merged definition and axes, and keep the definition they were captured under as `captured_definition`.
-  - The per-shape open-source solutions merge too: one DeepGEMM BF16 solution for every `(N, K)` (the CuTe DSL branch served only the removed `M <= 32` rows); one DeepGEMM grouped solution; FlashAttention 4 without a mask (FP16 for `D = 64`, as before); NATTEN with the window from the inputs; and one FlashMLA solution.
 - **Receipts and tensors.** The receipts of removed workloads are dropped, along with every tensor that nothing references.
 - **Scripts.**
   - `check_workload_inputs.py` evaluates constraints that read inputs, such as `cu_seqlens[-1]`.
@@ -231,7 +229,7 @@ BF16 comparisons use `rtol=0.016, atol=0.005`; FP32 uses `rtol=1e-4, atol=2e-5`;
 
 One complete router workload is excluded from the 279 DeepSeek raw captures: at two rows of a 4,096-row call, FP32 ranking ties produce different expert selections. The original FP32 reference and exact selected-set requirement remain unchanged. This call was also absent from the original dataset. No rows are removed from published tensors. All nine LTX requests pass and are included.
 
-Tensor files are published directly as `blob/workloads/<definition>/<hash>.safetensors` through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 5,455 paths contain 5,124 unique snapshots totaling 146.34 GB (146.41 GB when materialized at every path).
+Tensor files are published directly as `blob/workloads/<definition>/<hash>.safetensors` through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 5,506 paths contain 5,124 unique snapshots totaling 146.34 GB (146.44 GB when materialized at every path).
 
 ```bash
 git clone https://huggingface.co/datasets/humanfia-lab/inference-kernels