"""Spec for `adaptive-sparsity-threshold` — per-row adaptive block threshold + 3D dilation + bit-packing.""" import pathlib import sys sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1])) from spec import TaskSpec SPEC = TaskSpec( name="adaptive-sparsity-threshold", title="Write a fast adaptive block-sparsity threshold + 3D mask dilation kernel", blurb=("Every run-time sparse video attention scheme has to turn a tile-level score estimate into the " "actual bitmap the attention kernel consumes, and a fixed top-k is the wrong tool: heads differ " "wildly in how concentrated they are, so the budget has to ADAPT. The rule that survives is " "per-row and relative — keep every tile within `delta` logits of the row's best — followed by a " "3D DILATION, because a pooled estimate is coarse and the real mass straddles tile boundaries. " "One pass over a multi-gigabyte score map, out comes a packed bitmap, per-row counts and the " "per-head density the scheduler needs."), keywords=["mle", "kernel-generation", "sparse-attention", "video-diffusion", "block-mask", "bitmap", "dilation", "hunyuanvideo", "wan", "mask-build"], module="adaptive_mask.py", func="adaptive_sparsity_mask", signature="adaptive_sparsity_mask(scores, delta, grid)", returns_doc="""Adaptive per-row threshold + 3D dilation of a tile-level attention score map. Args: scores: (B, NH, NT, NT) float32 — tile-level score estimate; scores[b,h,i,j] is query tile i against key tile j. Both axes index the SAME 3D tile grid, raster ordered (f, then h, then w). delta: (NH,) float32 — per-head threshold margin, in logits, below the row maximum. grid: (GF, GH, GW) tuple of int — the 3D tile grid; GF*GH*GW == NT, and NT is a multiple of 8. Returns: (bits, counts, density): bits: (B, NH, NT, NT//8) uint8 — packed keep-mask, LSB-first (bit b of byte w is tile 8*w+b). counts: (B, NH, NT) int32 — number of kept key tiles per row. density: (B, NH) float32 — kept fraction per head = sum(counts) / (NT*NT). `bits` and `counts` are compared EXACTLY; they are the bitmap a sparse attention kernel then runs on.""", reference_imports="import torch", reference_src=''' def adaptive_sparsity_mask(scores, delta, grid): """Adaptive threshold + 3D dilation + bit packing, written as dense boolean tensor algebra in fp32. Correct and simple — it is the numerical SPECIFICATION, not a performance target. It materialises the whole boolean keep-map one (batch, head) at a time and shifts it six ways to dilate. """ B, NH, NT, _ = scores.shape GF, GH, GW = grid dev = scores.device bits = torch.empty(B, NH, NT, NT // 8, device=dev, dtype=torch.uint8) counts = torch.empty(B, NH, NT, device=dev, dtype=torch.int32) pw = (1 << torch.arange(8, device=dev, dtype=torch.int32)) step = max(1, int(6e7) // NT) for b in range(B): for h in range(NH): d = delta[h] for q0 in range(0, NT, step): q1 = min(NT, q0 + step) sc = scores[b, h, q0:q1].float() keep = sc >= (sc.amax(-1, keepdim=True) - d) # adaptive per-ROW threshold rows = torch.arange(q1 - q0, device=dev) keep[rows, torch.arange(q0, q1, device=dev)] = True # a tile always keeps itself k3 = keep.view(-1, GF, GH, GW) dil = k3.clone() # 6-neighbour dilation on the tile grid dil[:, 1:] |= k3[:, :-1] dil[:, :-1] |= k3[:, 1:] dil[:, :, 1:] |= k3[:, :, :-1] dil[:, :, :-1] |= k3[:, :, 1:] dil[:, :, :, 1:] |= k3[:, :, :, :-1] dil[:, :, :, :-1] |= k3[:, :, :, 1:] kk = dil.reshape(-1, NT) counts[b, h, q0:q1] = kk.sum(-1, dtype=torch.int32) bits[b, h, q0:q1] = ((kk.view(-1, NT // 8, 8).to(torch.int32) * pw) .sum(-1).to(torch.uint8)) density = counts.sum(-1, dtype=torch.int64).float() / float(NT * NT) return bits, counts, density ''', make_inputs_src=''' def _mk(B, NH, GF, GH, GW, seed): gen = torch.Generator(device="cuda").manual_seed(seed) NT = GF * GH * GW ff = torch.arange(NT, device="cuda") // (GH * GW) hh = (torch.arange(NT, device="cuda") // GW) % GH ww = torch.arange(NT, device="cuda") % GW # a realistic estimate: energy decays with 3D tile distance, plus per-pair noise dist = ((ff[:, None] - ff[None, :]).abs().float() * 1.6 + (hh[:, None] - hh[None, :]).abs().float() * 0.5 + (ww[:, None] - ww[None, :]).abs().float() * 0.5) scores = torch.randn(B, NH, NT, NT, device="cuda", dtype=torch.float32, generator=gen) scores -= 0.35 * dist delta = _deltas(NH).to("cuda") return scores, delta, (GF, GH, GW) ''', flops_src=''' def _deltas(NH): """Per-head threshold margin, from the SHAPE ALONE: heads differ in how concentrated they are.""" return torch.tensor([1.0 + 1.6 * (h % 7) / 6.0 for h in range(NH)], dtype=torch.float32) def canonical_work(B, NH, GF, GH, GW): """BYTES moved by one call, from the SHAPE ALONE. The score map is read once (4 bytes per entry), the packed bitmap is written once (1 bit per entry), plus the per-row counts and the per-head density. A kernel that reads the map twice -- once for the row max, once for the compare -- moves twice this and scores half. """ NT = GF * GH * GW return B * NH * NT * (4 * NT + NT // 8 + 4) + B * NH * 4 ''', flops_formula=("NT = GF*GH*GW\n" "BYTES = B*NH*NT*(4*NT + NT/8 + 4) + B*NH*4 # read the fp32 map once, write the " "packed bitmap + counts"), metric="GB/s", compare="tuple", tuple_names=("bits", "counts", "density"), tol=1e-4, shape_names=("B", "NH", "GF", "GH", "GW"), grader_shapes=[(2, 24, 11, 15, 16), (3, 40, 7, 15, 16), (3, 24, 13, 12, 16), (2, 32, 9, 16, 18), (4, 24, 8, 15, 16)], measure_shapes=[(2, 24, 11, 15, 14), (3, 40, 7, 12, 16), (2, 24, 13, 12, 16), (2, 32, 9, 14, 16), (4, 16, 8, 15, 16)], measure_quick_shapes=[(1, 8, 5, 8, 16), (2, 6, 4, 10, 12), (1, 12, 6, 6, 16)], correct_shapes=[(1, 4, 3, 4, 8), (2, 3, 5, 4, 6), (1, 6, 4, 5, 8), (1, 2, 7, 3, 8), (2, 4, 3, 5, 16), (1, 5, 2, 4, 10)], spec_md="""`scores[b,h,i,j]` is an upstream estimate of how much attention mass query tile `i` puts on key tile `j`, in logits. Both axes index the same 3D tile grid of `NT = GF*GH*GW` tiles in raster order, so tile id `t` is the grid position `(f, h, w) = (t // (GH*GW), (t // GW) % GH, t % GW)`. For every `(b, h, i)` row, in this order: **1. Adaptive threshold.** Keep key tile `j` iff it is within `delta[h]` of the row's best tile: ``` m = max_j scores[b,h,i,j] keep[j] = ( scores[b,h,i,j] >= m - delta[h] ) ``` This is per **row**, not per head and not per tensor: a row whose mass is spread out keeps many tiles, a peaked row keeps a handful. That is the whole point — the budget adapts. **2. Self.** `keep[i] = True` — a tile always attends to itself, whatever the score says. **3. 3D dilation.** The estimate came from pooled tiles, so it is blurry; every kept tile pulls in its six face-neighbours on the tile grid: ``` out[f,h,w] = keep[f,h,w] | keep[f±1,h,w] | keep[f,h±1,w] | keep[f,h,w±1] ``` Neighbours outside the grid do not exist (**no wrap-around**: `w = GW-1` is *not* adjacent to `w = 0` of the next row of tiles, even though they are adjacent in the raster). The dilation reads the mask from step 2 — it is a single dilation, **not** iterated to a fixed point. **4. Pack.** `bits[b,h,i,w]` holds tiles `8w .. 8w+7`, **LSB first**: bit `(1 << t)` of byte `w` is tile `8w + t`. `counts[b,h,i]` is the popcount of the row *after* dilation. `density[b,h]` is `sum_i counts[b,h,i] / (NT*NT)`. `/app/reference.py` materialises the whole boolean map per `(b, h)` and shifts it six ways. That is the exact specification; it is deliberately simple rather than fast.""", contract_md="""| arg | shape | dtype | meaning | |-----|-------|-------|---------| | `scores` | `(B, NH, NT, NT)` | `float32` | tile-level score estimate, query-tile major | | `delta` | `(NH,)` | `float32` | per-head margin below the row max; a **device** tensor | | `grid` | `(GF, GH, GW)` | tuple of int | tile grid, `GF*GH*GW == NT` | **Return** a 3-tuple `(bits, counts, density)` **in that order**: | out | shape | dtype | notes | |-----|-------|-------|-------| | `bits` | `(B, NH, NT, NT//8)` | `uint8` | packed keep-mask, LSB-first; compared **exactly** | | `counts` | `(B, NH, NT)` | `int32` | kept tiles per row, after dilation; compared **exactly** | | `density` | `(B, NH)` | `float32` | `sum_i counts[b,h,i] / (NT*NT)` | `NT` is always a multiple of 8 but **not** of 32, and `GW` is not always a power of two. `scores` is read-only and contiguous; all tensors are CUDA. The score map is the big object here — it is up to 1.3 GB and it is `float32` on purpose (see Precision). `bits` and `counts` must be **exactly** right: they are consumed by a block-sparse attention kernel, where one flipped bit is a missing or a phantom tile.""", regime_md="""**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): tile grids of `NT` 1700-2900 tiles (`GF` 7-13 temporal by `GH` 12-16 by `GW` 14-18 — a 33x45x80 HunyuanVideo latent cut into ~45-token tiles, or a 21x45x80 Wan latent), `NH` 20-40 heads, `B` 2-4. That is a **1.0-1.4 GiB score map per call**, and the output is 1/32 of it. This is a pure bandwidth kernel with nothing to hide behind: the floor is that ~1.3 GB divided by your device's achieved HBM bandwidth. Everything that matters is whether you read the map exactly **once**.""", correctness_md="""`bits` and `counts` are compared **element-exactly** — one wrong bit anywhere fails. `density` must be within relative Frobenius error `1e-4`. All of this is checked at every graded shape, including the timed ones.""", perf_md="""**One row fits in shared memory.** A row is `NT` floats — 7-12 KB. Load it once, reduce for the max, threshold, dilate and pack entirely on chip. The two-pass shape (one kernel for the row max, another to compare) reads 1.3 GB twice and can never beat half the achievable score. **Vectorise the load.** `float4` (128-bit) loads of a contiguous row are the difference between roughly half of achievable HBM bandwidth and most of it. `NT` is a multiple of 8 but not of 32, so handle the tail explicitly rather than padding the whole row. **The dilation is three shifts, not six.** `out = keep | shift_w(±1) | shift_h(±GW) | shift_f(±GH*GW)` — in a warp-per-row layout the `w` neighbours are `__shfl_up`/`__shfl_down` of the same lane's bits, and the `h` and `f` neighbours are a fixed lane offset away. If you keep the row as one bit per bit-position in registers, the whole dilation is a handful of shifts and ORs on 32-bit words plus the boundary fixups (**no wrap** at `w = GW-1`, `h = GH-1`, `f = GF-1`). **Popcount is free** once the row is packed: `__popc` on the packed words, warp-reduce, one `int32` store. **`density` is a second, tiny reduction** over `NT` counts per head. Do not launch a whole extra pass over `scores` for it — reduce the counts you already produced, with an atomic add per row or a small second kernel over the `(B, NH, NT)` count array. **Occupancy:** `B*NH*NT` rows is 100k-300k independent rows, so one CTA (or one warp) per row is plenty of parallelism. The interesting question is how few bytes per row you can touch.""", precision_md="""`scores` is **float32** and the threshold comparison must be done **in float32**: `keep = (score >= rowmax - delta[h])` with `rowmax` the exact fp32 maximum of the row. This is not decoration. `rowmax - delta` is a single fp32 operation on values you were given exactly, so every faithful implementation gets bit-identical decisions. Rounding the row max or the difference to bf16/fp16 moves the threshold by up to ~0.03 logits, which flips the tiles that sit near it — and with hundreds of millions of entries, some always do. The output is compared exactly, so a flipped tile is a failure, not a rounding error. `counts` is the popcount **after** dilation, and `density` divides by `NT*NT` exactly. Accumulate the counts as integers; an fp32 running sum of hundreds of thousands of small integers is still exact here, but there is no reason to risk it. There is no low-precision arithmetic anywhere in this kernel: the tolerance exists only for `density`.""", ).validate() # --------------------------------------------------------------------------------------------------- ALT_SRC = ''' def _alt(scores, delta, grid): """Independent impl: row-blocked, dilation via index gathers instead of shifted slices, packing via matmul. Used only to check that two correct implementations agree bit-exactly.""" B, NH, NT, _ = scores.shape GF, GH, GW = grid dev = scores.device t = torch.arange(NT, device=dev) f, h, w = t // (GH * GW), (t // GW) % GH, t % GW nb = [t] for dd, lim, stride in ((f, GF, GH * GW), (h, GH, GW), (w, GW, 1)): for s in (-1, 1): ok = ((dd + s) >= 0) & ((dd + s) < lim) nb.append(torch.where(ok, t + s * stride, t)) bits = torch.empty(B, NH, NT, NT // 8, device=dev, dtype=torch.uint8) counts = torch.empty(B, NH, NT, device=dev, dtype=torch.int32) for b in range(B): for h_ in range(NH): keep = scores[b, h_] >= (scores[b, h_].max(-1, keepdim=True).values - delta[h_]) keep[t, t] = True dil = torch.zeros_like(keep) for src in nb: # out[j] |= keep[neighbour of j] (symmetric relation) dil |= keep[:, src] counts[b, h_] = dil.sum(-1, dtype=torch.int32) pk = torch.zeros(NT, NT // 8, device=dev, dtype=torch.int32) for i in range(8): pk |= dil.view(NT, NT // 8, 8)[:, :, i].int() << i bits[b, h_] = pk.to(torch.uint8) density = counts.sum(-1, dtype=torch.int64).float() / float(NT * NT) return bits, counts, density ''' DROP_SRC = ''' def _drop(scores, delta, grid): """Drop-the-feature: skip the 3D dilation.""" B, NH, NT, _ = scores.shape dev = scores.device t = torch.arange(NT, device=dev) bits = torch.empty(B, NH, NT, NT // 8, device=dev, dtype=torch.uint8) counts = torch.empty(B, NH, NT, device=dev, dtype=torch.int32) pw = (1 << torch.arange(8, device=dev, dtype=torch.int32)) for b in range(B): for h_ in range(NH): keep = scores[b, h_] >= (scores[b, h_].amax(-1, keepdim=True) - delta[h_]) keep[t, t] = True counts[b, h_] = keep.sum(-1, dtype=torch.int32) bits[b, h_] = (keep.view(NT, NT // 8, 8).to(torch.int32) * pw).sum(-1).to(torch.uint8) density = counts.sum(-1, dtype=torch.int64).float() / float(NT * NT) return bits, counts, density ''' DROP2_SRC = ''' def _drop2(scores, delta, grid): """Second drop check: one GLOBAL threshold per head instead of the per-row adaptive one.""" B, NH, NT, _ = scores.shape GF, GH, GW = grid dev = scores.device t = torch.arange(NT, device=dev) bits = torch.empty(B, NH, NT, NT // 8, device=dev, dtype=torch.uint8) counts = torch.empty(B, NH, NT, device=dev, dtype=torch.int32) pw = (1 << torch.arange(8, device=dev, dtype=torch.int32)) for b in range(B): for h_ in range(NH): keep = scores[b, h_] >= (scores[b, h_].max() - delta[h_]) keep[t, t] = True k3 = keep.view(NT, GF, GH, GW) dil = k3.clone() dil[:, 1:] |= k3[:, :-1] dil[:, :-1] |= k3[:, 1:] dil[:, :, 1:] |= k3[:, :, :-1] dil[:, :, :-1] |= k3[:, :, 1:] dil[:, :, :, 1:] |= k3[:, :, :, :-1] dil[:, :, :, :-1] |= k3[:, :, :, 1:] kk = dil.reshape(NT, NT) counts[b, h_] = kk.sum(-1, dtype=torch.int32) bits[b, h_] = (kk.view(NT, NT // 8, 8).to(torch.int32) * pw).sum(-1).to(torch.uint8) density = counts.sum(-1, dtype=torch.int64).float() / float(NT * NT) return bits, counts, density '''