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

tasks/quantization-gemm/zamba-shared-attn-lora-backward/RUN.md

@@ -0,0 +1,42 @@
+# Running `zamba-shared-attn-lora-backward`
+
+Fine-tuning a Zamba-style hybrid means differentiating a block that was called at L different depths with one frozen weight and L different rank-64 adapters, over an input that was a concatenation of the depth's residual stream and the model's original embedding. So the embedding's gradient is a sum over EVERY depth, each adapter's gradient is a pair of tall-skinny reductions over the token axis, and the frozen weight is read L times and never updated.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/zamba-shared-attn-lora-backward` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/shared_qkv_bwd.py` |
+| **Score** | achieved **TFLOP/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/zamba-shared-attn-lora-backward --task-name zamba-shared-attn-lora-backward \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/zamba-shared-attn-lora-backward
+docker build -t zamba-shared-attn-lora-backward environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep zamba-shared-attn-lora-backward 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 (TFLOP/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/quantization-gemm/zamba-shared-attn-lora-backward/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/quantization-gemm/zamba-shared-attn-lora-backward/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast backward kernel for the shared-attention-block QKV projection
+#
+# Fine-tuning a Zamba-style hybrid means differentiating a block that was called at L different depths with one frozen weight and L different rank-64 adapters, over an input that was a concatenation of the depth's residual stream and the model's original embedding. So the embedding's gradient is a sum over EVERY depth, each adapter's gradient is a pair of tall-skinny reductions over the token axis, and the frozen weight is read L times and never updated.
+#
+# SCORING: correctness is a hard gate; the score is achieved TFLOP/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 shared_qkv_bwd.py /app/shared_qkv_bwd.py

tasks/quantization-gemm/zamba-shared-attn-lora-backward/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/quantization-gemm/zamba-shared-attn-lora-backward/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/quantization-gemm/zamba-shared-attn-lora-backward/environment/measure.py

@@ -0,0 +1,131 @@
+"""Self-assessment tool — your correctness + achieved TFLOP/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 TFLOP/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 shared_qkv_backward as _ref
+from shared_qkv_bwd import shared_qkv_backward as _agent
+
+TOL = 0.006
+NAMES = ('dh', 'demb', 'dlora_a', 'dlora_b')
+
+FULL = [(6, 3584, 2048, 64), (4, 3584, 2560, 64), (8, 1792, 2048, 32), (6, 2560, 2048, 128), (4, 5120, 2048, 64)]
+QUICK = [(4, 512, 1024, 32), (2, 1024, 512, 16), (6, 256, 1024, 64)]
+
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one backward call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add:
+      * ONE pass of the big shared shape: dxc = dqkv @ w_qkv                (the base weight is frozen,
+        so there is no dw_qkv and no second pass over it)
+      * THREE passes of the (2*Dm, r) adapter shape: recompute mid = xc @ lora_a.T (the LoRA output is a
+        forward temporary), dxc += dmid @ lora_a, dlora_a = dmid.T @ xc
+      * TWO passes of the (3*Dm, r) adapter shape: dmid = dqkv @ lora_b, dlora_b = dqkv.T @ mid
+    The concatenation, the split of dxc and the sum of demb over depths are O(L*T*Dm) data movement and
+    are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm)
+                + 3 * (2 * T * (2 * Dm) * r)
+                + 2 * (2 * T * (3 * Dm) * r))
+
+def _mk(L, T, Dm, r, seed):
+    """Saved forward inputs plus the incoming gradient. The adapters are scaled so the LoRA delta is a real
+    but minority part of the forward (RMS `16/r` of the base projection), which is what a trained LoRA
+    looks like."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    dqkv = rnd(L, T, 3 * Dm)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r, dqkv
+
+
+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 / 1e12 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} TFLOP/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} TFLOP/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/quantization-gemm/zamba-shared-attn-lora-backward/environment/reference.py

@@ -0,0 +1,27 @@
+"""Reference implementation — the CORRECTNESS SPEC for `shared_qkv_backward`.
+
+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 TFLOP/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def _shared_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """The fp32 forward of `zamba-shared-attn-lora-qkv`, differentiable. Autograd through THIS defines
+    every gradient this task asks for."""
+    L, T, Dm = h.shape
+    outs = []
+    for l in range(L):
+        xc = torch.cat([h[l], emb], dim=-1)                     # (T, 2*Dm)  [state | embedding]
+        base = xc @ w_qkv.t()
+        delta = (xc @ lora_a[l].t()) @ lora_b[l].t()
+        outs.append(base + scaling * delta)
+    return torch.stack(outs, 0)
+
+
+def shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv):
+    """The baseline re-runs the fp32 forward under autograd. The shared weight is FROZEN: only the two
+    activations and the L adapters receive gradients."""
+    ins = [t.detach().clone().float().requires_grad_(True) for t in (h, emb, lora_a, lora_b)]
+    o = _shared_qkv(ins[0], ins[1], w_qkv.float(), ins[2], ins[3], scaling)
+    return torch.autograd.grad(o, ins, dqkv.float())

tasks/quantization-gemm/zamba-shared-attn-lora-backward/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/quantization-gemm/zamba-shared-attn-lora-backward/environment/shared_qkv_bwd.py

@@ -0,0 +1,28 @@
+"""Your implementation goes here.
+
+Replace the body of `shared_qkv_backward` 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 TFLOP/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 shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv):
+    """Backward of the shared attention-block QKV projection (frozen base, L LoRA adapters).
+
+    Args:
+        h:       (L, T, Dm)    bfloat16 — residual stream at each depth, saved by the forward.
+        emb:     (T, Dm)       bfloat16 — the shared original embedding, saved by the forward.
+        w_qkv:   (3*Dm, 2*Dm)  bfloat16 — the shared projection. FROZEN: no gradient is returned for it.
+        lora_a:  (L, r, 2*Dm)  bfloat16 — per-depth LoRA down-projection.
+        lora_b:  (L, 3*Dm, r)  bfloat16 — per-depth LoRA up-projection.
+        scaling: float                  — the LoRA scale (alpha / r).
+        dqkv:    (L, T, 3*Dm)  bfloat16 — incoming gradient w.r.t. the fused QKV output.
+
+    Returns:
+        (dh, demb, dlora_a, dlora_b) with shapes
+        (L, T, Dm), (T, Dm), (L, r, 2*Dm), (L, 3*Dm, r).
+    """
+    raise NotImplementedError("Implement a fast shared_qkv_backward in /app/shared_qkv_bwd.py")

tasks/quantization-gemm/zamba-shared-attn-lora-backward/instruction.md

@@ -0,0 +1,213 @@
+# Write a fast backward kernel for the shared-attention-block QKV projection
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv)`. **Read it, run it, profile it.**
+
+Write **`/app/shared_qkv_bwd.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def shared_qkv_backward(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+The forward being differentiated is the shared attention block's QKV projection, called at
+`L` depths with one shared weight and a per-depth LoRA adapter:
+
+```
+xc[l]  = concat( h[l], emb )                                       # (T, 2*Dm), state first
+mid[l] = xc[l] @ lora_a[l].T                                       # (T, r)
+qkv[l] = xc[l] @ w_qkv.T  +  scaling * mid[l] @ lora_b[l].T
+```
+
+`w_qkv` is **frozen** — this is adapter fine-tuning, so no gradient is produced for it and it is never
+transposed-reduced over the token axis. Given `dqkv` you must return four things:
+
+```
+dmid[l]     = scaling * ( dqkv[l] @ lora_b[l] )                    # (T, r)
+dxc[l]      = dqkv[l] @ w_qkv  +  dmid[l] @ lora_a[l]              # (T, 2*Dm)
+dlora_a[l]  = dmid[l].T @ xc[l]                                    # (r, 2*Dm)
+dlora_b[l]  = scaling * ( dqkv[l].T @ mid[l] )                     # (3*Dm, r)
+```
+
+and then the concatenation is undone:
+
+```
+dh[l] = dxc[l][:, :Dm]
+demb  = sum over ALL l of dxc[l][:, Dm:]
+```
+
+**`demb` is a sum over every depth.** The same embedding tensor was fed to all `L` invocations, so its
+gradient collects a contribution from each one — this is the piece that makes the backward of a *shared*
+block different from `L` independent backwards.
+
+Note that `mid[l]` was a forward temporary and is not an argument: `dlora_b` needs it, so it must be
+recomputed.
+
+`/app/reference.py` re-runs the fp32 forward under autograd and differentiates it. That is the exact
+specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `h` | `(L, T, Dm)` | `bfloat16` | residual stream at each depth |
+| `emb` | `(T, Dm)` | `bfloat16` | shared original embedding |
+| `w_qkv` | `(3*Dm, 2*Dm)` | `bfloat16` | shared projection, **frozen** |
+| `lora_a` | `(L, r, 2*Dm)` | `bfloat16` | per-depth LoRA down |
+| `lora_b` | `(L, 3*Dm, r)` | `bfloat16` | per-depth LoRA up |
+| `scaling` | float | | LoRA scale `alpha / r` |
+| `dqkv` | `(L, T, 3*Dm)` | `bfloat16` | incoming gradient w.r.t. the fused QKV output |
+
+**Return a 4-tuple in exactly this order:** `dh (L, T, Dm)`, `demb (T, Dm)`, `dlora_a (L, r, 2*Dm)`,
+`dlora_b (L, 3*Dm, r)`.
+
+`dh` and `demb` may be bf16 or fp32; the two adapter gradients should be **fp32** — each is a reduction
+over every token. **No gradient is returned for `w_qkv`.** The concatenation order is `[h[l] ‖ emb]`, so
+`dh` comes from the first `Dm` channels of `dxc` and `demb` from the last `Dm`, summed over depths.
+
+All inputs are **read-only**. `T` is **not** guaranteed to be a multiple of any tile size (the correctness
+shapes include `T = 129`), and `r` is as small as 4.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L` in
+4–8, `T` in 2048–6144, `Dm` in 2048–2560, `r` in 32–128. One big matmul per depth dominates the FLOPs; the
+adapter work is a few percent of it and most of the difficulty.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** **All four** returned tensors must match the reference (evaluated in fp32) within
+**relative Frobenius error `6e-3`** at every graded shape, including the timed ones; the grader scores the
+**worst** of the four.
+
+That gate is **measured**, and the two structural mistakes this task invites miss it badly: taking `demb`
+from depth 0 instead of summing over **all** depths scores **0.70–0.91**, and omitting the adapter's
+contribution `dmid @ lora_a` from `dxc` scores **0.124** at the largest graded shape (0.45–0.97 at the
+small ones) — 21x the tolerance at worst. 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 )   [TFLOP/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:
+
+```
+canonical_work(L, T, Dm, r) = L * ( 2*T*(2*Dm)*(3*Dm)      # dxc = dqkv @ w_qkv
+                                 + 3 * 2*T*(2*Dm)*r        # mid, dxc +=, dlora_a
+                                 + 2 * 2*T*(3*Dm)*r )      # dmid, dlora_b
+```
+
+**There is no cap and no target.** Higher TFLOP/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 TFLOP/s plus correctness.
+
+## Where the performance comes from
+
+`L` big matmuls against one frozen weight, plus four tall-skinny ones per depth, plus a
+reduction that ties all the depths together.
+
+**The frozen weight is read `L` times if you let it be.** `w_qkv` is 40–65 MB; a persistent grid that
+walks all `L` depths per weight tile pays for it once. Note the transpose: the backward needs
+`dqkv @ w_qkv` (not `w_qkv.T`), so the reduction runs over the `3*Dm` axis — plan the layout for that
+rather than transposing a 65 MB tensor at run time.
+
+**`demb` is a cross-depth reduction.** Do not build `L` copies of `dxc[:, Dm:]` and add them afterwards:
+that is `L` extra full-size writes and reads. Accumulate into one fp32 `(T, Dm)` buffer as each depth's
+tile is produced — with `L <= 8` a deterministic tree or a per-depth atomic-free accumulation over a
+partition of the token axis both work, and both beat materialising the intermediates.
+
+**Fuse the adapter path.** `mid[l]` and `dmid[l]` are `(T, r)` with `r <= 128`. Both belong in shared
+memory: recompute `mid` from the `xc` tile you already have, form `dmid` from the `dqkv` tile you already
+have, and feed both straight into the two weight-gradient reductions. An autograd-shaped implementation
+sends four `(T, r)` tensors and two `(T, 2*Dm)` tensors through HBM per depth for a delta worth a few
+percent of the arithmetic.
+
+**`dlora_a` and `dlora_b` are split-K reductions** over the token axis into tiny outputs (`r x 2*Dm` and
+`3*Dm x r`). Use fp32 accumulators and a cross-block reduction; do not use one atomic per element.
+
+`xc` should never be materialised: its first half is `h[l]`, its second half is `emb`, and every consumer
+can read them separately.
+
+## Precision and faithfulness (read this)
+
+Inputs are **bfloat16**; accumulate every matmul, the `demb` cross-depth sum and both
+adapter-gradient reductions in **fp32**.
+
+`demb` sums `L` full-size contributions and the adapter gradients sum over up to 6144 tokens — a bf16
+accumulator in either place gives an error that *grows* with the problem size, which the faithfulness
+clause below rejects.
+
+**fp8 is not appropriate here**: the saved activations arrive in bf16 and re-quantising them is an
+approximation of the specified computation.
+
+**Where the tolerance comes from.** `1e-2` is measured. A second, independent implementation — the
+analytic backward written out by hand, all `L` depths batched into `bmm`s, `xc` never materialised, the
+adapter gradients accumulated in a different order from autograd's — differs from this fp32 autograd
+reference by a worst relative Frobenius error of **2.90e-3** across the correctness shapes and two
+full-size graded shapes, over several seeds. The tolerance is **2.07x** that, and the error *falls* with
+problem size (2.37e-3 at the large shapes) — it is the bf16 rounding of the operands, nothing 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/shared_qkv_bwd.py` is the only file that is graded.** The grader imports `shared_qkv_backward` 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/quantization-gemm/zamba-shared-attn-lora-backward/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/zamba-shared-attn-lora-backward"
+description = "Fine-tuning a Zamba-style hybrid means differentiating a block that was called at L different depths with one frozen weight and L different rank-64 adapters, over an input that was a concatenation of the depth's residual stream and the model's original embedding. So the embedding's gradient is a sum over EVERY depth, each adapter's gradient is a pair of tall-skinny reductions over the token axis, and the frozen weight is read L times and never updated."
+authors = []
+keywords = ["mle", "kernel-generation", "zamba", "hybrid", "shared-attention", "lora", "multi-adapter", "backward", "training", "gemm", "compute-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/quantization-gemm/zamba-shared-attn-lora-backward/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/quantization-gemm/zamba-shared-attn-lora-backward/tests/verify_env.py

@@ -0,0 +1,197 @@
+"""zamba-shared-attn-lora-backward verifier — correctness gate + achieved-TFLOP/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of TFLOP/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/shared_qkv_bwd.py"
+TOL = 0.006
+NAMES = ('dh', 'demb', 'dlora_a', 'dlora_b')
+
+GRADER_SHAPES = [(6, 4096, 2048, 64), (4, 4096, 2560, 64), (8, 2048, 2048, 32), (6, 3072, 2048, 128), (4, 6144, 2048, 64)]
+CORRECT_SHAPES = [(2, 256, 256, 16), (3, 129, 128, 8), (4, 512, 512, 32), (2, 64, 128, 4)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one backward call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add:
+      * ONE pass of the big shared shape: dxc = dqkv @ w_qkv                (the base weight is frozen,
+        so there is no dw_qkv and no second pass over it)
+      * THREE passes of the (2*Dm, r) adapter shape: recompute mid = xc @ lora_a.T (the LoRA output is a
+        forward temporary), dxc += dmid @ lora_a, dlora_a = dmid.T @ xc
+      * TWO passes of the (3*Dm, r) adapter shape: dmid = dqkv @ lora_b, dlora_b = dqkv.T @ mid
+    The concatenation, the split of dxc and the sum of demb over depths are O(L*T*Dm) data movement and
+    are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm)
+                + 3 * (2 * T * (2 * Dm) * r)
+                + 2 * (2 * T * (3 * Dm) * r))
+
+def _shared_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """The fp32 forward of `zamba-shared-attn-lora-qkv`, differentiable. Autograd through THIS defines
+    every gradient this task asks for."""
+    L, T, Dm = h.shape
+    outs = []
+    for l in range(L):
+        xc = torch.cat([h[l], emb], dim=-1)                     # (T, 2*Dm)  [state | embedding]
+        base = xc @ w_qkv.t()
+        delta = (xc @ lora_a[l].t()) @ lora_b[l].t()
+        outs.append(base + scaling * delta)
+    return torch.stack(outs, 0)
+
+
+def _ref(h, emb, w_qkv, lora_a, lora_b, scaling, dqkv):
+    """The baseline re-runs the fp32 forward under autograd. The shared weight is FROZEN: only the two
+    activations and the L adapters receive gradients."""
+    ins = [t.detach().clone().float().requires_grad_(True) for t in (h, emb, lora_a, lora_b)]
+    o = _shared_qkv(ins[0], ins[1], w_qkv.float(), ins[2], ins[3], scaling)
+    return torch.autograd.grad(o, ins, dqkv.float())
+
+def _mk(L, T, Dm, r, seed):
+    """Saved forward inputs plus the incoming gradient. The adapters are scaled so the LoRA delta is a real
+    but minority part of the forward (RMS `16/r` of the base projection), which is what a trained LoRA
+    looks like."""
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    dqkv = rnd(L, T, 3 * Dm)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r, dqkv
+
+
+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.shared_qkv_backward
+
+        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 / 1e12 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "tflops": 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": "TFLOP/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, "TFLOP/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/RUN.md

@@ -0,0 +1,42 @@
+# Running `zamba-shared-attn-lora-qkv`
+
+Zamba-2 does not give every attention layer its own weights — it has ONE attention block and calls it at several depths of a Mamba stack, feeding it the concatenation of the current residual stream and the original token embedding, and giving each invocation its own low-rank adapter so the shared weights can still specialise. The QKV projection therefore runs L times against the same 50 MB of weights with L different rank-64 deltas, and done as L separate library calls the shared weight is re-read from HBM every time and the adapters get three extra launches each.
+
+|  |  |
+|---|---|
+| **Task id** | `mle-bench/zamba-shared-attn-lora-qkv` |
+| **Group** | `kernel-generation` |
+| **GPUs** | 1 |
+| **Agent edits** | `/app/shared_qkv.py` |
+| **Score** | achieved **TFLOP/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/zamba-shared-attn-lora-qkv --task-name zamba-shared-attn-lora-qkv \
+  --agent claude-code --model anthropic/claude-opus-4-1 -e docker
+```
+
+## Run manually
+
+```bash
+cd kernel-generation/kernels/zamba-shared-attn-lora-qkv
+docker build -t zamba-shared-attn-lora-qkv environment/
+docker run -d --name v --gpus '"device=0"' --shm-size=8g --entrypoint sleep zamba-shared-attn-lora-qkv 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 (TFLOP/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/quantization-gemm/zamba-shared-attn-lora-qkv/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/quantization-gemm/zamba-shared-attn-lora-qkv/environment/Dockerfile

@@ -0,0 +1,41 @@
+# Kernel-generation task: Write a fast shared-attention-block QKV kernel (one weight, L per-depth LoRA adapters)
+#
+# Zamba-2 does not give every attention layer its own weights — it has ONE attention block and calls it at several depths of a Mamba stack, feeding it the concatenation of the current residual stream and the original token embedding, and giving each invocation its own low-rank adapter so the shared weights can still specialise. The QKV projection therefore runs L times against the same 50 MB of weights with L different rank-64 deltas, and done as L separate library calls the shared weight is re-read from HBM every time and the adapters get three extra launches each.
+#
+# SCORING: correctness is a hard gate; the score is achieved TFLOP/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 shared_qkv.py /app/shared_qkv.py

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/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/quantization-gemm/zamba-shared-attn-lora-qkv/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/quantization-gemm/zamba-shared-attn-lora-qkv/environment/measure.py

@@ -0,0 +1,121 @@
+"""Self-assessment tool — your correctness + achieved TFLOP/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 TFLOP/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 shared_block_qkv as _ref
+from shared_qkv import shared_block_qkv as _agent
+
+TOL = 0.007
+
+FULL = [(6, 3584, 2048, 64), (4, 3584, 2560, 64), (8, 1792, 2048, 32), (6, 2560, 2048, 128), (4, 5120, 2048, 64)]
+QUICK = [(4, 512, 1024, 32), (2, 1024, 512, 16), (6, 256, 1024, 64)]
+
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add: the shared projection (T, 2*Dm) x (2*Dm, 3*Dm), the adapter's
+    down-projection (T, 2*Dm) x (2*Dm, r) and its up-projection (T, r) x (r, 3*Dm). The concatenation and
+    the residual add are O(T*Dm) data movement and are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm) + 2 * T * (2 * Dm) * r + 2 * T * r * (3 * Dm))
+
+def _mk(L, T, Dm, r, seed):
+    """Per-depth residual streams, one shared embedding, the shared weight and L LoRA adapters.
+
+    The adapters are scaled so the delta is a real but minority contribution (its RMS is `16/r` of the
+    base projection's), which is what a trained LoRA looks like — big enough that ignoring it is obvious,
+    small enough that it is a correction rather than the answer.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.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 / 1e12 if t > 0 else 0.0
+        vals.append(v)
+        print(f"  {str(shp):28s} {t*1e3:9.2f} ms | {v:9.2f} TFLOP/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} TFLOP/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/quantization-gemm/zamba-shared-attn-lora-qkv/environment/reference.py

@@ -0,0 +1,24 @@
+"""Reference implementation — the CORRECTNESS SPEC for `shared_block_qkv`.
+
+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 TFLOP/s number. GENERATED by _factory/build.py.
+"""
+import torch
+
+
+def shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """One depth at a time: concatenate, project with the shared weight, add the depth's LoRA delta.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The shared weight is
+    re-read for every depth and the rank-wide intermediate goes to HBM.
+    """
+    L, T, Dm = h.shape
+    out = torch.empty(L, T, 3 * Dm, device=h.device, dtype=torch.float32)
+    w = w_qkv.float()
+    e = emb.float()
+    for l in range(L):
+        xc = torch.cat([h[l].float(), e], dim=-1)              # (T, 2*Dm)  [state | embedding]
+        base = xc @ w.t()                                      # the SHARED projection
+        delta = (xc @ lora_a[l].float().t()) @ lora_b[l].float().t()
+        out[l] = base + scaling * delta
+    return out.to(torch.bfloat16)

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/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/quantization-gemm/zamba-shared-attn-lora-qkv/environment/shared_qkv.py

@@ -0,0 +1,26 @@
+"""Your implementation goes here.
+
+Replace the body of `shared_block_qkv` 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 TFLOP/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 shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """Shared attention-block QKV projection with a per-depth LoRA adapter.
+
+    Args:
+        h:       (L, T, Dm)    bfloat16 — the residual stream at each of the L depths the block is called at.
+        emb:     (T, Dm)       bfloat16 — the ORIGINAL token embedding, concatenated at every depth.
+        w_qkv:   (3*Dm, 2*Dm)  bfloat16 — the SHARED qkv projection, nn.Linear layout (out, in).
+        lora_a:  (L, r, 2*Dm)  bfloat16 — per-depth LoRA down-projection.
+        lora_b:  (L, 3*Dm, r)  bfloat16 — per-depth LoRA up-projection.
+        scaling: float                  — the LoRA scale (alpha / r).
+
+    Returns:
+        qkv: (L, T, 3*Dm), bfloat16 or float32 — must match /app/reference.py numerically.
+    """
+    raise NotImplementedError("Implement a fast shared_block_qkv in /app/shared_qkv.py")

tasks/quantization-gemm/zamba-shared-attn-lora-qkv/instruction.md

@@ -0,0 +1,199 @@
+# Write a fast shared-attention-block QKV kernel (one weight, L per-depth LoRA adapters)
+
+You are given a **correct but slow** reference at **`/app/reference.py`** — `shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling)`. **Read it, run it, profile it.**
+
+Write **`/app/shared_qkv.py`** with the **same signature** and the **same numerical output**, but **as fast as you can make it**.
+
+```python
+def shared_block_qkv(h, emb, w_qkv, lora_a, lora_b, scaling):
+    ...
+```
+
+## The computation (this is the exact spec)
+
+A Zamba-style hybrid stack has **one** attention block, invoked at `L` different depths of a
+Mamba backbone. Two things make its QKV projection unusual.
+
+**1 — the input is a concatenation.** At every depth the block sees the current residual stream *and* the
+original token embedding, glued along the feature axis:
+
+```
+xc[l] = concat( h[l], emb )          # (T, 2*Dm) — state first, embedding second
+```
+
+`emb` is the **same** tensor at every depth: it is the model's input embedding, re-fed so the shared block
+always has the original token available no matter how deep it is being called.
+
+**2 — the weights are shared, the adapters are not.** One `(3*Dm, 2*Dm)` projection serves every depth,
+and each depth gets its own rank-`r` LoRA delta:
+
+```
+qkv[l] = xc[l] @ w_qkv.T  +  scaling * ( xc[l] @ lora_a[l].T ) @ lora_b[l].T
+```
+
+That is the whole computation: `L` applications of one big shared GEMM, each with its own tiny two-matmul
+correction. The output layout is the usual fused one — `qkv[l][:, 0:Dm]` is Q, `[Dm:2*Dm]` is K,
+`[2*Dm:3*Dm]` is V — but nothing here needs to know that; you return the fused tensor.
+
+`/app/reference.py` loops over depths and materialises the concatenation and the rank-wide intermediate for
+each. That is the exact specification; it is deliberately simple rather than fast.
+
+## The contract (fixed — do not change these)
+
+| arg | shape | dtype | meaning |
+|-----|-------|-------|---------|
+| `h` | `(L, T, Dm)` | `bfloat16` | residual stream at each of the `L` invocation depths |
+| `emb` | `(T, Dm)` | `bfloat16` | the original token embedding, **shared** across depths |
+| `w_qkv` | `(3*Dm, 2*Dm)` | `bfloat16` | the shared projection, `nn.Linear` layout `(out, in)` |
+| `lora_a` | `(L, r, 2*Dm)` | `bfloat16` | per-depth LoRA down-projection |
+| `lora_b` | `(L, 3*Dm, r)` | `bfloat16` | per-depth LoRA up-projection |
+| `scaling` | float | | LoRA scale `alpha / r`, a Python float |
+
+**Return** a single tensor `qkv` of shape `(L, T, 3*Dm)`, bfloat16 or float32 (the grader compares in
+fp32).
+
+The concatenation order is **`[h[l] ‖ emb]`** — state in channels `[0, Dm)`, embedding in `[Dm, 2*Dm)` —
+and `w_qkv`'s columns are laid out to match. All inputs are **read-only**. `T` is **not** guaranteed to be
+a multiple of any tile size (the correctness shapes include `T = 129`), and `r` is as small as 4.
+
+**Shape regime you are graded in** (the exact grader sizes are *not* disclosed): `L`
+(invocation depths) in 4–8, `T` (tokens) in 2048–6144, `Dm` in 2048–2560, `r` in 32–128. The shared weight
+is 40–65 MB and is used `L` times; the `L` adapters together are a few megabytes. That ratio is the whole
+design of the layer and it should be the whole design of your kernel.
+
+## How success is decided (runs on GPU)
+
+**1. Correctness — a required gate.** The returned tensor must match the reference (evaluated in fp32) within **relative
+Frobenius error `7e-3`** at every graded shape, including the timed ones.
+
+That gate is **measured**, and the plausible ways to get this wrong miss it by a wide margin: dropping the
+LoRA delta entirely scores **0.12–0.24** at the graded shapes (0.45–0.97 at the small ones, where `r` is
+a larger fraction of the width), using depth 0's adapter for every depth scores **0.16–0.30**, and
+concatenating `[emb ‖ h[l]]` instead of `[h[l] ‖ emb]` scores **1.41** — the closest is **18x** 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 )   [TFLOP/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:
+
+```
+canonical_work(L, T, Dm, r) = L * ( 2*T*(2*Dm)*(3*Dm)  +  2*T*(2*Dm)*r  +  2*T*r*(3*Dm) )
+#                                  shared projection      LoRA down        LoRA up
+```
+
+**There is no cap and no target.** Higher TFLOP/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 TFLOP/s plus correctness.
+
+## Where the performance comes from
+
+One big GEMM done `L` times against the same weight, plus `2L` tiny ones. Three things
+decide the score.
+
+**Read the shared weight once.** `w_qkv` is 40–65 MB; `L` separate `torch.matmul` calls stream it from HBM
+`L` times. A kernel that tiles over `(depth, token)` blocks with the weight tile resident — or a persistent
+grid that walks all `L` depths for each weight tile — pays for it once. At `L = 8` that is the difference
+between 500 MB and 60 MB of weight traffic.
+
+**Never materialise the concatenation.** `xc[l]` is `(T, 2*Dm)` and half of it is `emb`, which is the same
+for every depth. Building it explicitly costs `L` writes and `L` reads of a tensor twice the size of `h`.
+The GEMM's K-loop can simply read the first `Dm` steps from `h[l]` and the next `Dm` from `emb` — the
+operands are contiguous within each half, and `emb`'s half is reused by all `L` depths, so it is a
+shared-memory tile you load once.
+
+**Fuse the adapter.** The rank-wide intermediate `xc @ lora_a[l].T` is `(T, r)` with `r <= 128` — a few
+hundred kilobytes. It has no business in HBM: compute it into shared memory while the tile is resident,
+then accumulate `scaling * (that) @ lora_b[l].T` straight into the same accumulator the shared projection
+is building. Done separately, the adapter costs a second full read of `xc`, two extra launches per depth,
+and a round trip of the intermediate — on a delta that is a few percent of the arithmetic.
+
+The `L` depths are completely independent, which is free parallelism for filling the machine at small `T`,
+and `T` is ragged, so size the tail carefully.
+
+## Precision and faithfulness (read this)
+
+Inputs are **bfloat16** and the output may be bf16 or fp32. Accumulate every matmul in
+**fp32** — including the adapter's two, whose product is added to a much larger base term, so its own
+rounding is amplified by nothing but must not be thrown away.
+
+`scaling` is a Python float. Fold it into the adapter's up-projection or apply it to the rank-wide
+intermediate; either is fine, but do it in fp32.
+
+**fp8 is not appropriate here**: the weights and activations arrive in bf16 and re-quantising them is an
+approximation of the specified computation, not an implementation of it.
+
+**Where the tolerance comes from.** `1e-2` is measured. A second, independent implementation — all `L`
+depths batched into one `bmm` against a broadcast weight, the concatenation formed implicitly by splitting
+the K-loop, the LoRA fused as `xc @ (lora_a.T @ lora_b.T)` in the other association order, bf16 operands
+with fp32 accumulate — differs from this fp32 reference by a worst relative Frobenius error of **3.30e-3**
+across the correctness shapes and two full-size graded shapes, over several seeds. The tolerance is
+**2.1x** that, and the error is flat in `L` and `T` (2.86e-3 at the large shapes) because it is the bf16
+rounding of the operands and of the returned tensor and nothing else.
+
+### 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/shared_qkv.py` is the only file that is graded.** The grader imports `shared_block_qkv` 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/quantization-gemm/zamba-shared-attn-lora-qkv/task.toml

@@ -0,0 +1,38 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/zamba-shared-attn-lora-qkv"
+description = "Zamba-2 does not give every attention layer its own weights — it has ONE attention block and calls it at several depths of a Mamba stack, feeding it the concatenation of the current residual stream and the original token embedding, and giving each invocation its own low-rank adapter so the shared weights can still specialise. The QKV projection therefore runs L times against the same 50 MB of weights with L different rank-64 deltas, and done as L separate library calls the shared weight is re-read from HBM every time and the adapters get three extra launches each."
+authors = []
+keywords = ["mle", "kernel-generation", "zamba", "hybrid", "shared-attention", "lora", "multi-adapter", "gemm", "fusion", "compute-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/quantization-gemm/zamba-shared-attn-lora-qkv/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/quantization-gemm/zamba-shared-attn-lora-qkv/tests/verify_env.py

@@ -0,0 +1,184 @@
+"""zamba-shared-attn-lora-qkv verifier — correctness gate + achieved-TFLOP/s SPEED LEADERBOARD (uncapped).
+
+    reward = 0                                     if the submission is incorrect
+    reward = geomean over graded shapes of TFLOP/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/shared_qkv.py"
+TOL = 0.007
+
+GRADER_SHAPES = [(6, 4096, 2048, 64), (4, 4096, 2560, 64), (8, 2048, 2048, 32), (6, 3072, 2048, 128), (4, 6144, 2048, 64)]
+CORRECT_SHAPES = [(2, 256, 256, 16), (3, 129, 128, 8), (4, 512, 512, 32), (2, 64, 128, 4)]
+
+sys.path.insert(0, "/app")
+
+def canonical_work(L, T, Dm, r):
+    """FLOPs attributed to one call, from the SHAPE ALONE.
+
+    Per depth, at 2 FLOPs per multiply-add: the shared projection (T, 2*Dm) x (2*Dm, 3*Dm), the adapter's
+    down-projection (T, 2*Dm) x (2*Dm, r) and its up-projection (T, r) x (r, 3*Dm). The concatenation and
+    the residual add are O(T*Dm) data movement and are not credited.
+    """
+    return L * (2 * T * (2 * Dm) * (3 * Dm) + 2 * T * (2 * Dm) * r + 2 * T * r * (3 * Dm))
+
+def _ref(h, emb, w_qkv, lora_a, lora_b, scaling):
+    """One depth at a time: concatenate, project with the shared weight, add the depth's LoRA delta.
+
+    Correct and simple — it is the numerical SPECIFICATION, not a performance target. The shared weight is
+    re-read for every depth and the rank-wide intermediate goes to HBM.
+    """
+    L, T, Dm = h.shape
+    out = torch.empty(L, T, 3 * Dm, device=h.device, dtype=torch.float32)
+    w = w_qkv.float()
+    e = emb.float()
+    for l in range(L):
+        xc = torch.cat([h[l].float(), e], dim=-1)              # (T, 2*Dm)  [state | embedding]
+        base = xc @ w.t()                                      # the SHARED projection
+        delta = (xc @ lora_a[l].float().t()) @ lora_b[l].float().t()
+        out[l] = base + scaling * delta
+    return out.to(torch.bfloat16)
+
+def _mk(L, T, Dm, r, seed):
+    """Per-depth residual streams, one shared embedding, the shared weight and L LoRA adapters.
+
+    The adapters are scaled so the delta is a real but minority contribution (its RMS is `16/r` of the
+    base projection's), which is what a trained LoRA looks like — big enough that ignoring it is obvious,
+    small enough that it is a correction rather than the answer.
+    """
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    def rnd(*sh, s=1.0):
+        return (torch.randn(*sh, device="cuda", dtype=torch.float32, generator=gen) * s).to(torch.bfloat16)
+
+    h = rnd(L, T, Dm)
+    emb = rnd(T, Dm)
+    w_qkv = rnd(3 * Dm, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_a = rnd(L, r, 2 * Dm, s=(2 * Dm) ** -0.5)
+    lora_b = rnd(L, 3 * Dm, r, s=r ** -0.5)
+    return h, emb, w_qkv, lora_a, lora_b, 16.0 / r
+
+
+def _is_exact(t):
+    """Integer/bool tensors are compared EXACTLY: .float() is lossy above 2**24, so two distinct large
+    ids (page ids, token ids, indices) can compare equal and let a wrong kernel pass."""
+    return t.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool)
+
+
+def _check(out, ref):
+    """-> (ok, value, msg). Exact for integer/bool; relative Frobenius error otherwise."""
+    if out is None or tuple(out.shape) != tuple(ref.shape):
+        return False, 1.0, "bad/None shape"
+    if _is_exact(ref):
+        bad = int((out != ref).sum())
+        return bad == 0, float(bad), ("exact match" if bad == 0 else f"{bad} elements differ")
+    e = float((out.float() - ref.float()).norm() / (ref.float().norm() + 1e-12))
+    return e <= TOL, e, f"relerr {e:.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.shared_block_qkv
+
+        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 / 1e12 if t > 0 else 0.0
+            vals.append(v)
+            per_shape.append({"shape": list(shp), "tflops": 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": "TFLOP/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, "TFLOP/s | correct:", 1.0 if correct_gate else 0.0)
+
+
+main()

tasks/raw-cuda/README.md

@@ -2,13 +2,19 @@
 
 Raw-CUDA tasks. No PyTorch and no Triton are installed at all — the agent gets `nvcc`, CUTLASS and the profilers, and writes CUDA C++ against a C-level harness.
 
-**6 tasks.**
+**12 tasks.**
 
 | task | metric | roofline | what the kernel does |
 |---|---|---|---|
+| [`cuda-blockwise-softmax`](cuda-blockwise-softmax/) | — | — |  |
+| [`cuda-fp8-cast-pack`](cuda-fp8-cast-pack/) | — | — |  |
+| [`cuda-histogram-atomics`](cuda-histogram-atomics/) | — | — |  |
 | [`cuda-linear-recurrence`](cuda-linear-recurrence/) | — | — |  |
+| [`cuda-radix-partition`](cuda-radix-partition/) | — | — |  |
 | [`cuda-relu2-aggregation`](cuda-relu2-aggregation/) | — | — |  |
 | [`cuda-topk-indices`](cuda-topk-indices/) | — | — |  |
+| [`cuda-transpose-vectorized`](cuda-transpose-vectorized/) | — | — |  |
+| [`cuda-warp-scan-segmented`](cuda-warp-scan-segmented/) | — | — |  |
 | [`flash-attention-fwd`](flash-attention-fwd/) | — | — |  |
 | [`gptq-w4a16-gemm`](gptq-w4a16-gemm/) | — | — |  |
 | [`qserve-w4a8-gemm`](qserve-w4a8-gemm/) | — | — |  |

tasks/raw-cuda/cuda-blockwise-softmax/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/raw-cuda/cuda-blockwise-softmax/environment/Dockerfile

@@ -0,0 +1,34 @@
+# CUDA kernel-generation task: write a fast row-wise (online) softmax kernel in solution.cu.
+# Toolchain only: nvcc / CUDA / CUTLASS / flashinfer + ncu/nsys.  NO PyTorch, NO Triton.
+FROM nvidia/cuda:12.8.1-devel-ubuntu24.04
+
+# ncu ships in the devel image (/usr/local/cuda/bin/ncu); add nsys + build/firewall deps.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git ca-certificates curl iptables iproute2 nsight-compute nsight-systems && \
+    rm -rf /var/lib/apt/lists/*
+
+# Header-only deps the agent's kernel may use (cloned at build time; runtime is firewalled).
+# Keep only flashinfer's include/ — its python source (which contains a triton submodule) isn't needed,
+# and dropping it keeps the environment free of any torch/triton files.
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git && \
+    git clone --depth 1 https://github.com/flashinfer-ai/flashinfer /tmp/fi && \
+    mkdir -p /opt/flashinfer && mv /tmp/fi/include /opt/flashinfer/include && rm -rf /tmp/fi
+
+# Pre-bake the agent (the offline firewall blocks installing it at run time).
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && /root/.local/bin/uv tool install mini-swe-agent
+ENV PATH=/root/.local/bin:$PATH
+
+# Task workspace: the stub the agent edits, a dev copy of the grading harness, and a build helper.
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+COPY solution.cu /app/solution.cu
+COPY harness.cu  /app/harness.cu
+COPY build.sh    /app/build.sh
+RUN chmod +x /app/build.sh
+
+# Offline firewall (allow the LLM API, block github/pypi/HF so reference kernels can't be fetched).
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+
+# Strip apt sources so harbor's base apt-setup is a no-op under the firewall.
+RUN rm -rf /etc/apt/sources.list /etc/apt/sources.list.d /var/lib/apt/lists/*

tasks/raw-cuda/cuda-blockwise-softmax/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/raw-cuda/cuda-blockwise-softmax/environment/build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Compile your solution against the harness and run one seed (the grader uses a different seed).
+set -e
+nvcc -O3 -arch=native /app/harness.cu /app/solution.cu -I/opt/flashinfer/include -I/opt/cutlass/include -o /app/run
+/app/run 0

tasks/raw-cuda/cuda-blockwise-softmax/environment/docker-compose.yaml

@@ -0,0 +1,17 @@
+# Anti-cheat firewall + profiling caps, merged on top of Harbor's base compose.
+# NET_ADMIN: restrict-network.sh installs the outbound allowlist (LLM API only; github/pypi/HF blocked).
+# SYS_ADMIN: lets the agent run ncu (GPU performance counters) inside the container (the host has
+#            NVreg_RestrictProfilingToAdminUsers=0). network_mode stays "public" — the firewall enforces it.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+      - SYS_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - 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/raw-cuda/cuda-blockwise-softmax/environment/harness.cu

@@ -0,0 +1,128 @@
+// Grading harness for cuda-blockwise-softmax.
+//   out[b, v] = exp(x[b,v] - max_v x[b,v]) / sum_v exp(x[b,v] - max_v x[b,v])     per row, in fp32
+//   x[B, V] bfloat16 row-major in, out[B, V] bfloat16 row-major out.
+// Rows are LONG (V = 131072) and a few of them carry logits large enough that exp() overflows fp32
+// unless the row max is subtracted first -- the numerically stable form is required, not optional.
+// Inputs are generated ON DEVICE from the seed (deterministic and fast).
+// The naive reference is one thread per row, three sequential passes over the row.
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <algorithm>
+
+#define CK(x) do{ cudaError_t e=(x); if(e!=cudaSuccess){ printf("CUDA err %s:%d %s\n",__FILE__,__LINE__,cudaGetErrorString(e)); exit(2);} }while(0)
+
+static const int B = 4096, V = 131072;       // 5.4e8 elements: 1.07 GB in, 1.07 GB out
+static const float TOL = 5e-3f;
+#ifndef R_BAR
+#define R_BAR 29.0f
+#endif
+
+// ---- the agent's kernel ------------------------------------------------------------------------
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B_, int V_);
+
+// ---- deterministic device-side input generation -------------------------------------------------
+__device__ __forceinline__ unsigned mix(unsigned a){
+    a ^= a >> 16; a *= 0x7feb352du; a ^= a >> 15; a *= 0x846ca68bu; a ^= a >> 16; return a;
+}
+__device__ __forceinline__ float unif(unsigned s){ return (mix(s) >> 8) * (1.0f / 16777216.0f); }
+
+__global__ void gen_kernel(__nv_bfloat16* x, long n, int V_, unsigned seed){
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        unsigned s = mix((unsigned)(i ^ (i >> 32)) * 2654435761u + seed);
+        float u1 = fmaxf(unif(s), 1e-7f), u2 = unif(s + 12345u);
+        float g = sqrtf(-2.0f * logf(u1)) * cospif(2.0f * u2);
+        int row = (int)(i / V_);
+        // most rows are ordinary attention-scale logits; every 97th row is an outlier row whose
+        // logits reach ~140, so exp() overflows fp32 if the row max is not subtracted first
+        float sc = (row % 97 == 0) ? 30.0f : 3.0f;
+        x[i] = __float2bfloat16(g * sc);
+    }
+}
+
+// ---- naive reference: one thread per row, three sequential passes --------------------------------
+__global__ void naive_kernel(const __nv_bfloat16* x, __nv_bfloat16* out, int B_, int V_){
+    for(long r = (long)blockIdx.x * blockDim.x + threadIdx.x; r < B_; r += (long)gridDim.x * blockDim.x){
+        const __nv_bfloat16* xr = x + r * (long)V_;
+        __nv_bfloat16* orow = out + r * (long)V_;
+        float m = -INFINITY;
+        for(int j = 0; j < V_; j++) m = fmaxf(m, __bfloat162float(xr[j]));
+        float s = 0.f;
+        for(int j = 0; j < V_; j++) s += expf(__bfloat162float(xr[j]) - m);
+        float inv = 1.f / s;
+        for(int j = 0; j < V_; j++) orow[j] = __float2bfloat16(expf(__bfloat162float(xr[j]) - m) * inv);
+    }
+}
+
+// ---- comparison: relative Frobenius --------------------------------------------------------------
+__global__ void cmp_kernel(const __nv_bfloat16* a, const __nv_bfloat16* b, long n, double* acc){
+    __shared__ double sn[256], sd[256];
+    double num = 0.0, den = 0.0;
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        double va = (double)__bfloat162float(a[i]), vb = (double)__bfloat162float(b[i]);
+        if(!isfinite(va)) va = 1e30;                 // an inf/nan from an unstable kernel must not pass
+        num += (va - vb) * (va - vb);
+        den += vb * vb;
+    }
+    sn[threadIdx.x] = num; sd[threadIdx.x] = den;
+    __syncthreads();
+    for(int o = blockDim.x >> 1; o; o >>= 1){
+        if(threadIdx.x < o){ sn[threadIdx.x] += sn[threadIdx.x + o]; sd[threadIdx.x] += sd[threadIdx.x + o]; }
+        __syncthreads();
+    }
+    if(threadIdx.x == 0){ atomicAdd(acc, sn[0]); atomicAdd(acc + 1, sd[0]); }
+}
+
+typedef void(*Fn)(const __nv_bfloat16*, __nv_bfloat16*);
+static float time_ms(Fn run, const __nv_bfloat16* a, __nv_bfloat16* b, int warm, int iters){
+    cudaEvent_t ev0, ev1; CK(cudaEventCreate(&ev0)); CK(cudaEventCreate(&ev1));
+    for(int i = 0; i < warm; i++) run(a, b);
+    CK(cudaDeviceSynchronize());
+    std::vector<float> ts;
+    for(int i = 0; i < iters; i++){
+        CK(cudaEventRecord(ev0)); run(a, b); CK(cudaEventRecord(ev1));
+        CK(cudaEventSynchronize(ev1)); float ms; CK(cudaEventElapsedTime(&ms, ev0, ev1)); ts.push_back(ms);
+    }
+    std::sort(ts.begin(), ts.end()); return ts[ts.size() / 2];
+}
+static void run_naive(const __nv_bfloat16* a, __nv_bfloat16* b){ naive_kernel<<<64, 64>>>(a, b, B, V); }
+static void run_agent(const __nv_bfloat16* a, __nv_bfloat16* b){ row_softmax(a, b, B, V); }
+
+int main(int argc, char** argv){
+    unsigned seed = argc > 1 ? (unsigned)atoi(argv[1]) : 1234u;
+    long n = (long)B * V;
+    __nv_bfloat16 *x, *oref, *oag; double* acc;
+    CK(cudaMalloc(&x, n * 2)); CK(cudaMalloc(&oref, n * 2)); CK(cudaMalloc(&oag, n * 2));
+    CK(cudaMalloc(&acc, 16)); CK(cudaMemset(acc, 0, 16)); CK(cudaMemset(oag, 0, n * 2));
+    gen_kernel<<<1024, 256>>>(x, n, V, seed);
+    CK(cudaDeviceSynchronize());
+
+    run_naive(x, oref); CK(cudaDeviceSynchronize());
+    run_agent(x, oag);  CK(cudaDeviceSynchronize());
+    cudaError_t ge = cudaGetLastError();
+
+    cmp_kernel<<<1024, 256>>>(oag, oref, n, acc);
+    CK(cudaDeviceSynchronize());
+    double h[2]; CK(cudaMemcpy(h, acc, 16, cudaMemcpyDeviceToHost));
+    double rel = sqrt(h[0] / (h[1] + 1e-30));
+
+    float tn = time_ms(run_naive, x, oref, 1, 3);
+    float ta = time_ms(run_agent, x, oag, 5, 30);
+    float sp = tn / ta;
+    bool correct = (ge == cudaSuccess) && (rel < TOL);
+    bool fast = sp >= R_BAR;
+    double reward = (correct && fast) ? 1.0 : 0.0;
+    printf("rel_err=%.3e | naive=%.3f ms agent=%.3f ms speedup=%.2fx (bar %.2f) | correct=%d fast=%d "
+           "-> reward=%.1f\n", rel, tn, ta, sp, (float)R_BAR, correct, fast, reward);
+    if(ge != cudaSuccess) printf("agent kernel error: %s\n", cudaGetErrorString(ge));
+    system("mkdir -p /logs/verifier");
+    FILE* f = fopen("/logs/verifier/reward.json", "w");
+    if(f){ fprintf(f, "{\"reward\": %.1f, \"correct\": %d, \"fast\": %d, \"rel_err\": %.3e, "
+                      "\"naive_ms\": %.3f, \"agent_ms\": %.3f, \"speedup\": %.3f}\n",
+                   reward, correct, fast, rel, tn, ta, sp); fclose(f); }
+    FILE* ft = fopen("/logs/verifier/reward.txt", "w"); if(ft){ fprintf(ft, "%.1f\n", reward); fclose(ft); }
+    return 0;
+}

tasks/raw-cuda/cuda-blockwise-softmax/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 fetch sglang's own Gemma4 implementation (`pip install sglang`, `git clone
+# sgl-project/sglang`, HF) and copy it. The model is already staged 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=(
+    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/raw-cuda/cuda-blockwise-softmax/environment/solution.cu

@@ -0,0 +1,18 @@
+// solution.cu — implement the row-wise softmax described in the instruction.
+//   m[b]      = max over v of x[b,v]
+//   out[b,v]  = exp(x[b,v] - m[b]) / sum_v exp(x[b,v] - m[b])
+// x[B,V] and out[B,V] are bfloat16 row-major; all arithmetic in fp32. B = 4096, V = 131072 (fixed).
+// Some rows carry logits near 140, so the max MUST be subtracted before exp() or fp32 overflows.
+// This stub writes zeros (it compiles and runs, but is incorrect — reward 0).
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+
+__global__ void stub_k(__nv_bfloat16* out, long n){
+    long i = (long)blockIdx.x * blockDim.x + threadIdx.x;
+    if(i < n) out[i] = __float2bfloat16(0.f);
+}
+
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B, int V){
+    long n = (long)B * V;
+    stub_k<<<(n + 255) / 256, 256>>>(out, n);
+}

tasks/raw-cuda/cuda-blockwise-softmax/instruction.md

@@ -0,0 +1,64 @@
+# Write a fast CUDA kernel for a row-wise softmax over very long rows
+
+Implement a high-performance CUDA kernel in `/app/solution.cu` that softmaxes each row of a large `bfloat16`
+matrix — the shape a vocabulary-sized logits matrix or a long attention-score row has.
+
+Input: `x` of shape `[B, V]` (`__nv_bfloat16`, row-major). Output: `out` of shape `[B, V]`
+(`__nv_bfloat16`, row-major). For each row `b`:
+
+```
+m[b]     = max over v of x[b, v]
+s[b]     = sum over v of exp( x[b, v] - m[b] )
+out[b,v] = exp( x[b, v] - m[b] ) / s[b]
+```
+
+All arithmetic in **fp32**; only the stored result is bfloat16. The sizes are fixed:
+**B = 4096, V = 131072** — 1.07 GB in, 1.07 GB out, and a row is 256 KB.
+
+**Subtracting the row max is required, not an optimisation.** Roughly one row in a hundred is an outlier row
+whose logits reach ~140, and `expf(140)` overflows fp32. A kernel that computes `exp(x)/sum(exp(x))`
+directly produces `inf`/`nan` on those rows and fails the correctness gate.
+
+The function signature (fixed) is in `/app/solution.cu`:
+```cpp
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B, int V);
+```
+
+## How success is decided
+
+The grader compiles your `solution.cu` against a fixed harness, generates seeded inputs on the device, and
+checks:
+1. **Correctness** — relative Frobenius error below **5e-3** against the reference (non-finite outputs are
+   scored as maximally wrong). That gate is measured: the reference sums each row **sequentially** in fp32
+   while any block-parallel kernel sums it as a tree, and with a bf16 output that difference alone measures
+   **8e-4 – 9.5e-4**. The gate is ~5x that, which covers reduction order and a fast `expf`, and is nowhere
+   near loose enough to admit a softmax over the wrong axis or an unstable one.
+2. **Performance** — your kernel is at least **R×** faster than a straightforward reference (CUDA-event
+   timed, warmup + median; the exact bar is printed when you build).
+
+Both must pass for reward 1.0.
+
+## Notes
+
+- The reference the bar is measured against is **one thread per row**, walking the row **three times** (max,
+  then sum, then normalise). It is uncoalesced *and* it makes three trips over the data — both are worth
+  fixing, and only one of them is obvious.
+- A row is 256 KB, so it does not fit in registers or shared memory: you cannot keep it on chip between
+  passes. But you do not need three passes either — the max and the sum can be accumulated **together** in a
+  single sweep if you carry a running `(max, sum)` pair and rescale the sum whenever the max moves
+  (`s <- s * exp(m_old - m_new)`). That is the standard online-softmax recurrence, and it turns three passes
+  over HBM into two.
+- One block per row is the natural decomposition (`B = 4096` rows, so there is plenty of parallelism). Inside
+  the block you need a max reduction and a sum reduction; warp shuffles plus a small shared-memory stage are
+  enough, and a block-wide barrier per row is unavoidable — but there should be only **one** of each.
+- Vectorise: an element is 2 bytes and a 128-bit access moves 8 of them, on both the load and the store side.
+- Think about where the second pass reads from. The rows a wave of blocks is working on are a few tens of MB
+  in total, which is not nothing relative to the L2 you can query with `cudaGetDeviceProperties` — how many
+  blocks you keep resident changes whether the re-read is an HBM read or an L2 hit.
+- Available: `nvcc`, header-only **CUTLASS** (`/opt/cutlass/include`) and **flashinfer**
+  (`/opt/flashinfer/include`), **CUB/Thrust** (ship with CUDA, including block-wide reductions), and the
+  profilers **`ncu`** and **`nsys`**. There is **no PyTorch and no Triton**; this is a pure CUDA task.
+- Build + test locally: **`bash /app/build.sh`** (compiles against the harness and runs one seed; the grader
+  uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
+  you are measured; you only edit `solution.cu`.
+- **No internet access.**

tasks/raw-cuda/cuda-blockwise-softmax/solution/solution.oracle.cu

@@ -0,0 +1,65 @@
+// Oracle: one block per row, ONLINE softmax so the row is read twice instead of three times.
+//   pass 1: running (max, sum) with rescaling  -> block reduce -> (m, S)
+//   pass 2: re-read the row and emit exp(x-m)/S
+// 128-bit loads and stores (8 bf16 per access); everything in fp32.
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+
+#define NTHREAD 512
+
+__global__ __launch_bounds__(NTHREAD) void softmax_k(const __nv_bfloat16* __restrict__ x,
+                                                     __nv_bfloat16* __restrict__ out, int V){
+    const long row = blockIdx.x;
+    const uint4* xr = reinterpret_cast<const uint4*>(x + row * (long)V);
+    uint4* orow = reinterpret_cast<uint4*>(out + row * (long)V);
+    const int nvec = V / 8;
+
+    float m = -INFINITY, s = 0.f;
+    for(int i = threadIdx.x; i < nvec; i += NTHREAD){         // online max+sum
+        uint4 v = xr[i];
+        const __nv_bfloat16* h = reinterpret_cast<const __nv_bfloat16*>(&v);
+        float lm = -INFINITY;
+        #pragma unroll
+        for(int j = 0; j < 8; j++) lm = fmaxf(lm, __bfloat162float(h[j]));
+        if(lm > m){ s *= __expf(m - lm); m = lm; }
+        #pragma unroll
+        for(int j = 0; j < 8; j++) s += __expf(__bfloat162float(h[j]) - m);
+    }
+    // block reduce: max first, then rescale each lane's sum onto it
+    __shared__ float sm[NTHREAD / 32], ss[NTHREAD / 32];
+    float mm = m;
+    for(int o = 16; o; o >>= 1) mm = fmaxf(mm, __shfl_xor_sync(0xffffffff, mm, o));
+    if((threadIdx.x & 31) == 0) sm[threadIdx.x >> 5] = mm;
+    __syncthreads();
+    if(threadIdx.x < 32){
+        float v = (threadIdx.x < NTHREAD / 32) ? sm[threadIdx.x] : -INFINITY;
+        for(int o = 16; o; o >>= 1) v = fmaxf(v, __shfl_xor_sync(0xffffffff, v, o));
+        if(threadIdx.x == 0) sm[0] = v;
+    }
+    __syncthreads();
+    const float M = sm[0];
+    float sv = s * __expf(m - M);
+    for(int o = 16; o; o >>= 1) sv += __shfl_xor_sync(0xffffffff, sv, o);
+    if((threadIdx.x & 31) == 0) ss[threadIdx.x >> 5] = sv;
+    __syncthreads();
+    if(threadIdx.x < 32){
+        float v = (threadIdx.x < NTHREAD / 32) ? ss[threadIdx.x] : 0.f;
+        for(int o = 16; o; o >>= 1) v += __shfl_xor_sync(0xffffffff, v, o);
+        if(threadIdx.x == 0) ss[0] = v;
+    }
+    __syncthreads();
+    const float inv = 1.0f / ss[0];
+
+    for(int i = threadIdx.x; i < nvec; i += NTHREAD){
+        uint4 v = xr[i];
+        const __nv_bfloat16* h = reinterpret_cast<const __nv_bfloat16*>(&v);
+        __nv_bfloat16 o8[8];
+        #pragma unroll
+        for(int j = 0; j < 8; j++) o8[j] = __float2bfloat16(__expf(__bfloat162float(h[j]) - M) * inv);
+        orow[i] = *reinterpret_cast<const uint4*>(o8);
+    }
+}
+
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B, int V){
+    softmax_k<<<B, NTHREAD>>>(x, out, V);
+}

tasks/raw-cuda/cuda-blockwise-softmax/solution/solve.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Oracle: restore the reference fast kernel.
+set -e
+cat > /app/solution.cu <<'ORACLE_CU_EOF'
+// Oracle: one block per row, ONLINE softmax so the row is read twice instead of three times.
+//   pass 1: running (max, sum) with rescaling  -> block reduce -> (m, S)
+//   pass 2: re-read the row and emit exp(x-m)/S
+// 128-bit loads and stores (8 bf16 per access); everything in fp32.
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+
+#define NTHREAD 512
+
+__global__ __launch_bounds__(NTHREAD) void softmax_k(const __nv_bfloat16* __restrict__ x,
+                                                     __nv_bfloat16* __restrict__ out, int V){
+    const long row = blockIdx.x;
+    const uint4* xr = reinterpret_cast<const uint4*>(x + row * (long)V);
+    uint4* orow = reinterpret_cast<uint4*>(out + row * (long)V);
+    const int nvec = V / 8;
+
+    float m = -INFINITY, s = 0.f;
+    for(int i = threadIdx.x; i < nvec; i += NTHREAD){         // online max+sum
+        uint4 v = xr[i];
+        const __nv_bfloat16* h = reinterpret_cast<const __nv_bfloat16*>(&v);
+        float lm = -INFINITY;
+        #pragma unroll
+        for(int j = 0; j < 8; j++) lm = fmaxf(lm, __bfloat162float(h[j]));
+        if(lm > m){ s *= __expf(m - lm); m = lm; }
+        #pragma unroll
+        for(int j = 0; j < 8; j++) s += __expf(__bfloat162float(h[j]) - m);
+    }
+    // block reduce: max first, then rescale each lane's sum onto it
+    __shared__ float sm[NTHREAD / 32], ss[NTHREAD / 32];
+    float mm = m;
+    for(int o = 16; o; o >>= 1) mm = fmaxf(mm, __shfl_xor_sync(0xffffffff, mm, o));
+    if((threadIdx.x & 31) == 0) sm[threadIdx.x >> 5] = mm;
+    __syncthreads();
+    if(threadIdx.x < 32){
+        float v = (threadIdx.x < NTHREAD / 32) ? sm[threadIdx.x] : -INFINITY;
+        for(int o = 16; o; o >>= 1) v = fmaxf(v, __shfl_xor_sync(0xffffffff, v, o));
+        if(threadIdx.x == 0) sm[0] = v;
+    }
+    __syncthreads();
+    const float M = sm[0];
+    float sv = s * __expf(m - M);
+    for(int o = 16; o; o >>= 1) sv += __shfl_xor_sync(0xffffffff, sv, o);
+    if((threadIdx.x & 31) == 0) ss[threadIdx.x >> 5] = sv;
+    __syncthreads();
+    if(threadIdx.x < 32){
+        float v = (threadIdx.x < NTHREAD / 32) ? ss[threadIdx.x] : 0.f;
+        for(int o = 16; o; o >>= 1) v += __shfl_xor_sync(0xffffffff, v, o);
+        if(threadIdx.x == 0) ss[0] = v;
+    }
+    __syncthreads();
+    const float inv = 1.0f / ss[0];
+
+    for(int i = threadIdx.x; i < nvec; i += NTHREAD){
+        uint4 v = xr[i];
+        const __nv_bfloat16* h = reinterpret_cast<const __nv_bfloat16*>(&v);
+        __nv_bfloat16 o8[8];
+        #pragma unroll
+        for(int j = 0; j < 8; j++) o8[j] = __float2bfloat16(__expf(__bfloat162float(h[j]) - M) * inv);
+        orow[i] = *reinterpret_cast<const uint4*>(o8);
+    }
+}
+
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B, int V){
+    softmax_k<<<B, NTHREAD>>>(x, out, V);
+}
+ORACLE_CU_EOF
+echo restored

tasks/raw-cuda/cuda-blockwise-softmax/task.toml

@@ -0,0 +1,36 @@
+schema_version = "1.1"
+
+[task]
+name = "mle-bench/cuda-blockwise-softmax"
+description = "Write a fast hand-written CUDA kernel for a row-wise softmax over very long rows (bf16 [4096, 131072], 2.15 GB), beating a one-thread-per-row three-pass reference by a calibrated margin. A row is 256 KB so it cannot be held on chip: the win is the online (running max + rescaled sum) recurrence that turns three HBM passes into two, one block per row with a single max and a single sum reduction, and 128-bit accesses. Outlier rows overflow fp32 unless the row max is subtracted, so the numerically stable form is graded. Hand-written CUDA only (CUTLASS/flashinfer/CUB); no PyTorch/Triton; ncu/nsys available."
+authors = []
+keywords = [ "mle", "kernel-generation", "cuda", "softmax", "online-softmax", "reduction", "bandwidth", "gpu",]
+
+[metadata]
+suite = "mle-bench"
+group = "kernel-generation"
+level = "1.0"
+difficulty = "hard"
+category = "mle"
+tags = [ "mle", "kernel-generation", "cuda", "gpu", "performance", "real-world",]
+
+[verifier]
+timeout_sec = 600.0
+
+[agent]
+timeout_sec = 14400.0
+
+[environment]
+build_timeout_sec = 3600.0
+cpus = 8
+memory_mb = 32768
+storage_mb = 40960
+gpus = 1
+network_mode = "public"
+mcp_servers = []
+
+[verifier.env]
+
+[environment.env]
+
+[solution.env]

tasks/raw-cuda/cuda-blockwise-softmax/tests/harness.cu

@@ -0,0 +1,128 @@
+// Grading harness for cuda-blockwise-softmax.
+//   out[b, v] = exp(x[b,v] - max_v x[b,v]) / sum_v exp(x[b,v] - max_v x[b,v])     per row, in fp32
+//   x[B, V] bfloat16 row-major in, out[B, V] bfloat16 row-major out.
+// Rows are LONG (V = 131072) and a few of them carry logits large enough that exp() overflows fp32
+// unless the row max is subtracted first -- the numerically stable form is required, not optional.
+// Inputs are generated ON DEVICE from the seed (deterministic and fast).
+// The naive reference is one thread per row, three sequential passes over the row.
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <algorithm>
+
+#define CK(x) do{ cudaError_t e=(x); if(e!=cudaSuccess){ printf("CUDA err %s:%d %s\n",__FILE__,__LINE__,cudaGetErrorString(e)); exit(2);} }while(0)
+
+static const int B = 4096, V = 131072;       // 5.4e8 elements: 1.07 GB in, 1.07 GB out
+static const float TOL = 5e-3f;
+#ifndef R_BAR
+#define R_BAR 29.0f
+#endif
+
+// ---- the agent's kernel ------------------------------------------------------------------------
+void row_softmax(const __nv_bfloat16* x, __nv_bfloat16* out, int B_, int V_);
+
+// ---- deterministic device-side input generation -------------------------------------------------
+__device__ __forceinline__ unsigned mix(unsigned a){
+    a ^= a >> 16; a *= 0x7feb352du; a ^= a >> 15; a *= 0x846ca68bu; a ^= a >> 16; return a;
+}
+__device__ __forceinline__ float unif(unsigned s){ return (mix(s) >> 8) * (1.0f / 16777216.0f); }
+
+__global__ void gen_kernel(__nv_bfloat16* x, long n, int V_, unsigned seed){
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        unsigned s = mix((unsigned)(i ^ (i >> 32)) * 2654435761u + seed);
+        float u1 = fmaxf(unif(s), 1e-7f), u2 = unif(s + 12345u);
+        float g = sqrtf(-2.0f * logf(u1)) * cospif(2.0f * u2);
+        int row = (int)(i / V_);
+        // most rows are ordinary attention-scale logits; every 97th row is an outlier row whose
+        // logits reach ~140, so exp() overflows fp32 if the row max is not subtracted first
+        float sc = (row % 97 == 0) ? 30.0f : 3.0f;
+        x[i] = __float2bfloat16(g * sc);
+    }
+}
+
+// ---- naive reference: one thread per row, three sequential passes --------------------------------
+__global__ void naive_kernel(const __nv_bfloat16* x, __nv_bfloat16* out, int B_, int V_){
+    for(long r = (long)blockIdx.x * blockDim.x + threadIdx.x; r < B_; r += (long)gridDim.x * blockDim.x){
+        const __nv_bfloat16* xr = x + r * (long)V_;
+        __nv_bfloat16* orow = out + r * (long)V_;
+        float m = -INFINITY;
+        for(int j = 0; j < V_; j++) m = fmaxf(m, __bfloat162float(xr[j]));
+        float s = 0.f;
+        for(int j = 0; j < V_; j++) s += expf(__bfloat162float(xr[j]) - m);
+        float inv = 1.f / s;
+        for(int j = 0; j < V_; j++) orow[j] = __float2bfloat16(expf(__bfloat162float(xr[j]) - m) * inv);
+    }
+}
+
+// ---- comparison: relative Frobenius --------------------------------------------------------------
+__global__ void cmp_kernel(const __nv_bfloat16* a, const __nv_bfloat16* b, long n, double* acc){
+    __shared__ double sn[256], sd[256];
+    double num = 0.0, den = 0.0;
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        double va = (double)__bfloat162float(a[i]), vb = (double)__bfloat162float(b[i]);
+        if(!isfinite(va)) va = 1e30;                 // an inf/nan from an unstable kernel must not pass
+        num += (va - vb) * (va - vb);
+        den += vb * vb;
+    }
+    sn[threadIdx.x] = num; sd[threadIdx.x] = den;
+    __syncthreads();
+    for(int o = blockDim.x >> 1; o; o >>= 1){
+        if(threadIdx.x < o){ sn[threadIdx.x] += sn[threadIdx.x + o]; sd[threadIdx.x] += sd[threadIdx.x + o]; }
+        __syncthreads();
+    }
+    if(threadIdx.x == 0){ atomicAdd(acc, sn[0]); atomicAdd(acc + 1, sd[0]); }
+}
+
+typedef void(*Fn)(const __nv_bfloat16*, __nv_bfloat16*);
+static float time_ms(Fn run, const __nv_bfloat16* a, __nv_bfloat16* b, int warm, int iters){
+    cudaEvent_t ev0, ev1; CK(cudaEventCreate(&ev0)); CK(cudaEventCreate(&ev1));
+    for(int i = 0; i < warm; i++) run(a, b);
+    CK(cudaDeviceSynchronize());
+    std::vector<float> ts;
+    for(int i = 0; i < iters; i++){
+        CK(cudaEventRecord(ev0)); run(a, b); CK(cudaEventRecord(ev1));
+        CK(cudaEventSynchronize(ev1)); float ms; CK(cudaEventElapsedTime(&ms, ev0, ev1)); ts.push_back(ms);
+    }
+    std::sort(ts.begin(), ts.end()); return ts[ts.size() / 2];
+}
+static void run_naive(const __nv_bfloat16* a, __nv_bfloat16* b){ naive_kernel<<<64, 64>>>(a, b, B, V); }
+static void run_agent(const __nv_bfloat16* a, __nv_bfloat16* b){ row_softmax(a, b, B, V); }
+
+int main(int argc, char** argv){
+    unsigned seed = argc > 1 ? (unsigned)atoi(argv[1]) : 1234u;
+    long n = (long)B * V;
+    __nv_bfloat16 *x, *oref, *oag; double* acc;
+    CK(cudaMalloc(&x, n * 2)); CK(cudaMalloc(&oref, n * 2)); CK(cudaMalloc(&oag, n * 2));
+    CK(cudaMalloc(&acc, 16)); CK(cudaMemset(acc, 0, 16)); CK(cudaMemset(oag, 0, n * 2));
+    gen_kernel<<<1024, 256>>>(x, n, V, seed);
+    CK(cudaDeviceSynchronize());
+
+    run_naive(x, oref); CK(cudaDeviceSynchronize());
+    run_agent(x, oag);  CK(cudaDeviceSynchronize());
+    cudaError_t ge = cudaGetLastError();
+
+    cmp_kernel<<<1024, 256>>>(oag, oref, n, acc);
+    CK(cudaDeviceSynchronize());
+    double h[2]; CK(cudaMemcpy(h, acc, 16, cudaMemcpyDeviceToHost));
+    double rel = sqrt(h[0] / (h[1] + 1e-30));
+
+    float tn = time_ms(run_naive, x, oref, 1, 3);
+    float ta = time_ms(run_agent, x, oag, 5, 30);
+    float sp = tn / ta;
+    bool correct = (ge == cudaSuccess) && (rel < TOL);
+    bool fast = sp >= R_BAR;
+    double reward = (correct && fast) ? 1.0 : 0.0;
+    printf("rel_err=%.3e | naive=%.3f ms agent=%.3f ms speedup=%.2fx (bar %.2f) | correct=%d fast=%d "
+           "-> reward=%.1f\n", rel, tn, ta, sp, (float)R_BAR, correct, fast, reward);
+    if(ge != cudaSuccess) printf("agent kernel error: %s\n", cudaGetErrorString(ge));
+    system("mkdir -p /logs/verifier");
+    FILE* f = fopen("/logs/verifier/reward.json", "w");
+    if(f){ fprintf(f, "{\"reward\": %.1f, \"correct\": %d, \"fast\": %d, \"rel_err\": %.3e, "
+                      "\"naive_ms\": %.3f, \"agent_ms\": %.3f, \"speedup\": %.3f}\n",
+                   reward, correct, fast, rel, tn, ta, sp); fclose(f); }
+    FILE* ft = fopen("/logs/verifier/reward.txt", "w"); if(ft){ fprintf(ft, "%.1f\n", reward); fclose(ft); }
+    return 0;
+}

tasks/raw-cuda/cuda-blockwise-softmax/tests/test.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Verifier: compile the FRESH harness + the agent's solution, grade with a random seed.
+set -uo pipefail
+mkdir -p /logs/verifier
+SEED=$(( (RANDOM << 15) ^ RANDOM ))
+nvcc -O3 -arch=native /tests/harness.cu /app/solution.cu -I/opt/flashinfer/include -I/opt/cutlass/include -o /tmp/grade 2>/tmp/nvcc.log
+if [ ! -x /tmp/grade ]; then
+  echo "COMPILE FAILED:"; tail -20 /tmp/nvcc.log
+  echo "0.0" > /logs/verifier/reward.txt
+  echo '{"reward": 0.0, "error": "compile_failed"}' > /logs/verifier/reward.json
+  exit 0
+fi
+/tmp/grade "$SEED"            # the harness writes /logs/verifier/reward.{txt,json}
+cat /logs/verifier/reward.json 2>/dev/null || true

tasks/raw-cuda/cuda-fp8-cast-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/raw-cuda/cuda-fp8-cast-pack/environment/Dockerfile

@@ -0,0 +1,34 @@
+# CUDA kernel-generation task: write a fast per-token FP8 quantisation kernel in solution.cu.
+# Toolchain only: nvcc / CUDA / CUTLASS / flashinfer + ncu/nsys.  NO PyTorch, NO Triton.
+FROM nvidia/cuda:12.8.1-devel-ubuntu24.04
+
+# ncu ships in the devel image (/usr/local/cuda/bin/ncu); add nsys + build/firewall deps.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git ca-certificates curl iptables iproute2 nsight-compute nsight-systems && \
+    rm -rf /var/lib/apt/lists/*
+
+# Header-only deps the agent's kernel may use (cloned at build time; runtime is firewalled).
+# Keep only flashinfer's include/ — its python source (which contains a triton submodule) isn't needed,
+# and dropping it keeps the environment free of any torch/triton files.
+RUN git clone --depth 1 https://github.com/NVIDIA/cutlass /opt/cutlass && rm -rf /opt/cutlass/.git && \
+    git clone --depth 1 https://github.com/flashinfer-ai/flashinfer /tmp/fi && \
+    mkdir -p /opt/flashinfer && mv /tmp/fi/include /opt/flashinfer/include && rm -rf /tmp/fi
+
+# Pre-bake the agent (the offline firewall blocks installing it at run time).
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && /root/.local/bin/uv tool install mini-swe-agent
+ENV PATH=/root/.local/bin:$PATH
+
+# Task workspace: the stub the agent edits, a dev copy of the grading harness, and a build helper.
+WORKDIR /app
+COPY CLAUDE.md PROCESS_MANAGEMENT.md /app/
+COPY solution.cu /app/solution.cu
+COPY harness.cu  /app/harness.cu
+COPY build.sh    /app/build.sh
+RUN chmod +x /app/build.sh
+
+# Offline firewall (allow the LLM API, block github/pypi/HF so reference kernels can't be fetched).
+COPY restrict-network.sh /app/restrict-network.sh
+RUN chmod +x /app/restrict-network.sh
+
+# Strip apt sources so harbor's base apt-setup is a no-op under the firewall.
+RUN rm -rf /etc/apt/sources.list /etc/apt/sources.list.d /var/lib/apt/lists/*

tasks/raw-cuda/cuda-fp8-cast-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/raw-cuda/cuda-fp8-cast-pack/environment/build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Compile your solution against the harness and run one seed (the grader uses a different seed).
+set -e
+nvcc -O3 -arch=native /app/harness.cu /app/solution.cu -I/opt/flashinfer/include -I/opt/cutlass/include -o /app/run
+/app/run 0

tasks/raw-cuda/cuda-fp8-cast-pack/environment/docker-compose.yaml

@@ -0,0 +1,17 @@
+# Anti-cheat firewall + profiling caps, merged on top of Harbor's base compose.
+# NET_ADMIN: restrict-network.sh installs the outbound allowlist (LLM API only; github/pypi/HF blocked).
+# SYS_ADMIN: lets the agent run ncu (GPU performance counters) inside the container (the host has
+#            NVreg_RestrictProfilingToAdminUsers=0). network_mode stays "public" — the firewall enforces it.
+services:
+  main:
+    cap_add:
+      - NET_ADMIN
+      - SYS_ADMIN
+    entrypoint: ["/bin/bash", "/app/restrict-network.sh"]
+    environment:
+      - ALLOWED_HOSTS=${ALLOWED_HOSTS:-}
+      - 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/raw-cuda/cuda-fp8-cast-pack/environment/harness.cu

@@ -0,0 +1,145 @@
+// Grading harness for cuda-fp8-cast-pack.
+//   Per-row (per-token) FP8 e4m3 activation quantisation:
+//     scale[m] = max( max_n |x[m,n]| , 1e-12f ) / 448.0f
+//     q[m,n]   = fp8_e4m3( x[m,n] / scale[m] )        (round-to-nearest-even, saturating)
+//   x[M,N] bfloat16 row-major in; q[M,N] fp8_e4m3 + scale[M] float32 out.
+// Inputs are generated ON DEVICE from the seed (deterministic, and fast enough to iterate on).
+// The naive reference is one thread per row, two sequential passes over the row.
+// Correctness: scales must agree to 1e-6 relative, and the DEQUANTISED values (q*scale) to 5e-3
+// relative Frobenius -- which tolerates the odd 1-ulp code flip but not a wrong rounding rule.
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+#include <cuda_fp8.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <algorithm>
+
+#define CK(x) do{ cudaError_t e=(x); if(e!=cudaSuccess){ printf("CUDA err %s:%d %s\n",__FILE__,__LINE__,cudaGetErrorString(e)); exit(2);} }while(0)
+
+static const int M = 32768, N = 16384;       // 5.4e8 elements: 1.07 GB in, 537 MB + 128 KB out
+static const float FP8_MAX = 448.0f;
+static const float TOL_DEQ = 5e-3f;          // relative Frobenius on dequantised values
+static const float TOL_SCALE = 1e-6f;        // relative, per row
+#ifndef R_BAR
+#define R_BAR 20.0f
+#endif
+
+// ---- the agent's kernel ------------------------------------------------------------------------
+void fp8_row_quant(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* scale, int M_, int N_);
+
+// ---- deterministic device-side input generation -------------------------------------------------
+__device__ __forceinline__ unsigned mix(unsigned a){
+    a ^= a >> 16; a *= 0x7feb352du; a ^= a >> 15; a *= 0x846ca68bu; a ^= a >> 16; return a;
+}
+__device__ __forceinline__ float unif(unsigned s){ return (mix(s) >> 8) * (1.0f / 16777216.0f); }
+
+// gaussian-ish (Box-Muller) times a per-row magnitude that spans ~30x, so row scales really differ
+__global__ void gen_kernel(__nv_bfloat16* x, long n, int N_, unsigned seed){
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        unsigned s = mix((unsigned)(i ^ (i >> 32)) * 2654435761u + seed);
+        float u1 = fmaxf(unif(s), 1e-7f), u2 = unif(s + 12345u);
+        float g = sqrtf(-2.0f * logf(u1)) * cospif(2.0f * u2);
+        int row = (int)(i / N_);
+        float rs = expf(unif(mix(row * 9781u + seed)) * 3.4f - 1.7f);
+        x[i] = __float2bfloat16(g * rs);
+    }
+}
+
+// ---- naive reference: one thread per row, two sequential passes ----------------------------------
+__global__ void naive_kernel(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* scale, int M_, int N_){
+    for(long r = (long)blockIdx.x * blockDim.x + threadIdx.x; r < M_; r += (long)gridDim.x * blockDim.x){
+        const __nv_bfloat16* xr = x + r * (long)N_;
+        float amax = 0.f;
+        for(int j = 0; j < N_; j++) amax = fmaxf(amax, fabsf(__bfloat162float(xr[j])));
+        float s = fmaxf(amax, 1e-12f) / FP8_MAX;
+        scale[r] = s;
+        __nv_fp8_e4m3* qr = q + r * (long)N_;
+        for(int j = 0; j < N_; j++) qr[j] = __nv_fp8_e4m3(__bfloat162float(xr[j]) / s);
+    }
+}
+
+// ---- comparison ---------------------------------------------------------------------------------
+__global__ void cmp_kernel(const __nv_fp8_e4m3* a, const float* sa, const __nv_fp8_e4m3* b,
+                           const float* sb, long n, int N_, double* acc){
+    __shared__ double sn[256], sd[256];
+    double num = 0.0, den = 0.0;
+    for(long i = (long)blockIdx.x * blockDim.x + threadIdx.x; i < n; i += (long)gridDim.x * blockDim.x){
+        int row = (int)(i / N_);
+        double va = (double)__half2float(__nv_cvt_fp8_to_halfraw(a[i].__x, __NV_E4M3)) * sa[row];
+        double vb = (double)__half2float(__nv_cvt_fp8_to_halfraw(b[i].__x, __NV_E4M3)) * sb[row];
+        num += (va - vb) * (va - vb);
+        den += vb * vb;
+    }
+    sn[threadIdx.x] = num; sd[threadIdx.x] = den;
+    __syncthreads();
+    for(int o = blockDim.x >> 1; o; o >>= 1){
+        if(threadIdx.x < o){ sn[threadIdx.x] += sn[threadIdx.x + o]; sd[threadIdx.x] += sd[threadIdx.x + o]; }
+        __syncthreads();
+    }
+    if(threadIdx.x == 0){ atomicAdd(acc, sn[0]); atomicAdd(acc + 1, sd[0]); }
+}
+__global__ void cmp_scale(const float* a, const float* b, int m, float* worst){
+    for(int i = blockIdx.x * blockDim.x + threadIdx.x; i < m; i += gridDim.x * blockDim.x){
+        float e = fabsf(a[i] - b[i]) / fmaxf(fabsf(b[i]), 1e-30f);
+        atomicMax((int*)worst, __float_as_int(e));           // all values are >= 0
+    }
+}
+
+typedef void(*Fn)(const __nv_bfloat16*, __nv_fp8_e4m3*, float*);
+static float time_ms(Fn run, const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* s, int warm, int iters){
+    cudaEvent_t a, b; CK(cudaEventCreate(&a)); CK(cudaEventCreate(&b));
+    for(int i = 0; i < warm; i++) run(x, q, s);
+    CK(cudaDeviceSynchronize());
+    std::vector<float> ts;
+    for(int i = 0; i < iters; i++){
+        CK(cudaEventRecord(a)); run(x, q, s); CK(cudaEventRecord(b));
+        CK(cudaEventSynchronize(b)); float ms; CK(cudaEventElapsedTime(&ms, a, b)); ts.push_back(ms);
+    }
+    std::sort(ts.begin(), ts.end()); return ts[ts.size() / 2];
+}
+static void run_naive(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* s){ naive_kernel<<<256, 128>>>(x, q, s, M, N); }
+static void run_agent(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* s){ fp8_row_quant(x, q, s, M, N); }
+
+int main(int argc, char** argv){
+    unsigned seed = argc > 1 ? (unsigned)atoi(argv[1]) : 1234u;
+    long n = (long)M * N;
+    __nv_bfloat16* x; __nv_fp8_e4m3 *qr, *qa; float *sr, *sa; double* acc; float* worst;
+    CK(cudaMalloc(&x, n * 2)); CK(cudaMalloc(&qr, n)); CK(cudaMalloc(&qa, n));
+    CK(cudaMalloc(&sr, M * 4)); CK(cudaMalloc(&sa, M * 4));
+    CK(cudaMalloc(&acc, 16)); CK(cudaMalloc(&worst, 4));
+    CK(cudaMemset(acc, 0, 16)); CK(cudaMemset(worst, 0, 4));
+    CK(cudaMemset(qa, 0, n)); CK(cudaMemset(sa, 0, M * 4));
+    gen_kernel<<<1024, 256>>>(x, n, N, seed);
+    CK(cudaDeviceSynchronize());
+
+    run_naive(x, qr, sr); CK(cudaDeviceSynchronize());
+    run_agent(x, qa, sa); CK(cudaDeviceSynchronize());
+    cudaError_t ge = cudaGetLastError();
+
+    cmp_kernel<<<1024, 256>>>(qa, sa, qr, sr, n, N, acc);
+    cmp_scale<<<64, 256>>>(sa, sr, M, worst);
+    CK(cudaDeviceSynchronize());
+    double h[2]; float ws;
+    CK(cudaMemcpy(h, acc, 16, cudaMemcpyDeviceToHost));
+    CK(cudaMemcpy(&ws, worst, 4, cudaMemcpyDeviceToHost));
+    double rel = sqrt(h[0] / (h[1] + 1e-30));
+
+    float tn = time_ms(run_naive, x, qr, sr, 1, 5);
+    float ta = time_ms(run_agent, x, qa, sa, 5, 30);
+    float sp = tn / ta;
+    bool correct = (ge == cudaSuccess) && (rel < TOL_DEQ) && (ws < TOL_SCALE);
+    bool fast = sp >= R_BAR;
+    double reward = (correct && fast) ? 1.0 : 0.0;
+    printf("rel_deq=%.3e scale_err=%.3e | naive=%.3f ms agent=%.3f ms speedup=%.2fx (bar %.2f) | "
+           "correct=%d fast=%d -> reward=%.1f\n", rel, ws, tn, ta, sp, (float)R_BAR, correct, fast, reward);
+    if(ge != cudaSuccess) printf("agent kernel error: %s\n", cudaGetErrorString(ge));
+    system("mkdir -p /logs/verifier");
+    FILE* f = fopen("/logs/verifier/reward.json", "w");
+    if(f){ fprintf(f, "{\"reward\": %.1f, \"correct\": %d, \"fast\": %d, \"rel_deq\": %.3e, "
+                      "\"scale_err\": %.3e, \"naive_ms\": %.3f, \"agent_ms\": %.3f, \"speedup\": %.3f}\n",
+                   reward, correct, fast, rel, ws, tn, ta, sp); fclose(f); }
+    FILE* ft = fopen("/logs/verifier/reward.txt", "w"); if(ft){ fprintf(ft, "%.1f\n", reward); fclose(ft); }
+    return 0;
+}

tasks/raw-cuda/cuda-fp8-cast-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 fetch sglang's own Gemma4 implementation (`pip install sglang`, `git clone
+# sgl-project/sglang`, HF) and copy it. The model is already staged 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=(
+    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/raw-cuda/cuda-fp8-cast-pack/environment/solution.cu

@@ -0,0 +1,20 @@
+// solution.cu — implement the per-row FP8 quantisation described in the instruction.
+//   scale[m] = max( max_n |x[m,n]| , 1e-12f ) / 448.0f
+//   q[m,n]   = fp8_e4m3( x[m,n] / scale[m] )        round-to-nearest-even, saturating
+// x[M,N] is bfloat16 row-major; q[M,N] is float8_e4m3 row-major; scale[M] is float32.
+// M = 32768, N = 16384 (fixed).  Reductions and the division must be done in fp32.
+// This stub writes zeros (it compiles and runs, but is incorrect — reward 0).
+#include <cuda_runtime.h>
+#include <cuda_bf16.h>
+#include <cuda_fp8.h>
+
+__global__ void stub_k(__nv_fp8_e4m3* q, float* s, long n, int m){
+    long i = (long)blockIdx.x * blockDim.x + threadIdx.x;
+    if(i < n) q[i] = __nv_fp8_e4m3(0.f);
+    if(i < m) s[i] = 1.f;
+}
+
+void fp8_row_quant(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* scale, int M, int N){
+    long n = (long)M * N;
+    stub_k<<<(n + 255) / 256, 256>>>(q, scale, n, M);
+}

tasks/raw-cuda/cuda-fp8-cast-pack/instruction.md

@@ -0,0 +1,61 @@
+# Write a fast CUDA kernel for per-token FP8 activation quantisation
+
+Implement a high-performance CUDA kernel in `/app/solution.cu` that quantises a `bfloat16` activation matrix
+to **float8_e4m3** with one scale per row — the step every FP8-served transformer runs in front of every GEMM.
+
+Input: `x` of shape `[M, N]` (`__nv_bfloat16`, row-major). Outputs: `q` of shape `[M, N]` (`__nv_fp8_e4m3`,
+row-major) and `scale` of shape `[M]` (`float`). For each row `m`:
+
+```
+amax     = max over n of |x[m, n]|                      # computed in fp32
+scale[m] = max(amax, 1e-12f) / 448.0f                    # 448 = max finite e4m3 magnitude
+q[m, n]  = fp8_e4m3( x[m, n] / scale[m] )                # round-to-nearest-even, saturating
+```
+
+so that `q[m,n] * scale[m]` reconstructs `x[m,n]` to FP8 accuracy. The sizes are fixed:
+**M = 32768, N = 16384** — 1.07 GB in, 537 MB + 128 KB out.
+
+The function signature (fixed) is in `/app/solution.cu`:
+```cpp
+void fp8_row_quant(const __nv_bfloat16* x, __nv_fp8_e4m3* q, float* scale, int M, int N);
+```
+
+## How success is decided
+
+The grader compiles your `solution.cu` against a fixed harness, generates seeded inputs on the device, and
+checks:
+1. **Correctness** — every `scale[m]` matches the reference to `1e-6` relative (the absmax is an exact
+   reduction, so a correct kernel matches it essentially exactly), and the dequantised values `q*scale` match
+   to `5e-3` relative Frobenius error. That tolerance absorbs the odd 1-ulp code flip — multiplying by
+   `1/scale` instead of dividing by `scale` measures `2e-3` and passes — but not a wrong rounding rule:
+   truncating instead of rounding to nearest scores about `4e-2`.
+2. **Performance** — your kernel is at least **R×** faster than a straightforward reference (CUDA-event
+   timed, warmup + median; the exact bar is printed when you build).
+
+Both must pass for reward 1.0.
+
+## Notes
+
+- This is a **pure bandwidth** problem: 1.07 GB has to come in and 537 MB has to go out, and the arithmetic
+  is one `fabsf`, one multiply and one conversion per element. Work out the roofline from the bandwidth you
+  measure (a large device-to-device copy is a good yardstick — do not trust a datasheet number), and treat
+  anything below it as a bug in your memory access pattern.
+- The reference the bar is measured against is **one thread per row**, walking the row twice. Every element
+  it touches is uncoalesced, which is exactly the trap: the fix is to give each row a *block* (or a warp) so
+  that consecutive lanes read consecutive addresses.
+- The scale for a row is not known until the whole row has been seen, so the obvious structure is two passes.
+  A row is `N * 2 = 32 KB`, which is small enough that it does **not** have to be re-read from HBM — think
+  about where you can keep it between the two passes, and how many rows a block should own.
+- Access width matters on both sides: `x` is 2 bytes/element and `q` is 1, so a 128-bit load covers 8 inputs
+  while a 128-bit store covers 16 outputs. Getting the store side wrong is the most common way to leave
+  bandwidth on the table. `__nv_cvt_float2_to_fp8x2` converts two values per instruction.
+- Available: `nvcc`, header-only **CUTLASS** (`/opt/cutlass/include`) and **flashinfer**
+  (`/opt/flashinfer/include`), **CUB/Thrust** (ship with CUDA), and the profilers **`ncu`** and **`nsys`**
+  (use them — `ncu` will tell you your achieved DRAM throughput directly). There is **no PyTorch and no
+  Triton**; this is a pure CUDA task.
+- Query the device you actually get with `cudaGetDeviceProperties` (SM count, shared memory per block, L2
+  size) and size your launch from that rather than from constants.
+- Build + test locally: **`bash /app/build.sh`** (compiles against the harness and runs one seed; the grader
+  uses a different seed). `/app/harness.cu` is the same harness used for grading — read it to see exactly how
+  you are measured; you only edit `solution.cu`.
+- **No internet access.**