| """Append K/V into a PAGED cache and attend over it -- including the entry just written -- in one |
| kernel, with no launch boundary between the write and the read. |
| |
| Every serving stack does append-then-attend, and almost every one of them does it as two kernels, |
| because a kernel boundary is a free device-wide fence: the append kernel's stores are guaranteed |
| visible to the attention kernel's loads. Fusing the two removes that guarantee, and you have to |
| recreate it yourself -- a release fence after the scattered page write, a grid-wide barrier, an |
| acquire on the other side -- for a store whose address came out of a page table and whose reader is a |
| different block than the writer. |
| |
| The cache is paged and the page table is SHUFFLED, so consecutive logical positions are scattered |
| across the pool: the reader cannot assume anything about locality, and the writer's target page is |
| data-dependent. |
| """ |
|
|
| BODY = r''' |
| def make_weights(cfg, seed=0, device="cuda"): |
| """No projection weights: K and V arrive already computed and already rotated.""" |
| return {} |
| |
| |
| def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"): |
| """A paged K/V pool plus a shuffled page table, already holding `prefill_len` tokens/request.""" |
| g = torch.Generator(device=device).manual_seed(seed + 777) |
| P, n_kv, hd = cfg["page"], cfg["n_kv"], cfg["hd"] |
| per = (max_seq + P - 1) // P |
| npg = batch * per |
| kp = torch.zeros(npg, n_kv, P, hd, device=device, dtype=torch.bfloat16) |
| vp = torch.zeros_like(kp) |
| tab = torch.randperm(npg, device=device, generator=g).view(batch, per).to(torch.int32) |
| |
| t = torch.arange(prefill_len, device=device) |
| pg = tab.to(torch.int64)[:, t // P] # (B, prefill_len) |
| sl = t % P |
| kp[pg, :, sl] = (torch.randn(batch, prefill_len, n_kv, hd, device=device, dtype=torch.float32, |
| generator=g) * 0.5).to(torch.bfloat16) |
| vp[pg, :, sl] = (torch.randn(batch, prefill_len, n_kv, hd, device=device, dtype=torch.float32, |
| generator=g) * 0.5).to(torch.bfloat16) |
| return {"k": kp, "v": vp, "table": tab} |
| |
| |
| def make_step_args(cfg, batch, base_pos, seed, n): |
| """(q, k_new, v_new, pos) per call. `pos` is a (B,) int32 CUDA tensor -- no host scalar needed. |
| |
| `q` is deliberately CORRELATED with `k_new`: in a real model both come from the same hidden state, |
| so a token attends strongly to the position it is itself writing. Here that self term carries about |
| 15% of the softmax mass, which is what makes the appended entry matter to the returned output -- |
| an implementation that attends over 0..pos-1 and forgets the token it just wrote is wrong by |
| ~0.9, not by 1/context. The queries are also scaled so the |
| softmax over the 16k-token context is genuinely peaked rather than a flat average that would wash |
| out any error in the bulk of the cache.""" |
| g = torch.Generator(device="cuda").manual_seed(seed) |
| n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"] |
| rep = n_q // n_kv |
| out = [] |
| for i in range(n): |
| k = (torch.randn(batch, n_kv, hd, device="cuda", dtype=torch.float32, generator=g) * 0.5) |
| v = (torch.randn(batch, n_kv, hd, device="cuda", dtype=torch.float32, generator=g) * 0.5) |
| q = (torch.randn(batch, n_q, hd, device="cuda", dtype=torch.float32, generator=g) * 3.0 |
| + k.repeat_interleave(rep, dim=1) * 3.5) |
| pos = torch.full((batch,), base_pos + i, device="cuda", dtype=torch.int32) |
| out.append((q.to(torch.bfloat16), k.to(torch.bfloat16), v.to(torch.bfloat16), pos)) |
| return out |
| |
| |
| def build_attn(weights, kv_cache, cfg, max_seq_len): |
| """UNTIMED setup. Re-layout the pool, pin the page table, launch a persistent kernel, ...""" |
| return {"kv": kv_cache, "cfg": cfg} |
| |
| |
| @torch.no_grad() |
| def append_attend(handle, q, k_new, v_new, pos): |
| """Write this position's K/V into the paged cache, then attend over 0..pos inclusive. |
| |
| q : (B, n_q, hd) bf16 already rotated queries |
| k_new : (B, n_kv, hd) bf16 already rotated keys for this position |
| v_new : (B, n_kv, hd) bf16 |
| pos : (B,) int32 absolute position to append for each request (all equal here) |
| returns : (out, k_rd, v_rd) -- out (B, n_q*hd) attention INCLUDING the token just appended; |
| k_rd, v_rd (B, n_kv*hd) read back OUT OF THE CACHE at the slot just written |
| """ |
| kvp, cfg = handle["kv"], handle["cfg"] |
| kp, vp, tab = kvp["k"], kvp["v"], kvp["table"].to(torch.int64) |
| P, n_q, n_kv, hd = cfg["page"], cfg["n_q"], cfg["n_kv"], cfg["hd"] |
| B = q.shape[0] |
| p = pos.to(torch.int64) |
| |
| b = torch.arange(B, device=q.device) |
| pg, sl = tab[b, p // P], p % P |
| kp[pg, :, sl] = k_new # scattered append |
| vp[pg, :, sl] = v_new |
| |
| L = int(p.max()) + 1 |
| t = torch.arange(L, device=q.device) |
| pgs, sls = tab[:, t // P], t % P |
| K = kp[pgs, :, sls].permute(0, 2, 1, 3) # (B, n_kv, L, hd) |
| V = vp[pgs, :, sls].permute(0, 2, 1, 3) |
| o = F.scaled_dot_product_attention(q.unsqueeze(2), K, V, enable_gqa=True) |
| return (o.reshape(B, n_q * hd).float(), |
| kp[pg, :, sl].reshape(B, n_kv * hd).float(), |
| vp[pg, :, sl].reshape(B, n_kv * hd).float()) |
| ''' |
|
|
| MODEL_SRC = BODY |
|
|
