File size: 6,772 Bytes
0f775e2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | """Llama-shaped decoder whose KV cache is PAGED.
Instead of one contiguous `(B, n_kv, max_seq, hd)` tensor per layer, each layer owns a pool of fixed
size pages and a per-sequence page table maps logical position -> physical page. The pool is twice the
size the batch needs and the pages a sequence owns are deliberately SCATTERED through it, so a kernel
cannot quietly treat the table as the identity and read contiguously; every attention step is a gather
through one level of indirection.
This is how every production serving stack stores KV (vLLM PagedAttention and everything after it),
and it is the single change that makes the attention half of a megakernel hard: the weight stream is
still a static schedule you can prefetch, but the KV addresses only exist after a table lookup.
"""
from model import HELPERS_CORE, QUANT_FP8
BODY = r'''
def make_weights(cfg, seed=0, device="cuda"):
"""Deterministic 1/sqrt(fan_in)-scaled weights. No checkpoint is shipped or downloaded."""
g = torch.Generator(device=device).manual_seed(seed)
d, ffn, n_q, n_kv, hd = cfg["d"], cfg["ffn"], cfg["n_q"], cfg["n_kv"], cfg["hd"]
dt = cfg["wdtype"]
def rnd(*shape, fan_in):
w = torch.randn(*shape, device=device, dtype=torch.float32, generator=g) / (fan_in ** 0.5)
return _quantise(w, dt)
ones = lambda: torch.ones(d, device=device, dtype=torch.bfloat16)
W = {"embed": rnd(cfg["vocab"], d, fan_in=d), "final_norm": ones(), "layers": []}
for _ in range(cfg["layers"]):
W["layers"].append(dict(
in_norm=ones(), post_norm=ones(),
q=rnd(n_q * hd, d, fan_in=d), k=rnd(n_kv * hd, d, fan_in=d),
v=rnd(n_kv * hd, d, fan_in=d), o=rnd(d, n_q * hd, fan_in=n_q * hd),
gate=rnd(ffn, d, fan_in=d), up=rnd(ffn, d, fan_in=d), down=rnd(d, ffn, fan_in=ffn)))
return W
def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"):
"""Paged KV pool + page table.
Returns {"k": [per-layer pool], "v": [...], "page_table": (B, pages_per_seq) int32,
"page_size": int}. Pools are (n_pages, n_kv, page_size, hd) bf16.
The pool is OVERSUBSCRIBED: it holds twice as many pages as this batch needs, and the page table
is a random SELECTION of half of them, so logically adjacent positions are physically scattered
and the pages in between belong to somebody else. `page_table[b, j]` is the physical page holding
logical positions [j*page_size, (j+1)*page_size) of sequence b.
Every page in the pool holds live-looking KV, including the ones this batch does not own. That is
what a real pool looks like (other sequences' pages, and freed pages still holding stale data),
and it is also what makes the indirection GRADEABLE. When the table was a permutation of a pool
that the sequence owned entirely, a kernel that ignored the table and read the pool contiguously
gathered a PERMUTED COPY OF THE SAME KEYS -- and attention is permutation-invariant over the key
axis, so the measured error of that shortcut was 0.087, barely above the 0.028 numerical floor.
With the pool oversubscribed the same shortcut measures 0.76 (see the spec's Precision section)."""
g = torch.Generator(device=device).manual_seed(seed + 777)
ps = cfg["page_size"]
per_seq = (max_seq + ps - 1) // ps
n_pages = 2 * batch * per_seq
sel = torch.randperm(n_pages, device=device, generator=g)[:batch * per_seq].to(torch.int32)
table = sel.view(batch, per_seq).contiguous()
ks, vs = [], []
for _ in range(cfg["layers"]):
k = (torch.randn(n_pages, cfg["n_kv"], ps, cfg["hd"], device=device, dtype=torch.float32,
generator=g) * 0.5).to(torch.bfloat16)
v = (torch.randn(n_pages, cfg["n_kv"], ps, cfg["hd"], device=device, dtype=torch.float32,
generator=g) * 0.5).to(torch.bfloat16)
ks.append(k)
vs.append(v)
return {"k": ks, "v": vs, "page_table": table, "page_size": ps}
def build_model(weights, kv_cache, cfg, max_seq_len):
"""UNTIMED setup. Returns whatever handle you like; the grader only passes it back to decode_step."""
cos, sin = _rope_cache(cfg, max_seq_len, weights["final_norm"].device)
W = {"embed": _deq(weights["embed"]), "final_norm": weights["final_norm"],
"layers": [{k: (v if k.endswith("norm") else _deq(v)) for k, v in L.items()}
for L in weights["layers"]]}
return {"W": W, "kv": kv_cache, "cfg": cfg, "cos": cos, "sin": sin}
def _gather_pages(pool, table, b, n_pos, ps):
"""Logical (n_kv, n_pos, hd) view of sequence b, gathered through the page table."""
npg = (n_pos + ps - 1) // ps
phys = table[b, :npg].long()
g = pool[phys] # (npg, n_kv, ps, hd)
g = g.permute(1, 0, 2, 3).reshape(g.shape[1], npg * ps, g.shape[3])
return g[:, :n_pos]
@torch.no_grad()
def decode_step(handle, token_ids, pos):
"""One decode step for every sequence in the batch. Appends this position's K/V into its page.
token_ids: (B,) int64 pos: int, the absolute position being written
returns: (B, vocab) logits
"""
W, kv, cfg = handle["W"], handle["kv"], handle["cfg"]
cos, sin = handle["cos"], handle["sin"]
B = token_ids.shape[0]
n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"]
rep, ps = n_q // n_kv, kv["page_size"]
table = kv["page_table"]
pg, slot = pos // ps, pos % ps
x = W["embed"][token_ids]
for li, L in enumerate(W["layers"]):
h = _rms_norm(x, L["in_norm"], cfg["eps"])
q = (h @ L["q"].T).view(B, n_q, 1, hd)
k = (h @ L["k"].T).view(B, n_kv, 1, hd)
v = (h @ L["v"].T).view(B, n_kv, 1, hd)
q = _apply_rope(q, cos, sin, pos)
k = _apply_rope(k, cos, sin, pos)
kp, vp = kv["k"][li], kv["v"][li]
outs = []
for b in range(B):
p = int(table[b, pg])
kp[p, :, slot] = k[b, :, 0] # append THIS position into its page
vp[p, :, slot] = v[b, :, 0]
kk = _gather_pages(kp, table, b, pos + 1, ps).unsqueeze(0)
vv = _gather_pages(vp, table, b, pos + 1, ps).unsqueeze(0)
kk = kk.repeat_interleave(rep, dim=1)
vv = vv.repeat_interleave(rep, dim=1)
outs.append(F.scaled_dot_product_attention(q[b:b + 1], kk, vv))
att = torch.cat(outs, dim=0)
x = x + (att.reshape(B, n_q * hd) @ L["o"].T)
h = _rms_norm(x, L["post_norm"], cfg["eps"])
x = x + ((F.silu(h @ L["gate"].T) * (h @ L["up"].T)) @ L["down"].T)
x = _rms_norm(x, W["final_norm"], cfg["eps"])
return x @ W["embed"].T # tied lm_head
'''
MODEL_SRC = HELPERS_CORE + QUANT_FP8 + BODY
|