# How to add a kernel-generation task Read this fully before writing anything. Everything here is a hard requirement learned from building the existing 153 tasks; the pitfalls at the bottom are all things that actually went wrong. ## What a task is An agent is given a slow-but-correct `reference.py` and an empty stub, and must write a fast GPU kernel. reward = 0 if the submission is incorrect reward = achieved TFLOP/s or GB/s otherwise, UNCAPPED Correctness is the **gate**. Speed is the **reward**. There is no oracle and no gold solution: the score is an absolute hardware metric, so it is hardware-portable and nothing needs re-benchmarking. ## Workflow ```bash cd /home/zhuominc/MLE-Bench/mle_tasks/kernel-generation/kernels $EDITOR _factory/specs/my_task.py # write the spec (see below) python3 _factory/build.py _factory/specs/my_task.py # generates the whole task directory bash _factory/validate.sh my-task-name # stub must be 0, reference must be > 0 python3 _factory/audit_sizes.py my-task-name # roofline must be >= 250 us ``` **Write the spec file to disk the moment you have it drafted, before validating.** Agents have been lost mid-run; anything not on disk is gone. `validate.sh` must print: my-task-name stub[0.0 | correct: 0.0] ref[ | correct: 1.0] If the stub scores non-zero or the reference scores zero, the task is broken. Do not move on. ## The spec Every field is in `_factory/spec.py`. The ones that matter most: | field | notes | |---|---| | `reference_src` | correct + simple. NOT a performance target. Must be numerically *tractable*, not fair. | | `make_inputs_src` | `def _mk(*shape, seed)` returning the arg tuple, on `cuda`, seeded | | `flops_src` | `def canonical_work(*shape)` — FLOPs or BYTES from **shape alone**, never from the data | | `flops_formula` | set this explicitly whenever `canonical_work` uses helpers or multiple statements | | `metric` | `"TFLOP/s"` for compute-bound, `"GB/s"` for bandwidth-bound. Pick honestly. | | `compare` | `"tensor"` \| `"tuple"` (needs `tuple_names`) \| `"rowwise"` (needs `row_pass`) | | `tol` | **measure it**, do not guess. See Precision below. | | `grader_shapes` / `correct_shapes` / `measure_shapes` | see Sizing below | `canonical_work` depending on the *data* (e.g. counting actual non-zeros) breaks the leaderboard — two submissions would be credited differently for the same work. Shape only. ## Sizing — the most common failure The kernel must dominate, not launch overhead. **At the largest graded shape the roofline time must be >= 250 us**, where roofline is `FLOPs / 700e12` (bf16 H200) or `bytes / 4.8e12`. `python3 _factory/audit_sizes.py ` checks this. If it reports under 250 us, make the tensors bigger — and then update `regime_md` so the prose matches the new numbers. Keep `correct_shapes` **small** (they run many times) and `grader_shapes` **large**. They are separate lists precisely so correctness can be cheap while timing is at scale. ## Precision Prefer **bf16 / fp8** — that is what LLM and diffusion inference actually use. fp32 references are fine as the numerical *spec*, but the graded dtype should be realistic. **Measure the tolerance, do not guess it.** Write the reference, write a second independent-but-correct implementation (different reduction order, different chunking), compare them, and set `tol` at roughly **2x** the observed difference. State the reasoning in `precision_md`. If a task ships pre-quantised inputs (fp8/int4/nvfp4), the reference must dequantise **those exact bytes**. Making the agent quantise and then charging them the quantisation error is a bug — it cost the megakernel fp8 task a 10x tolerance error before it was caught. ## Quantisation tasks: constrain the input span Quantised tasks have a failure mode the rest of the lane does not — the measured error depends on the input span, so a tolerance measured on a few seeds can be a lottery. * **Per-TENSOR scales must be exactly representable.** A scalar scale drawn from a continuous distribution is not representable in bf16, and its rounding error multiplies the WHOLE output coherently instead of averaging out. `nvfp4-dequant-gemm` measured a **221x spread** in E across 80 seeds from one such scalar, leaving 1.73x headroom at the worst seed. Round per-tensor scales onto the bf16 grid at generation. Per-row and per-block scales average out over the reduction and should be left alone — rounding them would misrepresent the real format. * **Measure E over MANY seeds, not two or three.** The tail grows: that same task measured 2.4e-3 over 20 seeds and 2.9e-3 over 80. And the grader validates the last TIMED rep on seeds 10000+i, which are different from the correctness seeds 100+i, so an unstable E can pass correctness and fail timing. * **Watch for underflow outliers.** If a fixture lets a dequantised value reach exactly zero where a divisor expects it not to, a handful of elements can dominate the relative-Frobenius norm. `quantized-optimizer-state` had 8 elements carrying 86% of the output energy for that reason. * **Relative Frobenius error under-weights what quantisation damages.** It is dominated by the largest elements, which are the ones that SET absmax and are best represented. Keep the block dynamic range (`absmax/rms`) near what a gaussian gives (~3.2 for a 128-block); if you want real activation outliers, inject them at a FIXED count and magnitude rather than relying on the tail of `randn`. * **If your gate ends up tight enough to forbid bf16 metadata, say so in the prose.** Scales and dequantisation maps are tiny and fully reused, so keeping them fp32 costs no bandwidth — but an agent will not guess that a 4e-5 gate is enforcing it. ## Contract clarity Difficulty must come from the kernel, never from ambiguity. `contract_md` must state, for every argument: shape, dtype, layout, and meaning; and for every output: shape, dtype, and whether it may be bf16 or must be exact. Say explicitly whether inputs are read-only and whether updates are in-place or functional. If a dimension is ragged (not a multiple of any tile), say so and include a ragged `correct_shape`. `perf_md` must tell the agent where the performance actually comes from, and `instruction.md` must explicitly push for speed — this is a leaderboard, not a pass/fail. ## Toolchain policy (what agents may use) Encouraged: **CUDA C++ / CuTe DSL**, then Triton (Gluon ships with it), CUTLASS. `torch` is allowed for setup and where there is no efficient direct alternative. Not available, by absence rather than by scanning: no internet at run time, and no flashinfer, vLLM, flash-attn, TensorRT-LLM, or any pre-fused library kernel installed. **Never add an anti-cheat source scan** — if agents should not have something, it simply is not installed. ## Novelty Tasks must be genuinely new, LLM- or video-generation-related, and not duplicate any of the 153 existing directories. `ls -d */ | grep -v '^_'` before you name anything. ## Pitfalls that have actually bitten * **Integer tensors must compare exactly.** `.float()` is lossy above 2^24, so two distinct page/token ids can compare equal and let a wrong kernel pass. The generated grader already handles this — do not reintroduce float comparison in a custom check. * **Top-k / argmax gates are fragile.** Near-tied values flip on ordinary numerical noise, so two *correct* implementations disagree. Gate on relative error instead. This killed a MoBA design and a megakernel design. * **`tensor / python_float` is a reciprocal-multiply** and flips ~0.05% of fp8 codes. Use a 0-dim tensor divisor. * **Check the drop-the-feature error.** Measure what a kernel that *ignores* your task's distinguishing feature would score. It must be far above `tol`, or the feature is not actually being graded. * **Do not trust a reference you have not verified.** Validate against a known-correct special case or an independent implementation before shipping. * **Disk.** Reap images as you go: `docker rmi -f mle-v-`. `/` has filled mid-run several times.