| """Generate one megakernel task from a MegaSpec. |
| |
| Produces the same file layout as _factory/build.py so harbor sees a uniform lane, but the grader is |
| different: stateful multi-step workload, measured fusion gates, throughput reward. |
| |
| The generated grader is architecture-agnostic. Everything model-specific lives in the spec's |
| `model_src`, which must define: |
| |
| make_weights(cfg, seed, device) -> weights |
| make_kv(cfg, batch, prefill_len, max_seq, seed) -> per-step state (may be [] / None) |
| <entry_build>(weights, kv, cfg, max_seq_len) -> handle |
| <entry_step>(handle, *args) -> output tensor (or tuple of tensors) |
| |
| and may override the two defaults injected by PRELUDE_SRC: |
| |
| make_step_args(cfg, batch, base_pos, seed, n) -> list of arg tuples, one per step |
| compare(got, exp) -> float relative error |
| """ |
| import pathlib |
| import shutil |
| import sys |
|
|
| HERE = pathlib.Path(__file__).resolve().parent |
| LANE = HERE.parent |
| sys.path.insert(0, str(HERE)) |
| from model import MODEL_SRC |
|
|
| SHARED = ["restrict-network.sh", "CLAUDE.md", "PROCESS_MANAGEMENT.md"] |
|
|
| PREAMBLE = "import torch\nimport torch.nn.functional as F" |
|
|
| |
| PRELUDE_SRC = r''' |
| def make_step_args(cfg, batch, base_pos, seed, n): |
| """Arguments passed to each step, after the handle. Default: (token_ids, pos).""" |
| g = torch.Generator(device="cuda").manual_seed(seed) |
| return [(torch.randint(0, cfg["vocab"], (batch,), device="cuda", generator=g), base_pos + i) |
| for i in range(n)] |
| |
| |
| def compare(got, exp): |
| """Relative error (Frobenius) used by the correctness gate. Tuples compare worst-elementwise.""" |
| if isinstance(exp, (tuple, list)): |
| return max(compare(g, e) for g, e in zip(got, exp)) |
| a, b = got.float(), exp.float() |
| return ((a - b).norm() / b.norm().clamp(min=1e-9)).item() |
| ''' |
|
|
| |
| VERIFY = '''"""{name} verifier — three gates, then an uncapped {metric} SPEED LEADERBOARD. |
| |
| reward = 0 if ANY gate fails |
| reward = {metric} otherwise |
| |
| GATES |
| 1. correctness full-output relative error <= {tol} at every compared step |
| 2. kernels/call <= {max_kernels} CUDA kernel launches per timed call |
| 3. dominant share the largest single kernel is >= {min_dom} of GPU busy time in a call |
| |
| Gates 2 and 3 are what make this a FUSION task rather than a generic speed task. They are measured, |
| not inspected: nothing reads your source. CUDA Graphs do not help -- a graph replays the same nodes, so |
| graphed eager torch still launches the same number of kernels (measured), missing gate 2 by a wide |
| margin. |
| |
| Gates 2/3 are measured in a SEPARATE profiled run; the reward comes from a clean unprofiled run, so |
| profiler overhead never contaminates your score. |
| |
| A submission whose persistent kernel is launched once in {entry_build}() and driven by flags will show |
| 0 launches/call. That is the ideal design and passes both gates. |
| |
| ANTI-REPLAY: every timed rep uses fresh state and a fresh argument sequence, and the output of the |
| last timed rep is validated against the reference for that exact sequence. |
| |
| GENERATED by _mega_factory/build.py — do not edit here; edit the spec and regenerate. |
| """ |
| import importlib.util |
| import json |
| import os |
| import sys |
| import traceback |
| |
| {preamble} |
| |
| REWARD_DIR = "/logs/verifier" |
| MODULE_PATH = "/app/{module}" |
| CFG = {cfg!r} |
| TOL = {tol!r} |
| BATCH, PREFILL, MAX_SEQ = {batch}, {prefill}, {max_seq} |
| DECODE_STEPS, CORRECT_STEPS, PROF_STEPS = {decode_steps}, {correct_steps}, {prof_steps} |
| MAX_KERNELS, MIN_DOM = {max_kernels!r}, {min_dom!r} |
| WEIGHT_BYTES, FLOOR_US = {weight_bytes}, {floor_us:.1f} |
| REWARD_WORK, METRIC = {reward_work!r}, "{metric}" |
| |
| sys.path.insert(0, "/app") |
| |
| {model_src} |
| |
| |
| def _args(seed, n, base=0): |
| return make_step_args(CFG, BATCH, PREFILL + base, seed, n) |
| |
| |
| def _fresh(seed): |
| """Independent weights + state. Built twice from the same seed rather than shared, so a submission |
| that repacks or mutates its inputs cannot disturb the reference.""" |
| return (make_weights(CFG, seed=seed), make_kv(CFG, BATCH, PREFILL, MAX_SEQ, seed=seed)) |
| |
| |
| def _teardown(mod, h): |
| fn = getattr(mod, "teardown", None) |
| if fn is not None: |
| try: |
| fn(h) |
| except Exception: |
| pass |
| |
| |
| def main(): |
| details, gates, thru = {{}}, {{}}, 0.0 |
| try: |
| s = importlib.util.spec_from_file_location("submission", MODULE_PATH) |
| m = importlib.util.module_from_spec(s) |
| s.loader.exec_module(m) |
| |
| # ---- gate 1: correctness over CORRECT_STEPS ------------------------------------------------ |
| W, kv = _fresh(11) |
| hs = m.{entry_build}(W, kv, CFG, MAX_SEQ) |
| Wr, kvr = _fresh(11) |
| hr = {entry_build}(Wr, kvr, CFG, MAX_SEQ) |
| worst, bad = 0.0, "" |
| for i, a in enumerate(_args(500, CORRECT_STEPS)): |
| got = m.{entry_step}(hs, *a) |
| exp = {entry_step}(hr, *a) |
| e = compare(got, exp) |
| worst = max(worst, e) |
| if e > TOL: |
| bad = f"step {{i}} relerr {{e:.5f}} > {{TOL}}" |
| break |
| gates["correct"] = not bad |
| details["worst_relerr"] = round(worst, 6) |
| details["correct_msg"] = bad or f"all {{CORRECT_STEPS}} steps within {{TOL}} (worst {{worst:.5f}})" |
| _teardown(m, hs) |
| del W, kv, hs, Wr, kvr, hr |
| torch.cuda.empty_cache() |
| |
| # ---- gates 2+3: profiled run (never timed) ------------------------------------------------- |
| from torch.profiler import profile, ProfilerActivity |
| W, kv = _fresh(12) |
| h = m.{entry_build}(W, kv, CFG, MAX_SEQ) |
| for a in _args(600, 4): |
| m.{entry_step}(h, *a) |
| torch.cuda.synchronize() |
| pt = _args(601, PROF_STEPS, 4) |
| with profile(activities=[ProfilerActivity.CUDA]) as prof: |
| for a in pt: |
| m.{entry_step}(h, *a) |
| torch.cuda.synchronize() |
| ka = [k for k in prof.key_averages() if k.self_device_time_total > 0] |
| if ka: |
| tot = sum(k.self_device_time_total for k in ka) |
| per_step = sum(k.count for k in ka) / PROF_STEPS |
| dom = max(k.self_device_time_total for k in ka) / max(tot, 1e-9) |
| top = max(ka, key=lambda k: k.self_device_time_total).key[:48] |
| else: |
| # no kernel launched inside a call -> a persistent kernel launched in {entry_build} |
| per_step, dom, top = 0.0, 1.0, "<persistent kernel spanning the timed region>" |
| gates["kernels_per_step"] = per_step <= MAX_KERNELS |
| gates["dominant_share"] = dom >= MIN_DOM |
| details.update(kernels_per_step=round(per_step, 2), dominant_share=round(dom, 4), |
| dominant_kernel=top) |
| _teardown(m, h) |
| del W, kv, h |
| torch.cuda.empty_cache() |
| |
| # ---- reward: clean unprofiled timing, fresh state per rep ---------------------------------- |
| best_s, timed_ok = float("inf"), True |
| for rep in range(3): |
| W, kv = _fresh(20 + rep) |
| h = m.{entry_build}(W, kv, CFG, MAX_SEQ) |
| seq = _args(900 + rep, DECODE_STEPS) |
| for a in seq[:3]: # warm on a throwaway prefix |
| m.{entry_step}(h, *a) |
| torch.cuda.synchronize() |
| W2, kv2 = _fresh(20 + rep) |
| h2 = m.{entry_build}(W2, kv2, CFG, MAX_SEQ) |
| ev0 = torch.cuda.Event(enable_timing=True) |
| ev1 = torch.cuda.Event(enable_timing=True) |
| ev0.record() |
| for a in seq: |
| out = m.{entry_step}(h2, *a) |
| ev1.record() |
| torch.cuda.synchronize() |
| best_s = min(best_s, ev0.elapsed_time(ev1) / 1e3) |
| if rep == 2: # validate the LAST timed rep |
| Wr, kvr = _fresh(20 + rep) |
| hr = {entry_build}(Wr, kvr, CFG, MAX_SEQ) |
| for a in seq: |
| exp = {entry_step}(hr, *a) |
| timed_ok = compare(out, exp) <= TOL |
| del Wr, kvr, hr |
| _teardown(m, h) |
| _teardown(m, h2) |
| del W, kv, h, W2, kv2, h2 |
| torch.cuda.empty_cache() |
| gates["timed_output_valid"] = timed_ok |
| thru = (REWARD_WORK * DECODE_STEPS) / best_s if best_s > 0 else 0.0 |
| details.update(throughput=round(thru, 2), metric=METRIC, |
| us_per_step=round(best_s / DECODE_STEPS * 1e6, 1), |
| floor_us=FLOOR_US, |
| x_above_floor=round((best_s / DECODE_STEPS * 1e6) / FLOOR_US, 2)) |
| except Exception as e: |
| details["error"] = f"{{e.__class__.__name__}}: {{e}}"[:220] |
| details["trace"] = traceback.format_exc()[-900:] |
| |
| ok = bool(gates) and all(gates.values()) |
| reward = round(thru, 3) if ok else 0.0 |
| details["gates"] = gates |
| os.makedirs(REWARD_DIR, exist_ok=True) |
| json.dump({{"reward": reward, "correct": 1.0 if ok else 0.0, |
| "throughput": round(thru, 3), "metric": "{metric} (uncapped)"}}, |
| open(f"{{REWARD_DIR}}/reward.json", "w"), indent=2) |
| open(f"{{REWARD_DIR}}/reward.txt", "w").write(str(reward)) |
| json.dump(details, open(f"{{REWARD_DIR}}/details.json", "w"), indent=2, default=str) |
| print("reward:", reward, "{metric} | correct:", 1.0 if ok else 0.0, "| gates:", gates) |
| |
| |
| main() |
| ''' |
|
|
| |
| MEASURE = '''"""Self-assessment — your three gates and your {metric}, same method as the grader. |
| |
| Run: python3 /app/measure.py |
| This does NOT set your score; it exists so you can iterate without guessing. |
| """ |
| import importlib.util |
| import sys |
| |
| {preamble} |
| |
| CFG = {cfg!r} |
| TOL = {tol!r} |
| BATCH, PREFILL, MAX_SEQ = {batch}, {prefill}, {max_seq} |
| DECODE_STEPS, CORRECT_STEPS, PROF_STEPS = {decode_steps}, {correct_steps}, {prof_steps} |
| MAX_KERNELS, MIN_DOM = {max_kernels!r}, {min_dom!r} |
| FLOOR_US, REWARD_WORK = {floor_us:.1f}, {reward_work!r} |
| |
| sys.path.insert(0, "/app") |
| {model_src} |
| |
| |
| def main(): |
| s = importlib.util.spec_from_file_location("sub", "/app/{module}") |
| m = importlib.util.module_from_spec(s) |
| s.loader.exec_module(m) |
| args = lambda seed, n, base=0: make_step_args(CFG, BATCH, PREFILL + base, seed, n) |
| |
| W = make_weights(CFG, seed=11); kv = make_kv(CFG, BATCH, PREFILL, MAX_SEQ, seed=11) |
| Wr = make_weights(CFG, seed=11); kvr = make_kv(CFG, BATCH, PREFILL, MAX_SEQ, seed=11) |
| hs, hr = m.{entry_build}(W, kv, CFG, MAX_SEQ), {entry_build}(Wr, kvr, CFG, MAX_SEQ) |
| worst = 0.0 |
| for a in args(500, CORRECT_STEPS): |
| worst = max(worst, compare(m.{entry_step}(hs, *a), {entry_step}(hr, *a))) |
| print(f"gate 1 correctness : worst relerr {{worst:.5f}} (limit {{TOL}}) " |
| f"{{'PASS' if worst <= TOL else 'FAIL'}}") |
| |
| from torch.profiler import profile, ProfilerActivity |
| for a in args(600, 4, CORRECT_STEPS): |
| m.{entry_step}(hs, *a) |
| torch.cuda.synchronize() |
| with profile(activities=[ProfilerActivity.CUDA]) as prof: |
| for a in args(601, PROF_STEPS, CORRECT_STEPS + 4): |
| m.{entry_step}(hs, *a) |
| torch.cuda.synchronize() |
| ka = [k for k in prof.key_averages() if k.self_device_time_total > 0] |
| if ka: |
| tot = sum(k.self_device_time_total for k in ka) |
| per_step = sum(k.count for k in ka) / PROF_STEPS |
| dom = max(k.self_device_time_total for k in ka) / max(tot, 1e-9) |
| else: |
| per_step, dom = 0.0, 1.0 |
| print(f"gate 2 kernels/call: {{per_step:.1f}} (limit {{MAX_KERNELS}}) " |
| f"{{'PASS' if per_step <= MAX_KERNELS else 'FAIL'}}") |
| print(f"gate 3 dominant : {{dom:.3f}} (limit {{MIN_DOM}}) " |
| f"{{'PASS' if dom >= MIN_DOM else 'FAIL'}}") |
| |
| seq = args(900, DECODE_STEPS) |
| W2 = make_weights(CFG, seed=20); kv2 = make_kv(CFG, BATCH, PREFILL, MAX_SEQ, seed=20) |
| h2 = m.{entry_build}(W2, kv2, CFG, MAX_SEQ) |
| for a in seq[:3]: |
| m.{entry_step}(h2, *a) |
| torch.cuda.synchronize() |
| e0, e1 = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True) |
| e0.record() |
| for a in seq: |
| m.{entry_step}(h2, *a) |
| e1.record() |
| torch.cuda.synchronize() |
| sec = e0.elapsed_time(e1) / 1e3 |
| us = sec / DECODE_STEPS * 1e6 |
| print(f"\\nthroughput : {{REWARD_WORK*DECODE_STEPS/sec:.1f}} {metric} " |
| f"({{us:.0f}} us/call, {{us/FLOOR_US:.1f}}x the {{FLOOR_US:.0f}}us bandwidth floor)") |
| |
| |
| main() |
| ''' |
|
|
| |
| STUB = '''"""YOUR SUBMISSION. {stub_head} |
| |
| Two entry points. `{entry_build}` is UNTIMED — do setup there (repack weights, allocate scratch, launch |
| a persistent kernel). `{entry_step}` is TIMED and is what the gates measure. |
| |
| Optionally define `teardown(handle)`; the grader calls it if present, so a persistent daemon can be |
| stopped cleanly. |
| """ |
| import torch |
| import torch.nn.functional as F |
| |
| |
| def {entry_build}(weights, kv_cache, cfg, max_seq_len): |
| """UNTIMED setup. Return any handle you like — the grader only passes it back to {entry_step}. |
| |
| {arg_doc} |
| cfg : the architecture dict |
| """ |
| raise NotImplementedError("implement {entry_build}") |
| |
| |
| def {entry_step}({step_sig}): |
| """TIMED. {step_doc}""" |
| raise NotImplementedError("implement {entry_step}") |
| ''' |
|
|
| |
| DOCKERFILE = '''# {title} |
| # {blurb_wrapped} |
| # |
| # Graded on 1 GPU by three gates (correctness, kernels/call, dominant-kernel share) and rewarded with |
| # an UNCAPPED {metric} number. Offline: no internet at run time, and only the permitted toolchain is |
| # installed — there is no flashinfer / vllm / flash-attn / cuBLASLt-fused-model to fall back on. |
| FROM {base_image} |
| |
| RUN pip install --break-system-packages --no-cache-dir {pip_extra} && \\ |
| apt-get update && apt-get install -y --no-install-recommends \\ |
| iptables iproute2 curl ca-certificates build-essential git && \\ |
| curl -LsSf https://astral.sh/uv/install.sh | sh && \\ |
| /root/.local/bin/uv tool install mini-swe-agent |
| RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \\ |
| apt-get install -y nodejs procps && \\ |
| npm install -g @anthropic-ai/claude-code && claude --version |
| ENV PATH=/root/.local/bin:$PATH |
| ENV DISABLE_TELEMETRY=1 DISABLE_AUTOUPDATER=1 DISABLE_ERROR_REPORTING=1 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 |
| RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d |
| WORKDIR /app |
| |
| COPY reference.py /app/reference.py |
| COPY measure.py /app/measure.py |
| COPY {module} /app/{module} |
| COPY restrict-network.sh /app/restrict-network.sh |
| RUN chmod +x /app/restrict-network.sh |
| COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/ |
| ''' |
|
|
| TASK_TOML = '''schema_version = "1.1" |
| |
| [task] |
| name = "mle-bench/{name}" |
| description = "{description}" |
| authors = [] |
| keywords = [{keywords}] |
| |
| [metadata] |
| suite = "mle-bench" |
| group = "kernel-generation" |
| level = "1.0" |
| difficulty = "hard" |
| category = "mle" |
| tags = [ "mle", "kernel-generation", "kernels", "gpu", "real-world",] |
| |
| [verifier] |
| timeout_sec = {verifier_timeout_sec} |
| |
| [agent] |
| timeout_sec = {agent_timeout_sec} |
| |
| # GPU request: honored by Modal/GKE/Daytona. On the local docker backend set environment.override_gpus: 0 |
| # in the job config and attach a GPU via configs/gpu_overlay_nvidia.yaml (see RUNNING.md §5). |
| # Profiling: `ncu` needs GPU performance counters — the runner must add the SYS_ADMIN capability |
| # (docker `--cap-add SYS_ADMIN`) or the host must set NVreg_RestrictProfilingToAdminUsers=0. |
| # Without it ncu exits with ERR_NVGPUCTRPERM. `nsys` works without any extra capability. |
| [environment] |
| build_timeout_sec = 3600.0 |
| cpus = 8 |
| memory_mb = {memory_mb} |
| storage_mb = 40960 |
| gpus = {gpus} |
| network_mode = "public" |
| mcp_servers = [] |
| |
| [verifier.env] |
| |
| [environment.env] |
| |
| [solution.env] |
| ''' |
|
|
| INSTRUCTION = '''# {title} |
| |
| {intro_md} |
| |
| Edit **`/app/{module}`**. Two entry points: |
| |
| ```python |
| def {entry_build}(weights, kv_cache, cfg, max_seq_len) -> handle # UNTIMED setup |
| def {entry_step}({step_sig}) -> {step_ret} # TIMED |
| def teardown(handle) # OPTIONAL |
| ``` |
| |
| {spec_md} |
| |
| ## The contract |
| |
| {contract_md} |
| |
| ## Grading: three gates, then an uncapped speed leaderboard |
| |
| | gate | limit | how it is measured | |
| |------|-------|--------------------| |
| | 1. correctness | full-output relative error <= `{tol}` | vs an embedded private copy of the reference | |
| | 2. kernels / call | <= **{max_kernels}** | CUDA kernel launches in a profiled timed call | |
| | 3. dominant share | >= **{min_dom}** | largest single kernel's fraction of GPU busy time | |
| |
| **reward = {metric}, uncapped. Any gate failing scores 0.** |
| |
| {gates_md} |
| |
| Nothing reads your source code. Gates 2 and 3 are *measured* — they are properties of how your code |
| actually executes. Two consequences worth internalising: |
| |
| * **CUDA Graphs will not get you past gate 2.** A graph replays the same nodes; it removes launch |
| overhead, not kernels.{unfused_note} |
| * **A persistent kernel launched once in `{entry_build}` and driven by flags shows 0 launches/call.** |
| That is the ideal design and passes gates 2 and 3 outright. |
| |
| Gates 2/3 are measured in a separate profiled run; your reward comes from a clean unprofiled run, so |
| profiling overhead never costs you score. |
| |
| {regime_md} |
| |
| ## Toolchain |
| |
| **Write this in CUDA C++ if you can.** A megakernel is exactly the case where you want direct control |
| over the grid, shared memory, async copies, and the device-wide barrier, and that is easiest to express |
| in CUDA. `nvcc` and the full CUDA toolkit are installed; build with `torch.utils.cpp_extension` (JIT or |
| ahead-of-time) or drive `nvcc` yourself. CUTLASS and the CuTe DSL are available. |
| |
| **Triton is also acceptable** — a grid-wide barrier built from `tl.atomic_add` / `tl.atomic_cas` with a |
| spin loop does work here, provided your grid stays co-resident (a grid larger than what fits deadlocks |
| the blocks already spinning). If you find Triton expressive enough for the fusion you want, use it. |
| |
| **The exact GPU is deliberately not stated — query it.** You are guaranteed compute capability |
| **sm≥90**, so fp8, TMA and wgmma-class instructions exist; nothing beyond that is promised. The reward |
| is an absolute {metric} number, and the same submission is graded on whatever device it |
| lands on. A grid size, tile shape or bandwidth constant hardcoded to a part you assumed is just slower. |
| |
| ```python |
| p = torch.cuda.get_device_properties(0) |
| p.name, p.major, p.minor # part and compute capability |
| p.multi_processor_count # SM count -- size your persistent grid from this, never a constant |
| p.shared_memory_per_block_optin # opt-in dynamic smem, the number that matters for big tiles |
| p.total_memory, p.regs_per_multiprocessor, p.max_threads_per_multi_processor |
| ``` |
| |
| Measure achieved HBM bandwidth with a large stream-copy rather than trusting a datasheet figure — every |
| roofline quoted below is `bytes moved / (that measured bandwidth)`. |
| |
| What is **not** available, by construction rather than by policy: there is no internet at run time and |
| no flashinfer, vLLM, TensorRT-LLM, flash-attn, or any pre-fused whole-model inference kernel installed. |
| `torch` is present and you may use it for setup and for anything with no efficient direct alternative, |
| but note that a torch-op implementation of `{entry_step}` cannot pass gate 2 no matter how it is wrapped. |
| |
| **Profilers.** `nsys` works here and answers the first question — is the time actually inside your |
| kernel, or in launch gaps and dispatch? `ncu` reads GPU performance counters, which the container may |
| not be permitted to access: if it prints `ERR_NVGPUCTRPERM`, counters are unavailable on this run. That |
| is an environment permission, not something you can fix from inside — fall back to `nsys` plus A/B |
| ablation (change one thing, re-time it) rather than spending your budget fighting it. `ncu --version` |
| succeeds either way; it never touches a counter. Kernel *replay* also breaks a persistent |
| grid-synchronizing kernel — if you do profile one, use `ncu --replay-mode application`. |
| |
| ## Correctness |
| |
| {correctness_md} |
| |
| ## Precision |
| |
| {precision_md} |
| |
| ## Where the performance comes from |
| |
| {perf_md} |
| |
| ## Self-assessment |
| |
| `python3 /app/measure.py` reports all three gates and your {metric} using the grader's method. Use it |
| freely — it does not set your score. |
| |
| ## Faithfulness |
| |
| {faithfulness} |
| ''' |
|
|
| FAITHFULNESS = '''Your kernel must actually compute the reference computation. Specifically: |
| |
| * Do **not** skip work, shrink a dimension, or approximate a reduction that the reference performs |
| exactly. |
| * Do **not** cache outputs across calls and replay them — every timed rep uses fresh state and a fresh |
| argument sequence, and the output of the last timed rep is validated. |
| * Do **not** mutate the reference's inputs to make the comparison easier; the grader builds its own |
| independent copy of every fixture from the same seed. |
| |
| You may repack, requantise, or re-layout the weights inside `{entry_build}` — that is untimed setup and |
| is exactly what a real serving stack does. You may allocate whatever scratch you need there too. |
| ''' |
|
|
| E1_FAITHFULNESS = '''Your kernel must actually compute the model. Specifically: |
| |
| * Do **not** skip layers, shrink the vocabulary, or approximate the attention over the KV cache. |
| * Do **not** cache logits across steps and replay them — every timed rep uses a fresh KV cache and a |
| fresh token sequence, and the final logits of the last timed rep are validated. |
| * Do **not** mutate the reference's inputs to make the comparison easier; the grader builds its own |
| independent copy of the weights and KV from the same seed. |
| |
| You may repack, requantise, or re-layout the weights inside `{entry_build}` — that is untimed setup and |
| is exactly what a real serving stack does. You may allocate whatever scratch you need there too. |
| ''' |
|
|
| E1_INTRO = '''You are writing a **megakernel**: the entire decode step of a transformer, fused into |
| (essentially) one persistent GPU kernel. This is not a "make it fast" task with a fusion hint — fusion |
| is **gated**.''' |
|
|
| E1_GATES = '''Gate 2 is set at a whole-model granularity on purpose: a decode step of this model is |
| ~40 fusable operations per layer, and an unfused implementation launches hundreds of kernels per step. |
| Allowing a handful of launches leaves room for a token copy, a flag reset, or a trivial epilogue |
| without leaving room for a per-op implementation. Gate 3 then requires that whatever you do launch is |
| *one* kernel doing essentially all of the work, so the count cannot be gamed by batching the model into |
| a few large-but-still-unfused calls.''' |
|
|
| RUN_MD = '''# {name} |
| |
| {blurb} |
| |
| * **GPUs**: {gpus} |
| * **Edit**: `/app/{module}` |
| * **Reward**: {metric}, uncapped, gated on correctness + kernels/call + dominant-kernel share |
| |
| ```bash |
| docker build -t {name} environment |
| docker run --rm --gpus device=0 -v $PWD/tests:/tests:ro {name} bash /tests/test.sh |
| ``` |
| ''' |
|
|
|
|
| def build(spec, out_root=LANE): |
| spec.validate() |
| d = pathlib.Path(out_root) / spec.name |
| (d / "environment").mkdir(parents=True, exist_ok=True) |
| (d / "tests").mkdir(parents=True, exist_ok=True) |
|
|
| src = PRELUDE_SRC.strip("\n") + "\n\n\n" + (spec.model_src or MODEL_SRC).strip("\n") |
| common = dict(name=spec.name, module=spec.module, cfg=spec.cfg, tol=spec.tol, |
| batch=spec.batch, prefill=spec.prefill_len, max_seq=spec.max_seq, |
| decode_steps=spec.decode_steps, correct_steps=spec.correct_steps, |
| prof_steps=spec.prof_steps, max_kernels=spec.max_kernels_per_step, |
| min_dom=spec.min_dominant_share, preamble=PREAMBLE, model_src=src, |
| entry_build=spec.entry_build, entry_step=spec.entry_step, |
| metric=spec.reward_metric, reward_work=spec.work_per_step(), |
| weight_bytes=int(spec.total_bytes()), floor_us=spec.floor_us()) |
|
|
| (d / "environment" / "reference.py").write_text( |
| f'"""Reference implementation — the CORRECTNESS SPEC for `{spec.name}`.\n\n' |
| f"Correct, deliberately unfused, and slow. Its speed has no bearing on your score, which is an\n" |
| f"absolute {spec.reward_metric} number. GENERATED by _mega_factory/build.py.\n" |
| f'"""\n{PREAMBLE}\n\n{src}\n') |
| (d / "tests" / "verify_env.py").write_text(VERIFY.format(**common)) |
| (d / "tests" / "test.sh").write_text( |
| "#!/bin/bash\n# GENERATED by _mega_factory/build.py.\n" |
| "set -u\nmkdir -p /logs/verifier\npython3 /tests/verify_env.py\n") |
| (d / "tests" / "test.sh").chmod(0o755) |
| (d / "environment" / "measure.py").write_text(MEASURE.format(**common)) |
| (d / "environment" / spec.module).write_text(STUB.format( |
| entry_build=spec.entry_build, entry_step=spec.entry_step, step_sig=spec.step_sig, |
| step_doc=spec.step_doc, arg_doc=spec.arg_doc, |
| stub_head=("Fuse the whole decode step into a megakernel." if spec.family == "e1" |
| else "Fuse this primitive into a single persistent kernel."))) |
| (d / "environment" / "Dockerfile").write_text(DOCKERFILE.format( |
| title=spec.title, blurb_wrapped=spec.blurb.replace("\n", "\n# "), metric=spec.reward_metric, |
| base_image=spec.base_image, module=spec.module, pip_extra=spec.pip_extra)) |
| (d / "instruction.md").write_text(INSTRUCTION.format( |
| title=spec.title, module=spec.module, tol=spec.tol, |
| max_kernels=spec.max_kernels_per_step, min_dom=spec.min_dominant_share, |
| entry_build=spec.entry_build, entry_step=spec.entry_step, step_sig=spec.step_sig, |
| metric=spec.reward_metric, step_ret=spec.step_ret, |
| unfused_note=(f" Eager torch here launches ~{spec.unfused_kernels} kernels/call — off by " |
| f"~{spec.unfused_kernels / max(spec.max_kernels_per_step, 1):.0f}x." |
| if spec.unfused_kernels else ""), |
| intro_md=(spec.intro_md or E1_INTRO).strip(), |
| spec_md=spec.spec_md.strip(), contract_md=spec.contract_md.strip(), |
| gates_md=(spec.gates_md or (E1_GATES if spec.family == "e1" else "")).strip(), |
| regime_md=spec.regime_md.strip(), correctness_md=spec.correctness_md.strip(), |
| precision_md=spec.precision_md.strip(), perf_md=spec.perf_md.strip(), |
| faithfulness=(spec.faithfulness_md |
| or (E1_FAITHFULNESS if spec.family == "e1" else FAITHFULNESS)).format( |
| entry_build=spec.entry_build).strip())) |
| (d / "task.toml").write_text(TASK_TOML.format( |
| name=spec.name, description=spec.blurb.replace("\n", " ").replace('"', "'"), |
| keywords=", ".join(f'"{k}"' for k in (spec.keywords or ["mle", "kernel-generation"])), |
| verifier_timeout_sec=spec.verifier_timeout_sec, agent_timeout_sec=spec.agent_timeout_sec, |
| memory_mb=spec.memory_mb, gpus=spec.gpus)) |
| (d / "RUN.md").write_text(RUN_MD.format(name=spec.name, blurb=spec.blurb, gpus=spec.gpus, |
| module=spec.module, metric=spec.reward_metric)) |
| for f in SHARED: |
| shutil.copy(LANE / "_factory" / "shared" / f, d / "environment" / f) |
| return d |
|
|
|
|
| if __name__ == "__main__": |
| import importlib.util |
| path = pathlib.Path(sys.argv[1]).resolve() |
| s = importlib.util.spec_from_file_location(path.stem, path) |
| mod = importlib.util.module_from_spec(s) |
| s.loader.exec_module(mod) |
| out = build(mod.SPEC, out_root=sys.argv[2] if len(sys.argv) > 2 else LANE) |
| print(f"generated {out} floor={mod.SPEC.floor_us():.0f}us metric={mod.SPEC.reward_metric}") |
|
|
