Reorganise: group 313 tasks into 17 families under tasks/, generators under tools/ (part 9)

tasks/moe/README.md

@@ -2,11 +2,13 @@
 
 Mixture-of-experts routing, permutation, grouped GEMM and combine.
 
-**15 tasks.**
+**20 tasks.**
 
 | task | metric | roofline | what the kernel does |
 |---|---|---|---|
+| [`deepseek-node-dispatch-pack`](deepseek-node-dispatch-pack/) | GB/s | 456 us | DeepSeek-V3's node-limited routing exists so that a token's experts live on at most a handful of nodes — and the payoff is collected right h… |
 | [`fp8-grouped-gemm-masked`](fp8-grouped-gemm-masked/) | TFLOP/s | 687 us | MoE decode under CUDA graphs cannot change tensor shapes between steps, so the expert GEMM is given a fixed per-expert capacity and a device… |
+| [`fsdp-reduce-scatter-bucket`](fsdp-reduce-scatter-bucket/) | GB/s | 569 us | Every FSDP backward ends by packing a whole unit's gradients into ONE reduce-scatter bucket: each parameter's rows split across the ranks an… |
 | [`grouped-fp8-gemm`](grouped-fp8-gemm/) | tokens/s | — | Write a fast grouped (mixture-of-experts) blockwise-FP8 GEMM — the MoE expert matmul: given FP8 (e4m3) grouped activations + per-expert weig… |
 | [`moe-capacity-drop-dispatch`](moe-capacity-drop-dispatch/) | GB/s | 483 us | Every MoE layer that runs on a fixed-shape expert buffer has to decide, per expert, which of the tokens routed to it actually fit: each expe… |
 | [`moe-combine-backward`](moe-combine-backward/) | GB/s | 581 us | Training an MoE layer means differentiating its last step, the weighted un-permute. The gradient splits in two directions that want opposite… |
@@ -21,3 +23,6 @@ Mixture-of-experts routing, permutation, grouped GEMM and combine.
 | [`moe-shared-expert-fused`](moe-shared-expert-fused/) | TFLOP/s | 1032 us | DeepSeek-V3 and Qwen3-MoE both keep one always-on 'shared' expert alongside the routed ones: every token goes through a dense SwiGLU FFN who… |
 | [`moe-token-permute`](moe-token-permute/) | GB/s | 205 us | Between the router and the expert GEMM every MoE layer has to physically reorder its tokens so that all rows going to the same expert are co… |
 | [`moe-topk-softmax-fused`](moe-topk-softmax-fused/) | GB/s | 277 us | The simplest and most widely deployed MoE router — Mixtral, Qwen3-MoE, GPT-OSS and every framework's default `topk_softmax`: soften the gate… |
+| [`qwen3-moe-route-align`](qwen3-moe-route-align/) | GB/s | 331 us | Qwen3-Next routes every token to 10 of 512 experts, and the router is only half the job: before the grouped expert GEMM can launch, the rout… |
+| [`swiglu-blockwise-fp8-quant`](swiglu-blockwise-fp8-quant/) | GB/s | 590 us | Between the two GEMMs of an FP8-served MLP there is exactly one elementwise step: split the fused gate/up projection, apply SwiGLU, and imme… |
+| [`zero3-param-regroup`](zero3-param-regroup/) | GB/s | 469 us | ZeRO-3 does not all-gather 200 expert matrices one at a time — it coalesces them into fixed-capacity buckets first, walking the parameter li… |

tasks/moe/deepseek-node-dispatch-pack/RUN.md

@@ -0,0 +1,42 @@
+# Running `deepseek-node-dispatch-pack`
+
+DeepSeek-V3's node-limited routing exists so that a token's experts live on at most a handful of nodes — and the payoff is collected right here, in the kernel that builds the all-to-all send buffer. A token routed to four experts on the same node is sent to that node ONCE, not four times, so the dispatch has to deduplicate every token's expert set down to a node set, rank the tokens per node, and gather the hidden states into node-major order. It is the largest tensor in the layer moved once, with an index computation that is anything but a memcpy.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/deepseek-node-dispatch-pack` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/dispatch_pack.py` |
+| **Score** | achieved **GB/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/deepseek-node-dispatch-pack --task-name deepseek-node-dispatch-pack \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/deepseek-node-dispatch-pack
+docker build -t deepseek-node-dispatch-pack environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep deepseek-node-dispatch-pack infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (GB/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/moe/deepseek-node-dispatch-pack/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/moe/deepseek-node-dispatch-pack/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast node-limited MoE dispatch (dedup + all-to-all send-buffer pack) kernel
+#
+# DeepSeek-V3's node-limited routing exists so that a token's experts live on at most a handful of nodes — and the payoff is collected right here, in the kernel that builds the all-to-all send buffer. A token routed to four experts on the same node is sent to that node ONCE, not four times, so the dispatch has to deduplicate every token's expert set down to a node set, rank the tokens per node, and gather the hidden states into node-major order. It is the largest tensor in the layer moved once, with an index computation that is anything but a memcpy.
+#
+# SCORING: correctness is a hard gate; the score is achieved GB/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    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
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+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
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY dispatch_pack.py /app/dispatch_pack.py

tasks/moe/deepseek-node-dispatch-pack/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/moe/deepseek-node-dispatch-pack/environment/dispatch_pack.py

@@ -0,0 +1,30 @@
+"""Your implementation goes here.
+
+Replace the body of `node_dispatch_pack` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved GB/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node):
+    """Node-limited MoE dispatch: dedup to node sets and pack the all-to-all send buffer.
+
+    Args:
+        x:                (T, H) bfloat16 — token hidden states.
+        topk_ids:         (T, K) int32    — the K expert ids chosen for each token (distinct within a row).
+        num_nodes:        int             — N, the number of expert-parallel nodes.
+        experts_per_node: int             — EPN; expert e lives on node e // EPN.
+
+    Returns:
+        (send_buf, src_token, node_counts, node_offsets) where
+          send_buf:     (T*M, H) bfloat16 — hidden states in NODE-MAJOR order, tokens ascending inside a node
+          src_token:    (T*M,)   int32    — the token each packed row came from
+          node_counts:  (N,)     int32    — rows destined for each node
+          node_offsets: (N+1,)   int32    — node n owns rows [node_offsets[n], node_offsets[n+1])
+        M is the (fixed) number of distinct nodes every token's experts span, so T*M rows are always
+        produced.
+    """
+    raise NotImplementedError("Implement a fast node_dispatch_pack in /app/dispatch_pack.py")

tasks/moe/deepseek-node-dispatch-pack/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/moe/deepseek-node-dispatch-pack/environment/measure.py

@@ -0,0 +1,130 @@
+"""Self-assessment tool — your correctness + achieved GB/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved GB/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import node_dispatch_pack as _ref
+from dispatch_pack import node_dispatch_pack as _agent
+
+TOL = 1e-05
+NAMES = ('send_buf', 'src_token', 'node_counts', 'node_offsets')
+
+FULL = [(28672, 7168, 8, 8, 4, 32), (20480, 7168, 8, 8, 4, 32), (40960, 4096, 8, 8, 4, 32), (28672, 7168, 6, 8, 3, 32), (28672, 5120, 8, 4, 3, 64)]
+QUICK = [(4096, 2048, 8, 8, 4, 32), (8192, 1024, 6, 4, 3, 16), (2048, 4096, 8, 8, 2, 32)]
+
+def canonical_work(T, H, K, N, M, EPN):
+    """BYTES attributed to one dispatch pack, from the SHAPE ALONE.
+
+    The unavoidable traffic: read the (T, H) bf16 hidden states once, read the (T, K) int32 routing table,
+    write the (T*M, H) bf16 send buffer and the (T*M,) int32 source map. The membership bitset, the
+    per-node counters and the prefix sum are tiny and never need to reach HBM. Node-limited routing fixes
+    the number of copies at exactly M per token, so this is a function of the shape alone. This is a
+    memory-bound kernel, so the score is achieved bandwidth against this fixed byte count.
+    """
+    return 2 * T * H + 4 * T * K + 2 * T * M * H + 4 * T * M + 4 * (2 * N + 1)
+
+def _mk(T, H, K, N, M, EPN, seed):
+    """Hidden states plus a NODE-LIMITED routing table: every token's K experts are distinct and span
+    EXACTLY M distinct nodes, which is what the node-limited router guarantees and what makes the packed
+    length T*M a function of the shape alone.
+
+    Slot j of a token goes to the (j % M)-th of its M chosen nodes, and takes the (j // M)-th entry of a
+    random permutation of that node's experts — so the K experts are always distinct.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    x = torch.randn(T, H, device="cuda", dtype=torch.bfloat16, generator=gen)
+
+    nodes = torch.rand(T, N, device="cuda", generator=gen).argsort(dim=-1)[:, :M]      # (T, M) distinct
+    perm = torch.rand(T, M, EPN, device="cuda", generator=gen).argsort(dim=-1)         # (T, M, EPN)
+    j = torch.arange(K, device="cuda")
+    m, r = j % M, j // M
+    sel_node = nodes[:, m]                                                             # (T, K)
+    sel_off = perm[:, m, r]                                                            # (T, K)
+    topk_ids = (sel_node * EPN + sel_off).to(torch.int32)
+    del nodes, perm, sel_node, sel_off
+    return x, topk_ids.contiguous(), N, EPN
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} GB/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} GB/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/moe/deepseek-node-dispatch-pack/environment/reference.py

@@ -0,0 +1,28 @@
+"""Reference implementation — the CORRECTNESS SPEC for `node_dispatch_pack`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute GB/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node):
+    """Deduplicate each token's experts to a node set, then gather node-major.
+
+    Correct and simple — it is the exact SPECIFICATION, not a performance target. It materialises a dense
+    (T, N) boolean membership matrix and lets `nonzero` do the ordering and the ranking, which is exactly
+    the multi-pass shape a real kernel replaces with one privatised histogram and one gather.
+    """
+    T, K = topk_ids.shape
+    node = topk_ids.to(torch.int64) // experts_per_node             # (T, K) node of every routed slot
+    member = torch.zeros(T, num_nodes, dtype=torch.bool, device=x.device)
+    member.scatter_(1, node, True)                                  # DEDUP: token -> set of nodes
+
+    pairs = member.t().nonzero()                    # (R, 2) = [node, token], node-major, token-ascending
+    src = pairs[:, 1]
+    send_buf = x[src]                                               # the gather
+
+    counts = member.sum(0).to(torch.int32)                          # rows per node
+    offsets = torch.cat([torch.zeros(1, dtype=torch.int32, device=x.device),
+                         torch.cumsum(counts, 0).to(torch.int32)])
+    return send_buf, src.to(torch.int32), counts, offsets

tasks/moe/deepseek-node-dispatch-pack/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/moe/deepseek-node-dispatch-pack/instruction.md

@@ -0,0 +1,219 @@
+# Write a fast node-limited MoE dispatch (dedup + all-to-all send-buffer pack) kernel
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node)`. **Read it, run it, profile it.**
+
+Write **`/app/dispatch_pack.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def node_dispatch_pack(x, topk_ids, num_nodes, experts_per_node):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+In expert-parallel serving the experts are spread over `N` nodes — expert `e` lives on node
+`e // EPN` — and before the all-to-all can run, every token's hidden state has to be copied into the send
+buffer of each node that owns one of its experts.
+
+**The dedup is the point.** A token routed to four experts that happen to live on the same node is sent to
+that node **once**. So the first step is to turn each token's `K` expert ids into a *set* of nodes:
+
+```
+node[t, j]  = topk_ids[t, j] // EPN
+member[t,n] = True iff any j has node[t, j] == n
+```
+
+DeepSeek's node-limited routing guarantees each token's experts span exactly `M` distinct nodes, so
+`member` has exactly `M` true entries per row and the packed buffer is exactly `T*M` rows long.
+
+**The packing is node-major, token-ascending inside a node:**
+
+```
+node_counts[n]  = number of tokens with member[t, n]
+node_offsets    = [0, cumsum(node_counts)]                 # (N+1,)
+```
+
+Node `n` owns rows `[node_offsets[n], node_offsets[n+1])` of `send_buf`, and those rows hold its tokens in
+**increasing token index**. Formally, if `r` is the rank of token `t` among the tokens that chose node `n`
+(counting in increasing `t`):
+
+```
+send_buf[node_offsets[n] + r, :] = x[t, :]
+src_token[node_offsets[n] + r]   = t
+```
+
+`src_token` is what the combine step later uses to scatter the expert outputs back, so it is part of the
+contract, not a debugging aid.
+
+Note what is **not** asked for: no per-expert grouping, no weights, no padding. This is the transport
+layer — one copy of each token per destination node, in the order the receiver expects.
+
+`/app/reference.py` builds a dense `(T, N)` boolean matrix and lets `nonzero` produce the ordering. That is
+the exact specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `x` | `(T, H)` | `bfloat16` | token hidden states |
+| `topk_ids` | `(T, K)` | `int32` | the `K` expert ids per token, **distinct within a row** |
+| `num_nodes` | int | | `N` |
+| `experts_per_node` | int | | `EPN`; expert `e` is on node `e // EPN` |
+
+**Return a 4-tuple in exactly this order:**
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `send_buf` | `(T*M, H)` | `bfloat16` | node-major, token-ascending inside each node |
+| `src_token` | `(T*M,)` | `int32` | source token of each packed row; compared **exactly** |
+| `node_counts` | `(N,)` | `int32` | compared **exactly** |
+| `node_offsets` | `(N+1,)` | `int32` | exclusive prefix sum, `node_offsets[N] == T*M`; compared **exactly** |
+
+`M` — the number of distinct nodes each token's experts span — is **fixed for a given call** and is what
+makes `T*M` a shape-only quantity; you can compute it, but you do not need to guess it, because
+`send_buf`'s length follows from the routing table you are given.
+
+All inputs are **read-only**; the copy is functional. `T` is **not** guaranteed to be a multiple of any
+tile size — the correctness shapes include `T = 129`.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `T`
+(tokens in the micro-batch) in 24576–49152, `H` in 4096–7168, `K` in 6–8, `N` (nodes) 4 or 8, `M`
+(distinct nodes per token) 3 or 4, `EPN` in 32–64. The send buffer is 3–4x the size of the input, so this
+call moves more bytes than any other single op in the MoE layer.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** Three of the four outputs are **integer** and are compared **bit-exactly** — one
+wrong row index anywhere and the score is 0. `send_buf` is a pure gather, so a correct kernel reproduces it
+**bit for bit**; its `1e-5` gate exists only to reject a change of dtype.
+
+The ordering rules are an exact specification, not a convention: **node-major** blocks, **ascending token
+index** inside each block. Two variants that break them were tried and both fail outright — packing
+token-major (all of token 0's copies, then token 1's) and leaving the tokens unsorted inside a node. So
+does skipping the dedup and emitting one row per expert slot, which produces `T*K` rows instead of `T*M`
+and fails on shape. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [GB/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+bytes = 2*T*H  +  4*T*K  +  2*T*M*H  +  4*T*M  +  4*(2*N+1)
+#       read x   read ids  write buf   src map   counts+offsets
+```
+
+**There is no cap and no target.** Higher GB/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean GB/s plus correctness.
+
+## Where the performance comes from
+
+One read of `x`, `M` writes of each row, and an index computation in between. The floor is
+`(1 + M)` passes over a `(T, H)`-sized tensor and nothing else, which is what the byte count assumes.
+
+The index side is small but it is where the naive version dies. The reference's `(T, N)` boolean matrix,
+`nonzero`, and the implied sort cost several passes over `T*N` and a device-wide scan. What it actually is:
+
+* a **bitset per token** — `N <= 8` nodes fit in one byte, so the dedup is `mask |= 1 << (e // EPN)` over
+  `K` ids, entirely in registers;
+* a **histogram** of `N` counters, which wants per-block privatised counters and one atomic per block per
+  node, not one atomic per token;
+* a **prefix sum over `N <= 8` numbers**, which is one warp;
+* a **rank within node**, which is the block's own offset plus a lane prefix — again no global sort.
+
+Then the gather. Each destination row is a full `H`-wide bf16 copy (8–14 KB), so use vectorised 128-bit
+accesses and give each row enough lanes to saturate; the read of `x[t]` serves all `M` of its destinations,
+so a block that has a token's row in registers or shared memory should write **all** its copies before
+moving on — reading `x` once instead of `M` times is a 25–33% bandwidth saving on its own.
+
+The destinations of one token are `M` widely separated offsets, so the writes are scattered at row
+granularity but perfectly coalesced within a row. Prefer a grid over (token tile) with the row resident,
+rather than a grid over output rows that re-reads the source.
+
+## Precision and faithfulness (read this)
+
+`x` and `send_buf` are **bfloat16** and the copy is exact — no arithmetic happens to
+the payload at all, so a correct kernel is bit-identical to the reference and the `1e-5` gate is
+effectively an exactness check. Returning `send_buf` in fp32 would change the contract (and cost twice the
+bandwidth for no benefit); returning it in fp8 would be a lossy transform of data that is supposed to be
+transported unchanged.
+
+The three integer outputs are compared **exactly**: `.float()` is lossy above 2^24 and `T*M` reaches
+200000 here, so the grader never converts them.
+
+**Where the tolerance comes from.** It is measured, and the measurement is that there is nothing to
+measure: an independent implementation — the membership computed as a per-token bitmask, the ranking from
+a scatter-add histogram plus a segmented rank instead of `nonzero`, and the gather written as an explicit
+row copy — differs from this reference by a relative Frobenius error of exactly **0.0e+00** on `send_buf`
+and reproduces all three integer outputs **bit for bit**, at every correctness shape and at a full-size
+graded shape, over several seeds. The gate is set at `1e-5` rather than at zero only so that a legitimate
+bf16 round-trip cannot fail on a denormal; it admits nothing except the specified bf16 payload, and in
+particular an fp8 or fp16 payload would miss it by 1e-3 or more.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability **sm≥90**, so fp8, TMA and wgmma/tcgen05-class instructions exist.
+  The exact part is deliberately **not** stated: query it and tune to what you actually find.
+
+```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.total_memory, p.regs_per_multiprocessor, p.max_threads_per_multi_processor
+p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters for big tiles
+```
+
+  `nvidia-smi --query-gpu=name,memory.total,clocks.max.sm --format=csv` and `nvidia-smi -q -d CLOCK`
+  give clocks; measure achieved HBM bandwidth with a large stream-copy rather than trusting a
+  datasheet figure. **Do not hardcode an SM count, a tile size derived from one, or a peak
+  FLOP/bandwidth constant** — the same submission is graded on whatever device it lands on, and the
+  score is an absolute metric, so a kernel tuned to a machine it never sees is just slower.
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/dispatch_pack.py` is the only file that is graded.** The grader imports `node_dispatch_pack` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.

tasks/moe/deepseek-node-dispatch-pack/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/deepseek-node-dispatch-pack"
+description = "DeepSeek-V3's node-limited routing exists so that a token's experts live on at most a handful of nodes — and the payoff is collected right here, in the kernel that builds the all-to-all send buffer. A token routed to four experts on the same node is sent to that node ONCE, not four times, so the dispatch has to deduplicate every token's expert set down to a node set, rank the tokens per node, and gather the hidden states into node-major order. It is the largest tensor in the layer moved once, with an index computation that is anything but a memcpy."
+authors = []
+keywords = ["mle", "kernel-generation", "moe", "expert-parallel", "dispatch", "all-to-all", "deepseek", "node-limited", "gather", "memory-bound"]
+
+[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 = 1800.0
+
+[agent]
+timeout_sec = 14400.0
+
+# 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).
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 65536
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/moe/deepseek-node-dispatch-pack/tests/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# GENERATED by _factory/build.py. python3 (not python): some CUDA bases lack the symlink.
+set -u
+mkdir -p /logs/verifier
+python3 /tests/verify_env.py

tasks/moe/deepseek-node-dispatch-pack/tests/verify_env.py

@@ -0,0 +1,197 @@
+"""deepseek-node-dispatch-pack verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of GB/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/dispatch_pack.py"
+TOL = 1e-05
+NAMES = ('send_buf', 'src_token', 'node_counts', 'node_offsets')
+
+GRADER_SHAPES = [(32768, 7168, 8, 8, 4, 32), (24576, 7168, 8, 8, 4, 32), (49152, 4096, 8, 8, 4, 32), (32768, 7168, 6, 8, 3, 32), (32768, 5120, 8, 4, 3, 64)]
+CORRECT_SHAPES = [(256, 512, 8, 4, 2, 16), (129, 256, 6, 4, 3, 8), (512, 1024, 8, 8, 4, 16), (64, 128, 4, 4, 2, 8)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(T, H, K, N, M, EPN):
+    """BYTES attributed to one dispatch pack, from the SHAPE ALONE.
+
+    The unavoidable traffic: read the (T, H) bf16 hidden states once, read the (T, K) int32 routing table,
+    write the (T*M, H) bf16 send buffer and the (T*M,) int32 source map. The membership bitset, the
+    per-node counters and the prefix sum are tiny and never need to reach HBM. Node-limited routing fixes
+    the number of copies at exactly M per token, so this is a function of the shape alone. This is a
+    memory-bound kernel, so the score is achieved bandwidth against this fixed byte count.
+    """
+    return 2 * T * H + 4 * T * K + 2 * T * M * H + 4 * T * M + 4 * (2 * N + 1)
+
+def _ref(x, topk_ids, num_nodes, experts_per_node):
+    """Deduplicate each token's experts to a node set, then gather node-major.
+
+    Correct and simple — it is the exact SPECIFICATION, not a performance target. It materialises a dense
+    (T, N) boolean membership matrix and lets `nonzero` do the ordering and the ranking, which is exactly
+    the multi-pass shape a real kernel replaces with one privatised histogram and one gather.
+    """
+    T, K = topk_ids.shape
+    node = topk_ids.to(torch.int64) // experts_per_node             # (T, K) node of every routed slot
+    member = torch.zeros(T, num_nodes, dtype=torch.bool, device=x.device)
+    member.scatter_(1, node, True)                                  # DEDUP: token -> set of nodes
+
+    pairs = member.t().nonzero()                    # (R, 2) = [node, token], node-major, token-ascending
+    src = pairs[:, 1]
+    send_buf = x[src]                                               # the gather
+
+    counts = member.sum(0).to(torch.int32)                          # rows per node
+    offsets = torch.cat([torch.zeros(1, dtype=torch.int32, device=x.device),
+                         torch.cumsum(counts, 0).to(torch.int32)])
+    return send_buf, src.to(torch.int32), counts, offsets
+
+def _mk(T, H, K, N, M, EPN, seed):
+    """Hidden states plus a NODE-LIMITED routing table: every token's K experts are distinct and span
+    EXACTLY M distinct nodes, which is what the node-limited router guarantees and what makes the packed
+    length T*M a function of the shape alone.
+
+    Slot j of a token goes to the (j % M)-th of its M chosen nodes, and takes the (j // M)-th entry of a
+    random permutation of that node's experts — so the K experts are always distinct.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    x = torch.randn(T, H, device="cuda", dtype=torch.bfloat16, generator=gen)
+
+    nodes = torch.rand(T, N, device="cuda", generator=gen).argsort(dim=-1)[:, :M]      # (T, M) distinct
+    perm = torch.rand(T, M, EPN, device="cuda", generator=gen).argsort(dim=-1)         # (T, M, EPN)
+    j = torch.arange(K, device="cuda")
+    m, r = j % M, j // M
+    sel_node = nodes[:, m]                                                             # (T, K)
+    sel_off = perm[:, m, r]                                                            # (T, K)
+    topk_ids = (sel_node * EPN + sel_off).to(torch.int32)
+    del nodes, perm, sel_node, sel_off
+    return x, topk_ids.contiguous(), N, EPN
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.node_dispatch_pack
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"},
+              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, "GB/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/moe/fsdp-reduce-scatter-bucket/RUN.md

@@ -0,0 +1,42 @@
+# Running `fsdp-reduce-scatter-bucket`
+
+Every FSDP backward ends by packing a whole unit's gradients into ONE reduce-scatter bucket: each parameter's rows split across the ranks and written rank-major, the padding rows zeroed so they cannot poison the sum, the whole thing pre-divided by the world size and cast down to the bf16 reduce dtype — and, since every element is already in registers, the per-parameter squared gradient norm the clipper needs falls out of the same pass. On an MoE unit that is hundreds of expert matrices and gigabytes of fp32 gradient, and it is what the backward waits on.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/fsdp-reduce-scatter-bucket` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/rs_copy_in.py` |
+| **Score** | achieved **GB/s** (uncapped speed leaderboard), `0` if incorrect |
+| **Grade output** | `tests/test.sh` -> `/logs/verifier/reward.json` |
+
+## Run through harbor
+
+```bash
+harbor run --dataset-path kernel-generation/kernels/fsdp-reduce-scatter-bucket --task-name fsdp-reduce-scatter-bucket \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/fsdp-reduce-scatter-bucket
+docker build -t fsdp-reduce-scatter-bucket environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep fsdp-reduce-scatter-bucket infinity
+docker cp tests v:/tests && docker exec v bash /tests/test.sh   # untouched start -> reward 0.0
+docker rm -f v
+```
+
+Use an **idle** GPU: the score is a timing measurement.
+
+## Design
+
+Correctness is a hard gate; the score is an absolute hardware metric (GB/s), so the task is
+hardware-portable and needs no gold solution, no oracle, and nothing vendored or sealed.
+
+Anti-cheat is structural: the image holds only the permitted toolchain and has no internet; the grader is
+copied in at grade time with its own private copy of the reference; and every timed rep runs on fresh inputs
+with the timed output itself validated, so memoize-and-replay fails the gate.
+
+Generated by `_factory/build.py` — edit the spec and regenerate rather than editing this task by hand.

tasks/moe/fsdp-reduce-scatter-bucket/environment/CLAUDE.md

@@ -0,0 +1,25 @@
+# Working in this environment
+
+## ⚠️ Stop background processes without killing yourself
+
+You are launched as `claude --print -- '<the task instruction>'`, so the task text — including the
+file names and commands it mentions — is on **your own** process's command line. Any command that
+finds processes by **matching that text** (`pkill -f …`, `pgrep -f … | xargs kill`, a `/proc`
+cmdline scan, `fuser -k`, `killall`) can match and **kill the agent itself**, ending your run
+(`NonZeroAgentExitCodeError`) and grading you on unfinished work.
+
+This bites whenever you background something and later stop/restart it — a **server**, a long
+**build** or **training run**, or an **ncu / nsys profiling** session.
+
+**Always** manage a background process by its **exact recorded PID**, never by a name pattern:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid   # start + record the PID
+kill "$(cat /tmp/job.pid)"; sleep 3                                 # stop (SIGTERM); -9 only if needed
+```
+
+Use `setsid` and kill the process **group** (`kill -- -"$(cat /tmp/job.pid)"`) if it spawns children.
+If you must enumerate processes, match a **unique token that is NOT anywhere in this prompt** and
+**exclude any cmdline containing `claude` or `--print`** — `pgrep -af`, and look before you kill.
+
+Full details + safe recipes: **`/app/PROCESS_MANAGEMENT.md`**.

tasks/moe/fsdp-reduce-scatter-bucket/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast FSDP reduce-scatter bucketing kernel (gradient copy-in)
+#
+# Every FSDP backward ends by packing a whole unit's gradients into ONE reduce-scatter bucket: each parameter's rows split across the ranks and written rank-major, the padding rows zeroed so they cannot poison the sum, the whole thing pre-divided by the world size and cast down to the bf16 reduce dtype — and, since every element is already in registers, the per-parameter squared gradient norm the clipper needs falls out of the same pass. On an MoE unit that is hundreds of expert matrices and gigabytes of fp32 gradient, and it is what the backward waits on.
+#
+# SCORING: correctness is a hard gate; the score is achieved GB/s (uncapped leaderboard, 0 if wrong).
+# There is no gold solution and no oracle, so nothing has to be vendored or sealed.
+#
+# TOOLCHAIN POLICY: the agent writes the kernel with Triton (+Gluon), CUDA C++ via nvcc, CUTLASS headers, or
+# the CuTe DSL. Enforcement is by ABSENCE, not by scanning: only the permitted toolchain is installed and
+# there is no internet, so nothing else can be obtained.
+#
+# GENERATED by _factory/build.py.
+FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
+
+# NOTE: every heavy layer comes FIRST and depends only on {base_image, pip_extra}, so all tasks in this
+# lane share the same cached layers. The task-specific COPYs are LAST. Do not reorder.
+RUN pip install --break-system-packages --no-cache-dir einops nvidia-cutlass-dsl && \
+    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
+# header-only CUTLASS for the agent's CUDA/CuTe route
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git
+# pre-bake Claude Code; harbor's claude_code.install() skips when present
+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
+
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+# strip apt sources LAST so harbor's post-firewall apt step is a no-op that succeeds
+RUN rm -rf /var/lib/apt/lists/* /etc/apt/sources.list /etc/apt/sources.list.d
+
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+
+# task-specific files LAST so the layers above stay shared across every task
+COPY reference.py /app/reference.py
+COPY measure.py /app/measure.py
+COPY rs_copy_in.py /app/rs_copy_in.py

tasks/moe/fsdp-reduce-scatter-bucket/environment/PROCESS_MANAGEMENT.md

@@ -0,0 +1,96 @@
+# Managing background processes — READ THIS before you `kill` anything
+
+You may start and stop background processes while iterating — a **server**, a long **build** or
+**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
+*your own agent process* and end the whole run.** This has happened repeatedly, including via a
+hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
+
+## The trap: matching task text against process command lines
+
+You were launched as roughly:
+
+```
+claude --print -- '<the entire task instruction text>'
+```
+
+The full task instruction is on **your own** process's command line, and it contains the file names
+and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
+So **any** command that finds processes by matching those strings will match — and can kill — **the
+agent itself**:
+
+```
+pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
+pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
+for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
+for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
+```
+
+It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
+a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
+the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
+immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
+worse than what you were about to finish.
+
+## The one safe rule: kill only the exact PID you recorded
+
+**Start** a background job and record its PID in a file:
+
+```bash
+nohup <your command> > /tmp/job.log 2>&1 &
+echo $! > /tmp/job.pid
+```
+
+**Stop / restart** by that exact PID — never by a name pattern:
+
+```bash
+kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
+sleep 3
+kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
+```
+
+If the job spawns workers, run it in its own process group and signal the group by its (negative)
+PGID — still an exact id, never a pattern:
+
+```bash
+setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
+kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
+```
+
+## If you ever enumerate processes, EXCLUDE the agent
+
+Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
+your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
+a unique name and match only that:
+
+```bash
+# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
+pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
+# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
+```
+
+Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
+single addition re-introduces the self-kill. Match the unique token **only**.
+
+## Freeing the GPU without going nuclear
+
+If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
+collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
+`/proc` sweep:
+
+- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
+  the process fully exits.
+- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
+  single `kill $PID` is enough.
+- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
+- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
+  confirming its cmdline is **not** `claude` / `--print`.
+
+## Rules of thumb
+
+- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
+  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
+  agent (its argv holds the prompt).
+- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
+- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
+  and your own shell**; `pgrep -af` and look before you kill.
+- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.

tasks/moe/fsdp-reduce-scatter-bucket/environment/docker-compose.yaml

@@ -0,0 +1,18 @@
+# Anti-cheat firewall overlay, merged on top of Harbor's base compose. Gives the main container
+# NET_ADMIN and runs restrict-network.sh as the entrypoint, so only DNS + the LLM API endpoints are
+# reachable (pypi/github/HF blocked). network_mode stays "public" (see task.toml) — the firewall, not
+# Docker, enforces the allowlist. mini-swe-agent is pre-installed and harbor's patched installer skips
+# the (now-blocked) network install when it is already present.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - FIREWORKS_BASE_URL=${FIREWORKS_BASE_URL:-}
+      - OPENROUTER_BASE_URL=${OPENROUTER_BASE_URL:-}
+      - OPENAI_BASE_URL=${OPENAI_BASE_URL:-}
+      - ANTHROPIC_BASE_URL=${ANTHROPIC_BASE_URL:-}
+      - LLM_BASE_URL=${LLM_BASE_URL:-}
+      - LITELLM_BASE_URL=${LITELLM_BASE_URL:-}

tasks/moe/fsdp-reduce-scatter-bucket/environment/measure.py

@@ -0,0 +1,142 @@
+"""Self-assessment tool — your correctness + achieved GB/s across a RANGE of shapes.
+
+    python /app/measure.py            # the graded regime
+    python /app/measure.py --quick    # smaller sizes for fast iteration
+
+You are scored on the **geomean achieved GB/s** — NOT one fixed size, and the leaderboard is UNCAPPED
+(higher is always better). The shapes below are a DIFFERENT sample from the same regime the grader uses, so
+optimize for GENERALITY. Work is counted with the same shape-only formula the grader uses, so the number
+printed here is computed exactly as your score is.
+
+GENERATED by _factory/build.py.
+"""
+import argparse
+import math
+import sys
+
+import torch
+
+sys.path.insert(0, "/app")
+from reference import reduce_scatter_bucket as _ref
+from rs_copy_in import reduce_scatter_bucket as _agent
+
+TOL = 1e-05
+NAMES = ('rs_in', 'sq')
+
+FULL = [(3, 2048, 1408, 32000, 8, 48), (4, 2048, 1408, 32000, 6, 24), (5, 1536, 1024, 32000, 8, 12), (3, 2048, 1792, 32768, 8, 40), (4, 1792, 1280, 48000, 8, 24)]
+QUICK = [(2, 512, 352, 8000, 4, 24), (2, 384, 256, 8000, 8, 12), (1, 640, 448, 8192, 6, 48)]
+
+def _param_grid(L, D, F, V, E):
+    """(rows, cols) of every parameter of an L-block MoE unit, from the SHAPE ALONE."""
+    R = [V]
+    C = [D]                                                # embed_tokens
+    for _ in range(L):
+        R += [D, D // 4, D // 4, D, E]                     # q, k, v, o, router
+        C += [D, D, D, D, D]
+        for _ in range(E):
+            R += [F, F, D]                                 # expert gate, up, down
+            C += [D, D, F]
+        R += [D, D]
+        C += [1, 1]                                        # the two RMSNorm gains
+    R += [D, V]
+    C += [1, D]                                            # final norm, lm_head
+    return R, C
+
+
+def canonical_work(L, D, F, V, E, W):
+    """BYTES attributed to one reduce-scatter copy-in, from the SHAPE ALONE.
+
+    Read every fp32 gradient element once (4*Ntot) and write the whole bf16 bucket once (2*W*S), where S is
+    one rank's block length, i.e. sum over parameters of ceil(rows/W)*cols. The (P,) norm vector is
+    negligible. Bandwidth-bound: the score is achieved bandwidth against that fixed byte count.
+    """
+    R, C = _param_grid(L, D, F, V, E)
+    S = sum(-(-r // W) * c for r, c in zip(R, C))
+    return 4 * sum(r * c for r, c in zip(R, C)) + 2 * W * S
+
+def _mk(L, D, F, V, E, W, seed):
+    """The fp32 gradients of an L-block MoE unit, in the module's natural parameter order.
+
+    Per block: q/k/v/o with 4x GQA, a router, E experts of (gate, up, down), and two RMSNorm gains, plus
+    the embedding table, the final norm and the LM head — 100 to 250 separate tensors at the graded sizes.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    R, C = _param_grid(L, D, F, V, E)
+    n = sum(r * c for r, c in zip(R, C))
+    grads = torch.randn(n, device="cuda", dtype=torch.float32, generator=gen) * 1e-3
+    return (grads,
+            torch.tensor(R, device="cuda", dtype=torch.int32),
+            torch.tensor(C, device="cuda", dtype=torch.int32),
+            W,
+            torch.tensor(1.0 / W, device="cuda", dtype=torch.float32))
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench(fn, reps=8, warm=3):
+    for _ in range(warm):
+        fn()
+    torch.cuda.synchronize()
+    best = float("inf")
+    for _ in range(reps):
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        fn()
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+    return best / 1e3
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--quick", action="store_true")
+    a = ap.parse_args()
+    shapes = QUICK if a.quick else FULL
+    print(f"geomean over {len(shapes)} shapes ({'quick' if a.quick else 'full'}); the grader uses "
+          f"DIFFERENT sizes in the same regime — optimize for generality\n")
+    vals, allok = [], True
+    for shp in shapes:
+        args = _mk(*shp, seed=sum(int(x) for x in shp) % 9973)
+        ref = _ref(*args)
+        try:
+            out = _agent(*args)
+        except Exception as ex:
+            print(f"  {shp}: RAISED {type(ex).__name__}: {str(ex)[:70]}")
+            allok = False
+            continue
+        ok, val, msg = _check(out, ref)
+        allok = allok and ok
+        t = _bench(lambda: _agent(*args))
+        v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} GB/s | {msg} {'ok' if ok else 'FAIL'}")
+        del args, ref, out
+        torch.cuda.empty_cache()
+    geo = math.exp(sum(math.log(max(v, 1e-9)) for v in vals) / len(vals)) if vals else 0.0
+    print(f"\n  => GEOMEAN {geo:.2f} GB/s   "
+          f"({'all correct' if allok else 'SOME WRONG — a wrong kernel scores 0, fix correctness first'})")
+    print("     This IS your score, and it is uncapped — higher is always better. Keep pushing.")
+
+
+if __name__ == "__main__":
+    main()

tasks/moe/fsdp-reduce-scatter-bucket/environment/reference.py

@@ -0,0 +1,34 @@
+"""Reference implementation — the CORRECTNESS SPEC for `reduce_scatter_bucket`.
+
+This is correct but slow. It defines exactly what your kernel must reproduce; its speed has no
+bearing on your score, which is an absolute GB/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def reduce_scatter_bucket(grads, rows, cols, world_size, pre_divide):
+    """Pack the bucket one parameter at a time, in fp32.
+
+    Correct and simple — it is the SPECIFICATION, not a performance target. It syncs the shape tables to the
+    host, zero-fills the whole bucket, and then makes a separate pass per parameter for the copy and another
+    for the norm.
+    """
+    W = world_size
+    R = rows.tolist()                                   # device -> host sync on the critical path
+    C = cols.tolist()
+    S = sum(-(-r // W) * c for r, c in zip(R, C))
+    rs_in = torch.zeros(W, S, device=grads.device, dtype=torch.bfloat16)
+    sq = torch.empty(len(R), device=grads.device, dtype=torch.float32)
+
+    src_off = 0
+    dst_off = 0
+    for p, (r, c) in enumerate(zip(R, C)):
+        g = grads[src_off:src_off + r * c]
+        sq[p] = (g * g).sum()                           # squared norm of the RAW gradient
+        sh = -(-r // W)                                 # rows each rank gets, padded up
+        blk = torch.zeros(W * sh, c, device=grads.device, dtype=torch.bfloat16)
+        blk[:r] = (g.view(r, c) * pre_divide).bfloat16()        # pre-divide, then cast
+        rs_in[:, dst_off:dst_off + sh * c] = blk.view(W, sh * c)
+        src_off += r * c
+        dst_off += sh * c
+    return rs_in, sq

tasks/moe/fsdp-reduce-scatter-bucket/environment/restrict-network.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Outbound firewall (anti-cheat): allow ONLY DNS, loopback, docker-internal networks, and the LLM API
+# endpoints the agent needs. Everything else is dropped — in particular pypi, github, and huggingface,
+# so the agent cannot `pip install vllm` / `pip install sglang` / clone the reference moe_align kernel and
+# copy it. torch + triton are already in the image, and mini-swe-agent is pre-installed (harbor's patched
+# installer skips the network install when it is already present), so no package index is needed at run time.
+#
+# Runs as the container ENTRYPOINT before the CMD. iptables rules are network-namespace-wide, so they also
+# apply to the agent's `docker exec` commands. Requires cap_add: NET_ADMIN.
+set -uo pipefail
+
+# LLM API endpoints the agent may reach. Extend at launch via ALLOWED_HOSTS=host1,host2 (no scheme).
+API_HOSTS=(
+    api.fireworks.ai
+    openrouter.ai openrouter.io
+    api.openai.com api.anthropic.com generativelanguage.googleapis.com
+    api.together.xyz integrate.api.nvidia.com api.moonshot.cn api.kimi.com
+)
+# Auto-allow hosts from any *_BASE_URL / *_ENDPOINT env var (ANTHROPIC_BASE_URL, OPENAI_BASE_URL, …).
+CUSTOM=()
+while IFS='=' read -r n v; do
+    case "$n" in
+        *_BASE_URL|*_URL|*_ENDPOINT)
+            [ -n "$v" ] && CUSTOM+=("$(echo "$v" | sed 's|.*://||; s|[:/].*||')") ;;
+    esac
+done < <(env)
+if [ -n "${ALLOWED_HOSTS:-}" ]; then IFS=',' read -ra E <<< "$ALLOWED_HOSTS"; CUSTOM+=("${E[@]}"); fi
+ALL_HOSTS=("${API_HOSTS[@]}" ${CUSTOM[@]+"${CUSTOM[@]}"})
+
+if iptables -L OUTPUT -n >/dev/null 2>&1; then
+    echo "restrict-network: applying outbound allowlist firewall..."
+    iptables -F OUTPUT 2>/dev/null || true
+    iptables -A OUTPUT -o lo -j ACCEPT
+    iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+    iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
+    iptables -A OUTPUT -d 10.0.0.0/8 -j ACCEPT
+    iptables -A OUTPUT -d 172.16.0.0/12 -j ACCEPT
+    iptables -A OUTPUT -d 192.168.0.0/16 -j ACCEPT
+    iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT
+    for h in "${ALL_HOSTS[@]}"; do
+        for ip in $(getent ahosts "$h" 2>/dev/null | awk '{print $1}' | sort -u); do
+            iptables -A OUTPUT -d "$ip" -j ACCEPT
+        done
+    done
+    iptables -A OUTPUT -j REJECT --reject-with icmp-admin-prohibited
+    echo "restrict-network: outbound locked to DNS + LLM endpoints; pypi/github/HF blocked."
+else
+    echo "restrict-network: WARNING — iptables unavailable (need cap_add NET_ADMIN); NOT firewalled." >&2
+fi
+
+exec "$@"

tasks/moe/fsdp-reduce-scatter-bucket/environment/rs_copy_in.py

@@ -0,0 +1,29 @@
+"""Your implementation goes here.
+
+Replace the body of `reduce_scatter_bucket` with a FAST implementation that reproduces the output of /app/reference.py
+(same signature, same numerics within tolerance) but is much faster — see /app/instruction.md.
+Run `python /app/measure.py` to check your correctness and achieved GB/s.
+
+You may add helper modules, Triton kernels, CUDA extensions, caches, etc. — only this function's name,
+signature and returned value are fixed by the contract.
+"""
+
+
+def reduce_scatter_bucket(grads, rows, cols, world_size, pre_divide):
+    """Pack an FSDP unit's gradients into the reduce-scatter input bucket.
+
+    Args:
+        grads:      (Ntot,) float32 — the unsharded gradients, each parameter row-major, concatenated in
+                                      parameter order with NO padding.
+        rows:       (P,)    int32   — dim-0 length of each parameter.
+        cols:       (P,)    int32   — dim-1 length of each parameter (1 for the 1-D ones).
+        world_size: int             — number of ranks the bucket is scattered to.
+        pre_divide: ()      float32 — 0-dim tensor, the pre-divide factor (1/world_size) the values are
+                                      MULTIPLIED by before the cast.
+
+    Returns:
+        (rs_in, sq) where
+          rs_in: (world_size, S) bfloat16 — the reduce-scatter input, rank-major, padding rows EXACTLY zero
+          sq:    (P,)            float32  — sum of squares of each parameter's RAW (undivided) gradient
+    """
+    raise NotImplementedError("Implement a fast reduce_scatter_bucket in /app/rs_copy_in.py")

tasks/moe/fsdp-reduce-scatter-bucket/instruction.md

@@ -0,0 +1,246 @@
+# Write a fast FSDP reduce-scatter bucketing kernel (gradient copy-in)
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `reduce_scatter_bucket(grads, rows, cols, world_size, pre_divide)`. **Read it, run it, profile it.**
+
+Write **`/app/rs_copy_in.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def reduce_scatter_bucket(grads, rows, cols, world_size, pre_divide):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+Parameter `p` is a `(rows[p], cols[p])` row-major matrix (1-D parameters have `cols = 1`) and
+its gradient sits in `grads` at the offset given by the running sum of `rows*cols`. The reduce-scatter wants
+that same data **rank-major**, with each parameter's rows split evenly across the `world_size` ranks:
+
+```
+sh[p]  = ceil(rows[p] / world_size)         # rows each rank contributes for parameter p
+S      = sum over p of sh[p]*cols[p]        # length of ONE rank's block
+off[p] = sum over q < p of sh[q]*cols[q]
+```
+
+For every parameter, view its gradient as `(rows[p], cols[p])`, pad it down to `world_size*sh[p]` rows with
+**exact zeros**, scale, cast, and write the `r`-th row block into rank `r`'s slot:
+
+```
+padded[i, j] = grad_p[i, j] * pre_divide   rounded to bf16     for i <  rows[p]
+padded[i, j] = 0                                               for i >= rows[p]
+rs_in[r, off[p] : off[p] + sh[p]*cols[p]] = padded[r*sh[p] : (r+1)*sh[p]].reshape(-1)
+```
+
+The zeros are not cosmetic: the reduce-scatter sums the ranks' buckets elementwise, so a padding slot that
+holds stale memory corrupts a real parameter's gradient on whichever rank owns that slot.
+
+`pre_divide` is a **0-dim fp32 tensor** holding `1/world_size`, and the spec is a **multiply** by it in
+fp32 followed by a single round to bf16 — not a divide, and not a cast followed by a scale. That makes the
+result bit-exact and identical for every correct implementation.
+
+Alongside the copy, report each parameter's squared gradient norm, computed on the **raw** gradient before
+the pre-divide, accumulated in fp32:
+
+```
+sq[p] = sum over all rows[p]*cols[p] elements of  grad_p^2
+```
+
+Every element is already in registers for the copy, so the norm is free if you fuse it and a second full
+pass over 2 GB if you do not.
+
+`/app/reference.py` zero-fills the whole bucket, then makes one pass per parameter for the norm and another
+for the copy. That is the exact specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `grads` | `(Ntot,)` | `float32` | unsharded gradients, parameter order, row-major, no padding |
+| `rows` | `(P,)` | `int32` | dim-0 length of each parameter |
+| `cols` | `(P,)` | `int32` | dim-1 length of each parameter; `1` for the 1-D ones |
+| `world_size` | scalar | `int` (python) | number of ranks; 12, 24, 40 or 48 |
+| `pre_divide` | `()` | `float32` | 0-dim tensor holding `1/world_size`; **multiply** by it |
+
+**Return** a 2-tuple `(rs_in, sq)` **in that order**:
+
+| out | shape | dtype | notes |
+|-----|-------|-------|-------|
+| `rs_in` | `(world_size, S)` | `bfloat16` | rank-major bucket; padding rows **exactly 0** |
+| `sq` | `(P,)` | `float32` | squared norm of each parameter's **raw** gradient, fp32 accumulation |
+
+`rows[p]` is **not** a multiple of `world_size` at any graded shape, and the router (`E` rows) and the norm
+gains are single-column parameters, one of which has fewer rows than there are ranks — its later ranks
+contribute nothing but zeros. All inputs are read-only; the call is functional.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L`
+(blocks in the FSDP unit) 3–6, `D` 1536–2048, `F` (per-expert intermediate) 1024–1792, `V` 32000–48000, `E`
+(experts per block) 6–12, and a world size of 12, 24, 40 or 48 — the shard-group sizes you get from 2–6
+nodes, none of which divide the row counts. That is **330 M – 480 M fp32 gradient elements**, 100–250
+separate tensors dominated by the expert matrices, and 2.0–2.9 GB of traffic per call. The reduce-scatter
+cannot start until this finishes, so it sits directly on the backward's critical path.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** **Both** returned values must match the reference within **relative error `1e-5`** at
+every graded shape, including the timed ones; the grader scores the **worse** of the two.
+
+`rs_in` carries no rounding freedom at all — the pre-divide is a multiply by a given fp32 constant followed
+by one round to bf16 — so a correct kernel reproduces it **bit for bit** and the gate on it is effectively
+exact. The whole `1e-5` budget exists for `sq`, whose fp32 accumulation order is yours to choose.
+
+That gate is **measured**, and every shortcut misses it by orders of magnitude: writing the bucket in
+parameter-major instead of rank-major order scores **1.41**, leaving the shard padding holding stale memory
+scores **1.79**, skipping the pre-divide scores **23.0**, and accumulating `sq` in bf16 instead of fp32
+scores **9.5e-4**, still 95x the tolerance. A wrong kernel scores **0**, no matter how fast.
+
+**2. Performance — this is your score, and it is an UNCAPPED leaderboard.**
+
+```
+reward = geomean over graded shapes of ( canonical_work(shape) / your_runtime )   [GB/s]
+reward = 0   if the submission is wrong at any graded shape
+```
+
+`canonical_work` depends **only on the shape**, never on how you implemented it, so every submission is
+credited the same work and this is a pure speed ranking in useful units:
+
+```
+Ntot = sum over p of  rows[p] * cols[p]                # the unsharded gradients
+S    = sum over p of  ceil(rows[p] / W) * cols[p]      # one rank's block of the bucket
+
+canonical_work(L, D, F, V, E, W) = 4*Ntot + 2*W*S      # read the fp32 gradients once, write the bf16 bucket once
+
+`rows`/`cols` are the parameter grid of an L-block MoE unit (q/k/v/o with 4x GQA, a router, E experts of
+gate/up/down, two norm gains, plus the embedding table, the final norm and the LM head), so the byte count
+is a function of the shape and never of the data.
+```
+
+**There is no cap and no target.** Higher GB/s is always a strictly better score, so **push the
+performance as hard as you can**. Getting a correct implementation is the *start* of the task, not the end of
+it. Once correct, spend the entire remainder of your budget profiling and optimising, re-checking correctness
+after every change. **Use your full time budget.**
+
+Run **`python /app/measure.py`** at any point to see your per-shape and geomean GB/s plus correctness.
+
+## Where the performance comes from
+
+Six bytes per gradient element — one fp32 read, one bf16 write — so this is a bandwidth
+kernel, and your score is achieved bandwidth against that count.
+
+The reference throws most of that away: `torch.zeros(W, S)` writes the entire bucket before anything real
+lands in it, every parameter then allocates its own zeroed `(W*sh, cols)` staging block, and the squared
+norm is a completely separate reduction pass over the same 2 GB.
+
+The kernel to write is **one launch that reads `grads` once**. For a tile of consecutive source elements,
+the parameter `p` is a binary search over the offset table and then
+
+```
+i = local / cols[p] ,  j = local % cols[p]        # row, column within the parameter
+r = i / sh[p]                                    # the rank that owns this row
+dst = r*S + off[p] + (i - r*sh[p])*cols[p] + j
+```
+
+which is contiguous in `dst` as long as the tile stays inside one `(p, r)` pair — so both sides vectorise.
+
+Where the time goes:
+
+- **Do not pre-zero the bucket.** The padding is well under 1% of `S`; emit those zeros from the same pass
+  that writes the real values, or write them with a tiny separate kernel over just the padding slots.
+- **Fuse the norm.** `sq[p]` is a segmented reduction over exactly the elements you already loaded. Reduce
+  in registers, then across the block, then one atomic per parameter per block — the segments are enormous
+  (millions of elements) so contention is not the issue, the second read of HBM is.
+- **fp32 accumulation, and mind the order.** The tolerance is tight enough that a bf16 or fp16 accumulator
+  fails; a per-thread fp32 accumulator followed by a tree reduction is both faster and more accurate than a
+  serial one.
+- **The size spread is the scheduling problem.** The expert matrices are all the same size and dominate, but
+  each block also carries a router and two norm gains that are a few kilobytes. Grid by tiles, not by
+  parameter.
+- **Avoid the host sync.** The offset tables depend only on `rows`, `cols` and `world_size`, so they can be
+  built on the device once per shape and reused — shape-keyed caching is explicitly allowed.
+
+## Precision and faithfulness (read this)
+
+Gradients arrive **fp32** and the bucket is **bfloat16** — that is the real FSDP mixed
+precision setting, where the reduce-scatter runs in the reduce dtype to halve the wire traffic.
+
+The scaling is specified exactly to remove any rounding freedom: multiply the fp32 value by the 0-dim fp32
+`pre_divide` tensor, then round **once** to bf16. Do not divide by `world_size` (a divide and a
+reciprocal-multiply disagree in the last fp32 ulp, and about one element in 2^16 then rounds to a different
+bf16 value), and do not cast first and scale afterwards. With the multiply as specified, every correct
+kernel produces bit-identical `rs_in`.
+
+`sq` must be accumulated in **fp32**. It is a sum of up to 6e7 squares per parameter, so the accumulation
+order is visible; that is what the tolerance is for.
+
+**fp8 is not useful here** and is not expected: the output dtype is fixed at bf16 by the contract.
+
+**Where the tolerance comes from (measured, not guessed).** An independent implementation — the bucket
+built by a single vectorised `index_copy_` from a precomputed destination-index map with no per-parameter
+staging, and `sq` accumulated by a chunked `(g*g).view(-1, 4096).sum(0).sum()` tree instead of a flat
+`sum()` — agrees with the reference to **`E = 8.0e-8`** worst over the correctness shapes and a full graded
+shape, entirely in `sq`; `rs_in` matched **bit for bit** (`0.0`) everywhere. Two further fp32 reduction
+orders were checked at a graded shape: the reference against a float64 sum, **1.4e-8**, and a deliberately
+poor 256-chain fp32 accumulation, **1.6e-8**. Every fp32 accumulation order tried lands within an order of
+magnitude of 1e-8, so the gate is set at **`1e-5`** — 125x above the measured floor, which leaves room for
+whatever reduction tree you pick, and still 95x below the cheapest shortcut.
+
+Drop-the-feature measurements, all far outside it: parameter-major instead of rank-major placement
+**D = 1.41**; shard padding left holding stale memory **D = 1.79**; no pre-divide **D = 23.0**; `sq`
+accumulated in bf16 **D = 9.5e-4**.
+
+### What the tolerance does NOT permit
+
+The tolerance exists **only** to absorb low-precision arithmetic noise. You are responsible for a **faithful
+implementation of the specified computation**. It is not a budget to spend on approximation. The following
+are wrong answers even if they happen to land inside the tolerance at some shape:
+
+- changing the algorithm to something that merely *approximates* the spec (dropping terms, truncating a
+  series, low-rank or sketched substitutes, skipping a correction term);
+- shortening the computation (fewer iterations/steps than specified, early exit on a heuristic, subsampling
+  or striding over the sequence, ignoring positions whose contribution "looks small");
+- computing at a coarser granularity than the spec (sharing a decay, scale, or normaliser across positions
+  that the spec gives their own);
+- anything whose error **grows** with sequence length, batch, or head count.
+
+A faithful bf16/fp8 kernel's error is *noise*: it stays flat as the problem grows and sits an order of
+magnitude below the gate. An approximation's error is *bias*: it scales with the problem. The graded shapes
+are deliberately large, so the difference shows up.
+
+## What's available
+
+- **Triton 3.6** (with Gluon), **CUDA C++ via `nvcc`** (`torch.utils.cpp_extension.load` for an inline
+  extension), header-only **CUTLASS** at `/opt/cutlass/include`, and the **CuTe DSL**
+  (`nvidia-cutlass-dsl`). C++ / CuTe DSL is the encouraged route; Triton is fully supported.
+- `torch` 2.11 (CUDA 12.8) and `einops` for bookkeeping.
+- A GPU with compute capability **sm≥90**, so fp8, TMA and wgmma/tcgen05-class instructions exist.
+  The exact part is deliberately **not** stated: query it and tune to what you actually find.
+
+```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.total_memory, p.regs_per_multiprocessor, p.max_threads_per_multi_processor
+p.shared_memory_per_block_optin   # opt-in dynamic smem, the number that matters for big tiles
+```
+
+  `nvidia-smi --query-gpu=name,memory.total,clocks.max.sm --format=csv` and `nvidia-smi -q -d CLOCK`
+  give clocks; measure achieved HBM bandwidth with a large stream-copy rather than trusting a
+  datasheet figure. **Do not hardcode an SM count, a tile size derived from one, or a peak
+  FLOP/bandwidth constant** — the same submission is graded on whatever device it lands on, and the
+  score is an absolute metric, so a kernel tuned to a machine it never sees is just slower.
+- **No internet access.** `pip install` and cloning repos are blocked. Everything you are permitted to use is
+  already installed, and no library implementation of this kernel exists on the machine.
+- Manage any long-running background job (a build, an `ncu`/`nsys` profile) by its **recorded PID** — see
+  `/app/CLAUDE.md` and `/app/PROCESS_MANAGEMENT.md`.
+
+## How the grading actually runs (so there are no surprises)
+
+- **`/app/rs_copy_in.py` is the only file that is graded.** The grader imports `reduce_scatter_bucket` from it and reads nothing
+  else from `/app`.
+- **The grader is not on this machine while you work.** It is copied in only after your session ends and it
+  carries its **own private copy of the reference** and its own input generator. Editing `/app/reference.py`
+  or `/app/measure.py` is allowed — they are yours to experiment with — but it has **no effect whatsoever on
+  your score**. Do not spend budget on them.
+- **Every timed repetition uses freshly generated inputs**, and the output of a timed call is itself checked
+  against the reference. Caching or memoizing a result and replaying it fails the correctness gate rather
+  than producing a fast measurement. Ordinary shape-keyed JIT/autotune caching is fine and is not penalised.
+- **The timed shapes are correctness-checked too.** Being correct only at the small shapes scores **0**.
+- Inputs are random each grade and the graded shapes are not the ones in `measure.py`.

tasks/moe/fsdp-reduce-scatter-bucket/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/fsdp-reduce-scatter-bucket"
+description = "Every FSDP backward ends by packing a whole unit's gradients into ONE reduce-scatter bucket: each parameter's rows split across the ranks and written rank-major, the padding rows zeroed so they cannot poison the sum, the whole thing pre-divided by the world size and cast down to the bf16 reduce dtype — and, since every element is already in registers, the per-parameter squared gradient norm the clipper needs falls out of the same pass. On an MoE unit that is hundreds of expert matrices and gigabytes of fp32 gradient, and it is what the backward waits on."
+authors = []
+keywords = ["mle", "kernel-generation", "fsdp", "zero", "reduce-scatter", "bucketing", "gradient", "mixed-precision", "moe", "distributed", "training", "memory-bound"]
+
+[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 = 1800.0
+
+[agent]
+timeout_sec = 14400.0
+
+# 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).
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 65536
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/moe/fsdp-reduce-scatter-bucket/tests/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# GENERATED by _factory/build.py. python3 (not python): some CUDA bases lack the symlink.
+set -u
+mkdir -p /logs/verifier
+python3 /tests/verify_env.py

tasks/moe/fsdp-reduce-scatter-bucket/tests/verify_env.py

@@ -0,0 +1,215 @@
+"""fsdp-reduce-scatter-bucket verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of GB/s otherwise
+
+GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.
+
+There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
+by construction and nothing has to be vendored, sealed, or re-benchmarked.
+
+CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
+shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
+scores 0.
+
+ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
+timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
+result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
+throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.
+
+WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
+submissions are credited identically and the ranking is a pure speed ranking.
+"""
+import importlib.util
+import json
+import math
+import os
+import sys
+import traceback
+
+import torch
+
+REWARD_DIR = "/logs/verifier"
+MODULE_PATH = "/app/rs_copy_in.py"
+TOL = 1e-05
+NAMES = ('rs_in', 'sq')
+
+GRADER_SHAPES = [(4, 2048, 1408, 32000, 8, 24), (3, 2048, 1408, 32000, 12, 12), (6, 1536, 1024, 32000, 8, 48), (4, 2048, 1792, 32768, 6, 40), (5, 1792, 1280, 48000, 8, 24)]
+CORRECT_SHAPES = [(1, 128, 96, 512, 3, 12), (2, 100, 70, 257, 2, 24), (2, 64, 48, 129, 5, 48), (1, 96, 56, 401, 4, 40), (1, 32, 24, 97, 2, 12)]
+
+sys.path.insert(0, "/app")
+
+def _param_grid(L, D, F, V, E):
+    """(rows, cols) of every parameter of an L-block MoE unit, from the SHAPE ALONE."""
+    R = [V]
+    C = [D]                                                # embed_tokens
+    for _ in range(L):
+        R += [D, D // 4, D // 4, D, E]                     # q, k, v, o, router
+        C += [D, D, D, D, D]
+        for _ in range(E):
+            R += [F, F, D]                                 # expert gate, up, down
+            C += [D, D, F]
+        R += [D, D]
+        C += [1, 1]                                        # the two RMSNorm gains
+    R += [D, V]
+    C += [1, D]                                            # final norm, lm_head
+    return R, C
+
+
+def canonical_work(L, D, F, V, E, W):
+    """BYTES attributed to one reduce-scatter copy-in, from the SHAPE ALONE.
+
+    Read every fp32 gradient element once (4*Ntot) and write the whole bf16 bucket once (2*W*S), where S is
+    one rank's block length, i.e. sum over parameters of ceil(rows/W)*cols. The (P,) norm vector is
+    negligible. Bandwidth-bound: the score is achieved bandwidth against that fixed byte count.
+    """
+    R, C = _param_grid(L, D, F, V, E)
+    S = sum(-(-r // W) * c for r, c in zip(R, C))
+    return 4 * sum(r * c for r, c in zip(R, C)) + 2 * W * S
+
+def _ref(grads, rows, cols, world_size, pre_divide):
+    """Pack the bucket one parameter at a time, in fp32.
+
+    Correct and simple — it is the SPECIFICATION, not a performance target. It syncs the shape tables to the
+    host, zero-fills the whole bucket, and then makes a separate pass per parameter for the copy and another
+    for the norm.
+    """
+    W = world_size
+    R = rows.tolist()                                   # device -> host sync on the critical path
+    C = cols.tolist()
+    S = sum(-(-r // W) * c for r, c in zip(R, C))
+    rs_in = torch.zeros(W, S, device=grads.device, dtype=torch.bfloat16)
+    sq = torch.empty(len(R), device=grads.device, dtype=torch.float32)
+
+    src_off = 0
+    dst_off = 0
+    for p, (r, c) in enumerate(zip(R, C)):
+        g = grads[src_off:src_off + r * c]
+        sq[p] = (g * g).sum()                           # squared norm of the RAW gradient
+        sh = -(-r // W)                                 # rows each rank gets, padded up
+        blk = torch.zeros(W * sh, c, device=grads.device, dtype=torch.bfloat16)
+        blk[:r] = (g.view(r, c) * pre_divide).bfloat16()        # pre-divide, then cast
+        rs_in[:, dst_off:dst_off + sh * c] = blk.view(W, sh * c)
+        src_off += r * c
+        dst_off += sh * c
+    return rs_in, sq
+
+def _mk(L, D, F, V, E, W, seed):
+    """The fp32 gradients of an L-block MoE unit, in the module's natural parameter order.
+
+    Per block: q/k/v/o with 4x GQA, a router, E experts of (gate, up, down), and two RMSNorm gains, plus
+    the embedding table, the final norm and the LM head — 100 to 250 separate tensors at the graded sizes.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+    R, C = _param_grid(L, D, F, V, E)
+    n = sum(r * c for r, c in zip(R, C))
+    grads = torch.randn(n, device="cuda", dtype=torch.float32, generator=gen) * 1e-3
+    return (grads,
+            torch.tensor(R, device="cuda", dtype=torch.int32),
+            torch.tensor(C, device="cuda", dtype=torch.int32),
+            W,
+            torch.tensor(1.0 / W, device="cuda", dtype=torch.float32))
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
+    if out is None or len(out) != len(NAMES):
+        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
+    per = []
+    for n, a, b in zip(NAMES, out, ref):
+        if a is None or tuple(a.shape) != tuple(b.shape):
+            return False, 1.0, f"{n} bad shape"
+        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
+            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
+            bad = int((a != b).sum())
+            if bad:
+                return False, 1.0, f"{n}: {bad} elements differ"
+            continue
+        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
+    if not per:
+        return True, 0.0, "all integer outputs exact"
+    wn, wv = max(per, key=lambda x: x[1])
+    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"
+
+
+def _bench_fresh(fn, mkargs, reps=5, warm=3):
+    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
+    wargs = mkargs(0)
+    for _ in range(warm):
+        fn(*wargs)
+    torch.cuda.synchronize()
+    del wargs
+    torch.cuda.empty_cache()
+
+    best, timed_ok = float("inf"), True
+    for i in range(reps):
+        args = mkargs(10_000 + i)
+        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
+        s.record()
+        out = fn(*args)
+        e.record()
+        torch.cuda.synchronize()
+        best = min(best, s.elapsed_time(e))
+        if i == reps - 1:
+            timed_ok = _check(out, _ref(*args))[0]
+        del args, out
+        torch.cuda.empty_cache()
+    return best / 1e3, timed_ok
+
+
+def _geomean(xs):
+    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0
+
+
+def main():
+    details, correct_gate, geo = {}, False, 0.0
+    try:
+        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
+        m = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(m)
+        fn = m.reduce_scatter_bucket
+
+        corr_ok, msg = True, ""
+        for i, shp in enumerate(CORRECT_SHAPES):
+            args = _mk(*shp, seed=10 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
+                break
+            del args
+            torch.cuda.empty_cache()
+        details["correct_msg"] = msg or "all correctness shapes pass"
+
+        vals, per_shape, perf_ok = [], [], corr_ok
+        for i, shp in enumerate(GRADER_SHAPES):
+            args = _mk(*shp, seed=100 + i)
+            ok, val, m_ = _check(fn(*args), _ref(*args))
+            if not ok:
+                perf_ok = False
+            del args
+            torch.cuda.empty_cache()
+            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
+            if not timed_ok:
+                perf_ok = False
+            v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3),
+                              "check": m_, "timed_ok": timed_ok})
+        geo = _geomean(vals)
+        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
+        correct_gate = corr_ok and perf_ok
+    except Exception as e:
+        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
+        details["trace"] = traceback.format_exc()[-800:]
+
+    reward = round(geo, 4) if correct_gate else 0.0
+    os.makedirs(REWARD_DIR, exist_ok=True)
+    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
+               "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"},
+              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, "GB/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()