"""Spec for `deepseek-v32-sparse-mla-decode` — absorbed MLA decode restricted to an index list, the second half of DeepSeek-V3.2 sparse attention.""" import pathlib import sys sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1])) from spec import TaskSpec SPEC = TaskSpec( name="deepseek-v32-sparse-mla-decode", title="Write a fast sparse MLA decode kernel (attention over an index list)", blurb=("Once DeepSeek-V3.2's indexer has picked the few thousand positions worth attending to, this is " "the kernel that actually attends to them: absorbed Multi-head Latent Attention over an " "arbitrary LIST of cache rows rather than a contiguous history. One latent per selected " "position serves as both key and value for all 128 heads, and the rows are scattered anywhere " "in a multi-gigabyte pool — so unlike dense decode there is no contiguity to exploit at all, " "and the whole problem is turning a random gather into something that still streams."), keywords=["mle", "kernel-generation", "mla", "dsa", "deepseek", "sparse-attention", "latent-attention", "decode", "gather", "kv-cache", "memory-bound"], module="sparse_mla.py", func="sparse_mla_decode", signature="sparse_mla_decode(q, kv_cache, indices, dv, scale=None)", returns_doc="""Absorbed MLA decode over an explicit list of selected cache rows. Args: q: (B, H, DT) bfloat16 — this token's query per head, already absorbed into the latent space; DT = dv + rope width. kv_cache: (NROWS, DT) bfloat16 — the flat latent pool; one vector per cached position, SHARED by all heads: [ latent(dv) | k_rope(DT - dv) ]. indices: (B, K) int32 — the K cache rows selected for request b, in ARBITRARY order. dv: int — width of the latent (value) part; the trailing DT - dv dims are the decoupled-RoPE key, which scores but is not read out. scale: float or None — logit scale; None means DT ** -0.5. Returns: o: (B, H, dv), bfloat16 or float32 — must match /app/reference.py numerically.""", reference_imports="import torch", reference_src=''' CH = 32 # the reference tiles over requests purely so it FITS; it makes no attempt to be fast def sparse_mla_decode(q, kv_cache, indices, dv, scale=None): """Gather the selected rows and run a dense fp32 softmax over them. Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the gathered (K, DT) block in fp32 for every request and then makes several passes over it; a real kernel reads each selected row ONCE, in bfloat16, straight into registers. The latent is shared by every head (this is MQA with one very wide head), and the SAME vector is both the key (all DT dims score) and the value (its leading dv dims are read out). """ B, H, DT = q.shape if scale is None: scale = DT ** -0.5 o = torch.empty(B, H, dv, device=q.device, dtype=torch.float32) for b0 in range(0, B, CH): b1 = min(b0 + CH, B) kv = kv_cache[indices[b0:b1].long()].float() # (b, K, DT) the selected rows s = torch.einsum("bhd,bkd->bhk", q[b0:b1].float() * scale, kv) # FULL DT-wide dot product p = torch.softmax(s, dim=-1) # no mask: every slot is selected o[b0:b1] = torch.einsum("bhk,bkd->bhd", p, kv[:, :, :dv]) # value = the LATENT part only return o.to(torch.bfloat16) ''', make_inputs_src=''' def _mk(B, K, H, DV, DR, NROWS, seed): """A latent pool plus K DISTINCT selected rows per request, scattered over the whole pool. The selection is stratified (one row from each of K equal buckets) so the indices are distinct without a sort, and then randomly permuted, so the kernel sees them in arbitrary order — which is what the indexer's top-k actually produces. """ gen = torch.Generator(device="cuda").manual_seed(seed) DT = DV + DR q = torch.randn(B, H, DT, device="cuda", dtype=torch.bfloat16, generator=gen) kv_cache = (torch.randn(NROWS, DT, device="cuda", generator=gen) * DT ** -0.25).to(torch.bfloat16) stride = NROWS // K base = (torch.arange(K, device="cuda") * stride).view(1, K) off = (torch.rand(B, K, device="cuda", generator=gen) * stride).long() idx = base + off # distinct by construction order = torch.rand(B, K, device="cuda", generator=gen).argsort(dim=-1) indices = idx.gather(1, order).to(torch.int32) # arbitrary order return q, kv_cache, indices, DV, None ''', flops_src=''' def canonical_work(B, K, H, DV, DR, NROWS): """BYTES attributed to one sparse MLA decode step, from the SHAPE ALONE. Sparse decode is memory bound, so work is counted as the unavoidable HBM traffic: the B*K SELECTED latent rows read EXACTLY ONCE, in native bfloat16, DT = DV + DR elements each. Note there is only ONE such read: in MLA the key and the value are the same latent, so unlike ordinary attention there is no second pass for V, and all H heads share the row. The query and the output are included; the index list is 4 bytes per selected row. """ DT = DV + DR return 2 * DT * B * K + 4 * B * K + 2 * B * H * DT + 2 * B * H * DV ''', flops_formula=("DT = DV + DR\n" "bytes = 2*DT*B*K + 4*B*K + 2*B*H*DT + 2*B*H*DV\n" "# selected rows indices query output"), metric="GB/s", compare="tensor", tol=7e-3, # MEASURED: 2.05x the 3.41e-3 worst gap to an independent online-softmax implementation shape_names=("B", "K", "H", "DV", "DR", "NROWS"), grader_shapes=[(768, 2048, 128, 512, 64, 1048576), (512, 4096, 128, 512, 64, 1048576), (1024, 2048, 128, 512, 64, 1048576), (768, 3072, 128, 512, 64, 1048576), (640, 2048, 64, 512, 64, 786432)], measure_shapes=[(704, 2048, 128, 512, 64, 1048576), (448, 4096, 128, 512, 64, 1048576), (896, 2048, 128, 512, 64, 1048576), (704, 3072, 128, 512, 64, 1048576), (576, 2048, 64, 512, 64, 786432)], measure_quick_shapes=[(64, 1024, 64, 512, 64, 131072), (128, 512, 32, 512, 64, 65536), (32, 2048, 128, 512, 64, 131072)], correct_shapes=[(5, 256, 8, 128, 32, 4096), (3, 129, 16, 256, 64, 2048), (7, 512, 4, 512, 64, 8192), (2, 64, 32, 128, 32, 1024)], spec_md="""This is the second half of DeepSeek-V3.2's sparse attention: the indexer has already chosen `K` cache rows per request, and this kernel attends over exactly those. ``` kv[b, j, :] = kv_cache[ indices[b, j], : ] # (B, K, DT), an arbitrary gather s[b, h, j] = ( q[b, h, :] . kv[b, j, :] ) * scale # scale = DT**-0.5 when scale is None p = softmax(s, over j) # every selected slot is valid: no mask o[b, h, :] = sum_j p[b, h, j] * kv[b, j, :dv] # read out the LATENT part only ``` Three things follow from Multi-head Latent Attention that make this different from a sparse-gather attention on ordinary K/V: * **The key and the value are the same tensor.** One row of the cache is scored in full (`DT` dims, latent *and* decoupled-RoPE key) and then read out in part (its first `dv` dims). There is no second tensor to fetch, so the byte count credits exactly one read per selected row. * **Every head shares the row.** This is MQA with one very wide head: `q` has `H` heads but the cache has none, so a row that is loaded once serves all `H` dot products and all `H` accumulations. * **The rows are anywhere.** `indices[b]` is what a top-k produced: `K` distinct rows in arbitrary order, scattered across a pool of `NROWS`. There is no page structure and no contiguity to lean on. `indices` contains no padding and no `-1` — every slot is a real selected row — so there is nothing to mask. `/app/reference.py` gathers each request's `(K, DT)` block into fp32 and runs a dense softmax over it. That is the exact specification; it is deliberately simple rather than fast.""", contract_md="""| arg | shape | dtype | meaning | |-----|-------|-------|---------| | `q` | `(B, H, DT)` | `bfloat16` | absorbed query per head; `DT = dv + DR` | | `kv_cache` | `(NROWS, DT)` | `bfloat16` | flat latent pool, `[ latent(dv) \\| k_rope(DR) ]` per row | | `indices` | `(B, K)` | `int32` | the `K` selected rows of request `b`, **arbitrary order**, distinct | | `dv` | int | | width of the latent part read out | | `scale` | float or `None` | | logit scale; `None` means `DT ** -0.5` | **Return** a single tensor `o` of shape `(B, H, dv)`, bfloat16 or float32 (the grader compares in fp32). All inputs are **read-only**. `K` is **not** guaranteed to be a multiple of any tile size — the correctness shapes include `K = 129` — and `B` is small and ragged (3, 5, 7 appear).""", regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `B` (concurrent requests) in 512–1024, `K` (selected rows per request) in 2048–4096, `H` in 64–128, `dv` = 512, `DR` = 64 (so `DT` = 576), and a pool `NROWS` of 786432 to 1048576 rows (0.9–1.2 GB). Between 1 and 2.5 GiB of latent is gathered per call — that gather is the entire kernel, and the arithmetic on top of it (`2*H*DT` FLOPs per row at `H = 128`) still leaves it firmly bandwidth-bound.""", correctness_md="""The returned tensor must match the reference (evaluated in fp32) within **relative Frobenius error `7e-3`** at every graded shape, including the timed ones. That gate is **measured**, and the shortcuts this shape invites miss it by orders of magnitude: scoring only the latent part and ignoring the trailing decoupled-RoPE dimensions of the key scores **0.063** (9x the tolerance — the RoPE part is only 64 of 576 dims, so this is the tightest ablation here and the first place to look if you are off by a few percent), and ignoring `indices` to read the first `K` rows of the pool scores **1.2**, 174x the tolerance.""", perf_md="""A random gather of 1–2.5 GiB with a softmax on top. Everything is decided by how well the gather streams. **One row, all heads, once.** Each selected row is 1152 bytes at the graded shapes — nine 128-byte sectors, perfectly coalesced *within* a row and completely unrelated to the next one. Load it once into registers or shared memory and use it for all `H` dot products *and* for the `p @ v` accumulation. A kernel that makes a scoring pass and then a second value pass reads the pool twice and halves its score; the fix is an online (flash-decoding) softmax that keeps a running max, a running sum, and an accumulator so one visit per row suffices. **`H = 128` heads share one 576-wide row.** That is 128 dot products of length 576 per loaded row, i.e. plenty of arithmetic to hide the latency of an irregular load — but only if you have enough rows in flight. Deep unrolling and multi-stage prefetch (async copy / TMA-style) on the index list is what turns a dependent gather into a stream. **Sorting is allowed and can pay.** The indices arrive in arbitrary order; nothing in the contract depends on the order in which you visit them, only on the mathematical result. Rows that happen to be near each other in the pool share DRAM pages, so a per-request sort (or a partial bucketing) can measurably improve locality — weigh it against its own cost. **Split-K for occupancy.** `B*H` is large but `B` alone is only in the hundreds, so a one-block-per-request grid under-fills the machine. Partition the index list across blocks and merge partial `(o, m, l)` triples with the standard log-sum-exp combine. The output is `(B, H, dv)` — up to a hundred megabytes — so make its write vectorised, and note that `q` at `(B, H, DT)` is read once and is small enough to stay resident per request.""", precision_md="""The cache and the query are **bfloat16**; the output may be bf16 or fp32. Accumulate the logits, the online softmax and the `p @ v` product in **fp32**, and merge split-K partials in fp32. `K` reaches 4096, so a bf16 accumulator over the value axis would lose the tail of the sum and produce an error that *grows* with `K` — which the faithfulness clause below rejects. **fp8 is not appropriate here**: the latent arrives in bf16 and re-quantising it on the fly is an approximation of the specified computation rather than an implementation of it. **Where the tolerance comes from.** `6e-3` is measured. A second, independent implementation — the rows gathered per request instead of per batch chunk, the scoring done as a bf16 tensor-core matmul with fp32 accumulate, an online softmax processing the index list in 256-row blocks (a completely different reduction order from the reference's dense one), and the output kept in bf16 — differs from this fp32 reference by a worst relative Frobenius error of **3.41e-3** across the correctness shapes and a full-size graded shape, over several seeds. The tolerance is **2.05x** that, and the error does not grow with `K` (3.17e-3 at `K = 2048`, 3.41e-3 at `K = 129`) — it is the bf16 rounding of the operands and of the returned tensor.""", ).validate()