"""A single wide SwiGLU block at batch 8 -- the producer/consumer warp-specialisation problem.

Three GEMVs against 805 MB of weights, with a hard dependency in the middle: `down` cannot start
until `silu(gate @ x) * (up @ x)` is complete for the whole 16384-wide intermediate. That makes the
whole thing one kernel with a grid-wide barrier in it, and inside each half the shape is the classic
warp-specialisation case: a stream of weight tiles that must be pulled from HBM continuously while a
separate set of warps consumes them against 8 resident activation rows.

Batch 8 rather than batch 1 on purpose: each loaded weight tile is used eight times, so the consumer
has enough arithmetic that keeping it fed is a real scheduling problem rather than a formality, while
the arithmetic intensity (8 flop/byte against a ~146 flop/byte machine balance) keeps the task firmly
bandwidth-bound and the reward honestly a GB/s number.
"""

BODY = r'''
def make_weights(cfg, seed=0, device="cuda"):
    """gate/up: (ffn, d).  down: (d, ffn).  1/sqrt(fan_in) scaled, bf16."""
    g = torch.Generator(device=device).manual_seed(seed)
    d, f = cfg["d"], cfg["ffn"]

    def rnd(*shape, fan_in):
        return (torch.randn(*shape, device=device, dtype=torch.float32, generator=g)
                / (fan_in ** 0.5)).to(torch.bfloat16)

    return {"gate": rnd(f, d, fan_in=d), "up": rnd(f, d, fan_in=d), "down": rnd(d, f, fan_in=f)}


def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"):
    """No KV cache in this task."""
    return []


def make_step_args(cfg, batch, base_pos, seed, n):
    """(x,) per call -- a fresh (B, d) bf16 activation block."""
    g = torch.Generator(device="cuda").manual_seed(seed)
    return [(torch.randn(batch, cfg["d"], device="cuda", dtype=torch.float32,
                         generator=g).to(torch.bfloat16),) for _ in range(n)]


def build_gemv(weights, kv_cache, cfg, max_seq_len):
    """UNTIMED setup. Re-tile, interleave gate/up, allocate the intermediate, ..."""
    return {"W": weights, "cfg": cfg}


@torch.no_grad()
def swiglu_gemv(handle, x):
    """One SwiGLU block: down @ (silu(gate @ x) * (up @ x)).

    x       : (B, d) bf16
    returns : (B, d) fp32
    """
    W = handle["W"]
    h = F.silu(torch.matmul(x, W["gate"].T).float()) * torch.matmul(x, W["up"].T).float()
    return torch.matmul(h.to(torch.bfloat16), W["down"].T).float()
'''

MODEL_SRC = BODY