LEVEL3_BRIEF.md

Brief: level-3 substrates (full architectures, multi-kernel)

Level-3 KernelBench problems are whole networks. Their substrate is a PIPELINE of kernels — one __global__ per layer — so that a mutation lands in a specific layer and we can measure how far a fault propagates through depth.

Read substrates/SPEC.md first for the general contract, then the differences below. Read problems_batch2.py for the CUDA style, and at least two accepted substrates from substrates/accepted/.

What changes vs a level-1/2 substrate

1. cuda holds SEVERAL __global__ kernels, one per layer of the network (e.g. mlp_gemm_relu_kernel, mlp_gemm_kernel). Name them so the layer is identifiable.
2. kernel_name is a LIST of those symbol names, in pipeline order.
3. launch returns a DICT describing the sequence instead of a single tuple:

def launch(inputs, torch):
    x = inputs[0]
    ...
    bufs = [torch.zeros(...), ...]        # intermediate activations
    seq = [
        # (kernel_name, grid3, block3, [tensor args in order], [(ctype, scalar), ...])
        ("layer0_kernel", (gx, gy, 1), (32, 32, 1), [x, w0, b0, bufs[0]],
         [(ctypes.c_int, M), (ctypes.c_int, K), (ctypes.c_int, N)]),
        ("layer1_kernel", ..., [bufs[0], w1, b1, out], [...]),
    ]
    return {"seq": seq, "out": out}

Tensor arguments are passed as data pointers in the order listed; scalars follow. Allocate intermediates inside launch.

4. WEIGHTS: the reference Model owns nn.Parameters. Create them ONCE with a fixed seed inside the substrate module (module-level, lazily on first use), and have ref use THE SAME tensors, so reference and kernel see identical weights. Put them on the input's device.

5. ref must reproduce the KernelBench Model.forward exactly, using those same weights (e.g. torch.nn.functional.linear(x, W0, b0).relu() ...).

6. Suites: T0_original must reproduce the problem's get_inputs(); add 2-3 targeted suites. Keep the legitimate-variance ceiling in mind: prefer same-sign large values over signed ones.

Performance does not matter

Naive kernels are fine (one thread per output element, sequential loops). What matters is: correct, readable, and rich in mutation sites (explicit bounds guards, ceil-division, distinct __syncthreads() where relevant).

Deliverable

substrates/candidate_L3p<N>_<short>.py with a register(K, torch, ctypes) function exactly as in SPEC.md, plus kernel_name as a list and the dict-style launch above. Import-safe, no GPU work at import time, do not modify other files.