tools/mega_factory/specs/persistent_layer_fused_decode.py

"""persistent-layer-fused-decode -- one whole transformer layer, one launch."""
import pathlib, sys
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1] / "models"))
from spec import MegaSpec
import fused_layers

CFG = dict(layers=1, d=8192, ffn=28672, n_q=64, n_kv=8, hd=128,
           eps=1e-5, theta=500000.0, wdtype="bf16")
PF, DS = 4096, 32
WB = (CFG["n_q"] * CFG["hd"] * CFG["d"] + 2 * CFG["n_kv"] * CFG["hd"] * CFG["d"]
      + CFG["d"] * CFG["n_q"] * CFG["hd"] + 3 * CFG["ffn"] * CFG["d"]) * 2
KVB = 2 * 1 * CFG["n_kv"] * (PF + DS) * CFG["hd"] * 2

SPEC = MegaSpec(
    name="persistent-layer-fused-decode",
    family="e2",
    title="Fuse one entire transformer decoder layer into a single kernel launch",
    blurb=("RMSNorm, GQA QKV projection, RoPE, KV append, attention over 4k tokens, output projection, "
           "residual, second RMSNorm, 28672-wide SwiGLU MLP, residual -- about 40 operations and "
           "1.71 GB of weights, in one launch. This is the unit cell of a whole-model megakernel: get "
           "it right and a 16-layer megakernel is this plus a schedule. Graded on tokens/s."),
    keywords=["mle", "kernel-generation", "megakernel", "persistent-kernel", "decode", "gqa",
              "swiglu", "rmsnorm", "rope", "memory-bound"],
    cfg=CFG, model_src=fused_layers.src("build_layer", "layer_step"),
    batch=1, prefill_len=PF, max_seq=4224, decode_steps=DS, correct_steps=8, prof_steps=4,
    tol=1.5e-2,
    max_kernels_per_step=2.0, min_dominant_share=0.95,
    bytes_per_step=WB + KVB,
    reward_metric="tokens/s", reward_work=1.0,
    entry_build="build_layer", entry_step="layer_step",
    step_sig="handle, x, pos",
    step_ret="x_out",
    step_doc=("Run the layer on one hidden state; append this position's K/V into the cache."
              "\n\n    x       : (B, d) bf16    the incoming residual stream"
              "\n    pos     : int           the absolute position being written"
              "\n    returns : (B, d)        the residual stream after the layer\n    "),
    arg_doc=("weights   : dict with `layers[0]` holding `in_norm, post_norm, q, k, v, o, gate, up, down`"
             "\n    kv_cache  : list of one (k, v), each (B, n_kv, max_seq_len, hd) bf16, prefilled"),
    unfused_kernels=43,
    intro_md="""This is the unit cell. A whole-model megakernel is one of these repeated 16 to 80 times
with a schedule wrapped around it, and almost everything that is hard about the whole-model version is
already hard here: a norm whose reduction gates every downstream output, a GQA attention that has to
share a KV head across 8 query heads, a cache write that the very next operation reads, and a 705 MB
MLP that has to stream while the attention's registers are still live.

One layer, one launch. Roughly 40 fusable operations and 1.71 GB of weights.""",
    spec_md="""## The computation

One standard decoder layer, for a single decode position `pos`:

```
h     = rmsnorm(x, in_norm)                                  # reduction over d = 8192
q     = h @ Wq.T   -> (B, 64, hd)      # 64 query heads
k     = h @ Wk.T   -> (B,  8, hd)      # 8 KV heads  (GQA, rep = 8)
v     = h @ Wv.T   -> (B,  8, hd)
q, k  = rope(q, pos), rope(k, pos)
kv_cache.k[:, :, pos] = k                                    # append THIS position
kv_cache.v[:, :, pos] = v
a     = softmax(q @ K[:pos+1].T / sqrt(hd)) @ V[:pos+1]       # K/V shared by 8 query heads each
x     = x + a_flat @ Wo.T
h     = rmsnorm(x, post_norm)
x     = x + (silu(h @ Wgate.T) * (h @ Wup.T)) @ Wdown.T       # ffn = 28672
return x
```

`d` = 8192, `ffn` = 28672, 64 query / 8 KV heads, head_dim 128 -- one layer of a 70B-class model. The
KV cache arrives holding 4096 tokens and you append one per call, so by the end of a timed run the
attention covers 4128 keys.

`/app/reference.py` implements exactly this, unfused, in eager torch: 43 kernel launches per call.

Note there is no embedding and no LM head. The input is a hidden state and the output is a hidden
state; the layer is the whole task.""",
    contract_md="""```python
def build_layer(weights, kv_cache, cfg, max_seq_len) -> handle    # UNTIMED
def layer_step(handle, x, pos) -> x_out                           # TIMED
def teardown(handle)                                              # OPTIONAL
```

`build_layer` is handed all four arguments below. `layer_step` is handed the handle you returned, plus
`x` and `pos`.

| arg | shape | dtype | meaning |
|-----|-------|-------|---------|
| `weights` | `dict` | `bfloat16` | exactly one key, `layers`, holding a list of **one** dict. There is **no** embedding and **no** LM head in this task |
| `weights["layers"][0]` | 9 tensors | `bfloat16` | `in_norm (d,)`, `post_norm (d,)`, `q (n_q*hd, d)`, `k (n_kv*hd, d)`, `v (n_kv*hd, d)`, `o (d, n_q*hd)`, `gate (ffn, d)`, `up (ffn, d)`, `down (d, ffn)` -- row-major, applied as `h @ W.T`. With `d`=8192, `ffn`=28672, `n_q`=64, `n_kv`=8, `hd`=128 |
| `kv_cache` | `list` of **1** `(k, v)` pair | `bfloat16` | each tensor `(B, n_kv, max_seq_len, hd)`; slots `[0, 4096)` hold the prefix, the rest are zero |
| `cfg` | `dict` | python `int` / `float` / `str` | `layers` = 1, `d, ffn, n_q, n_kv, hd, eps, theta, wdtype` |
| `max_seq_len` | scalar | python `int` | `4224` -- the allocated time capacity of the cache, exactly `kv_cache[0][0].shape[2]`. `pos < max_seq_len` always holds, so a RoPE table of this length covers the whole run |
| `x` | `(B, d)` = `(1, 8192)` | `bfloat16`, on the GPU | the incoming residual stream, fresh every call |
| `pos` | scalar | python `int` | the absolute position to write; it advances by 1 per call |

**Return** -- `layer_step` returns a **single tensor** `x_out` of shape `(B, d)` = `(1, 8192)`, the
residual stream after the layer, **bf16 or fp32, both accepted** (the grader compares in fp32).
`build_layer` returns an opaque handle of any type; the grader never inspects it and only passes it
back to `layer_step`.

`weights`, `cfg` and `x` are **read-only**. `kv_cache` is the one thing you must update **in place**:
you **must** write K and V for `pos` into the cache you were given, because the next call attends over
it and the timed run is validated at the end, so an unwritten position surfaces as a wrong answer
later.

`build_layer` is untimed: repack weights, fuse Q/K/V into one matrix, build the RoPE tables, allocate
scratch, launch a persistent kernel.""",
    gates_md="""**Why these gates, for this task.**

Here the tight kernel-count gate is exactly right, with none of the caveats that apply to the smaller
primitives in this group. A decoder layer is ~40 distinct operations with a data dependency between
almost every consecutive pair; the reference launches 43 kernels, and there is no natural
implementation that lands between "fused" and "one kernel per op". Setting the limit at 2 means the
norm, both projections, RoPE, the cache write, the attention, the output projection, both residuals
and the whole MLP happen without the activation ever going back to HBM -- which is the definition of
the thing being asked for. CUDA Graphs do not help: a graph replays 40 nodes.

Dominant share >= 0.95 closes the obvious loophole in the count. The two natural "two big kernels"
splits are attention-then-MLP and QKV-then-rest. The MLP is 705 M of the 856 M parameters, so an
attention/MLP split gives a dominant share of about 0.82 by weight bytes and fails; a QKV/rest
split fails harder.
0.95 leaves room only for a genuinely trivial second launch, such as zeroing a barrier flag.

**Why the reward is tokens/s.** One call is one decoded token for one sequence, so tokens/s is the
literal, directly comparable serving metric, and it makes this task's number commensurable with the
whole-model megakernel tasks (which are the same metric on the same hardware).

**Why `tol` is 1.5e-2.** Measured: the reference keeps the residual stream in bf16, which is what
production serving stacks do; a megakernel holding `x` in registers naturally keeps it in fp32. Those
differ by 0.0038 here. The tolerance is ~4x that, tighter than the whole-model tasks' 5e-2 because
there is only one layer of accumulation.""",
    regime_md="""**Regime**: batch 1, one layer, `d` = 8192, `ffn` = 28672, 64 query / 8 KV heads,
head_dim 128 -- a 70B-class layer. 856 M parameters = 1.71 GB, plus 17 MB of KV read at the deepest
position, so the roofline is that 1.73 GB divided by the HBM bandwidth you measure, and the whole thing
is weight bandwidth. Measured eager torch: 770 us, i.e. 2.25 TB/s and **2.14x** that roofline.""",
    correctness_md="""The returned `(B, d)` residual stream must match the reference within **relative
error 1.5e-2** at every compared step, and the KV cache must contain what the reference's cache
contains -- not because it is compared directly, but because the next call attends over it and the
final timed step is validated.

Accumulate in fp32 inside every reduction: the RMSNorm sums, the attention softmax (running max +
rescale), and all six GEMV dot products.

**The residual stream may be kept in bf16 or fp32 -- both pass.** Measured difference between those
two choices: 0.0038.""",
    precision_md="""Weights and the KV cache are **bfloat16**; compute in bf16 with **fp32
accumulation**.

RoPE is applied in **fp32** on `q` and `k` before the cache write -- the reference builds its cos/sin
table in fp32 -- and `k` is cast back to bf16 for storage. Storing rotated K in anything wider than
bf16 breaks the cache contract, because the reference will read those bytes back as bf16 next call.

The attention softmax must use a running maximum and rescale in fp32. At 4128 keys a naive `exp` of
raw scores is fine numerically, but the accumulation of `p @ V` in bf16 is not.

`eps` = 1e-5 goes inside the square root of the RMSNorm: `x * rsqrt(mean(x^2) + eps)`.""",
    perf_md="""At batch 1 this is pure weight bandwidth: 1.71 GB streamed to produce 8192 numbers.

`BW` is the HBM bandwidth you measure on the device with a large stream-copy -- never a
datasheet figure. The measured rows come from one machine, so read the **x floor** column, not the
absolute microseconds.

| | us/call | tokens/s | x floor |
|---|---|---|---|
| roofline | 1.73 GB -> divide by `BW` | -- | 1.0 |
| eager torch (43 launches) | 770 | 1299 | 2.14 |

2.1x is a smaller gap than the whole-model tasks show, and that is honest: with only 43 launches the
per-op overhead is a smaller fraction than it is at 628. What is left is real -- pipeline drain at
every boundary, the intermediate `(1, 28672)` SwiGLU activation round-tripping through HBM, and the
`q/k/v` triple being read as three separate passes over the same `h`.

What actually wins here:

* **Fuse Q, K and V into one pass.** They share the same input `h` and their weight matrices can be
  concatenated in `build_layer` into a single `(n_q*hd + 2*n_kv*hd, d)` matrix. One pass, one set of
  accumulators.
* **Never materialise the SwiGLU intermediate.** `silu(gate@h) * (up@h)` is `(1, 28672)`; produce a
  block of it, immediately consume it into the `down` accumulation, discard. This alone removes two
  full HBM trips.
* **The attention is tiny; treat it as such.** 4128 keys x 8 KV heads x 128 = 8.5 MB of KV against
  1.71 GB of weights. Give it a small slice of the grid and overlap it with the MLP weight loads
  rather than letting the whole grid stall on a 0.5% workload.
* **GQA means the KV head is read once for 8 query heads.** Load `K[h]` into shared memory and let 8
  query heads consume it; loading per query head is an 8x mistake on the KV side.
* **Keep `x` resident.** The residual stream is 8192 numbers -- 16 KB. It should live in registers or
  shared memory from the first residual add to the last.
* **The MLP is 82% of your bytes.** Whatever you do about the attention, the score is decided by how
  well `gate`, `up` and `down` stream.""",
).validate()