# Manifest — what was run

Without this file, nobody will be able to say six months from now under what
conditions a given number was measured. It is the authoritative record of the
runtime stacks, the harness settings and the uncommitted local changes in
effect at measurement time.

This archive holds **two batches**. `CANONICAL.md` states the canonical run for
every (version × model) cell.

## Batch 1 · full clean sweep

```
run-id       vllm-{0.18.0,0.26.0,0.29.0}-vllm-only-h200-clean
date         2026-09-22 21:12 -- 2026-09-23 04:05 UTC (about 6h50m)
driver log   compare/fullsweep.log.gz
result       0.18 = 13/14, 0.26 = 13/14, 0.29 = 14/14
             (plus GLM-5.2-NVFP4 skipped on every leg, see below)
```

## Batch 2 · gemma-4 on the 0.26 leg, transformers pinned

```
run-id       vllm-0.26.0-vllm-only-h200-tfpin   (1 model)
               PINS_026="transformers==5.14.1"
               venv: /data-fast/fk-venvs/venv-vllm-0.26.0-transformers-5.14.1
               scenario table patches/scenarios_gemma4.yaml
date         2026-09-23 05:33 UTC
driver log   compare/backfill.log.gz
merged       0.18 = 13/14, 0.26 = 14/14, 0.29 = 14/14
```

**No cutlass backfill was required.** On B200 a second batch pinned
`nvidia-cutlass-dsl==4.5.3` to recover six models on the 0.18 leg. On Hopper
those six pass unpinned, so that batch does not exist here. This is itself a
result — see "Failure attribution" in `REPORT.md`.

## Hardware and node

```
node         alexsu-dev-h200-0
GPU          8 x NVIDIA H200, 143771 MiB each (1123 GiB total)
driver       NVRM 580.159.03
system CUDA  13.0 (V13.0.88)
```

For reference, the B200 node had 8 × 183359 MiB (1433 GiB). **The tensor-parallel
degrees were not changed** — every model ran at the same `tp` as on B200, and
nothing ran out of memory, including `gpt-oss-120b` at tp2, which was the
candidate for trouble. So the two studies are directly comparable at the same
`tp`.

`nvidia/GLM-5.2-NVFP4` is skipped by the harness on this architecture
(`NVFP4 is Blackwell-only`). It is a skip, not a failure: no process launched,
so there is no `run.log` and no `results.json` for it on any leg.

## The three runtime stacks

Identical to the B200 run, which is what makes the two comparable. torch / CUDA /
flashinfer are printed by `verify_one` during setup and can be checked in
`compare/fullsweep.log.gz`.

| leg | vllm | torch | CUDA | flashinfer | transformers | cutlass-dsl |
| --- | --- | --- | --- | --- | --- | --- |
| 0.18 | 0.18.0 | 2.10.0+cu128 | 12.8 | 0.6.6 | 4.57.6 | 4.8.0 |
| 0.26 | 0.26.0 | 2.11.0+cu130 | 13.0 | 0.6.14 | 5.17.0 | 4.6.0 |
| 0.29 | 0.29.0 | 2.13.0+cu130 | 13.0 | 0.6.18 | 5.17.0 | 4.6.2 |

The pinned venv from batch 2 changes exactly one package:

```
0.26 + transformers 5.14.1   torch 2.11.0+cu130 / flashinfer 0.6.14
```

Two things worth recording. The 0.29 `nvidia-cutlass-dsl` version is **4.6.2**;
the B200 manifest lists it as "not recorded", so this fills that gap. And the
0.18 leg resolved `nvidia-cutlass-dsl==4.8.0`, exactly as on B200 — verified
before the sweep that `cute.core.ThrMma` is absent from it. The broken
dependency is present here too; it simply never gets imported on Hopper.

The three venvs resolve to different transformers and cutlass-dsl versions
because `uv pip install vllm==<ver>` resolves each independently. This is a
confound that can only be disclosed, not removed — 0.18 cannot use
transformers 5.x.

## Environment hygiene

- Three isolated `uv` venvs; the conda environment is only the driver.
  `verify_one` confirmed `vllm-omni` is absent from all three legs.
- All three legs have `flashinfer-jit-cache` and `flashinfer-cubin` at versions
  matching `flashinfer-python`. Without them, six MoE models fail on a gcc
  internal compiler error.
- `VLLM_NO_USAGE_STATS=1` / `DO_NOT_TRACK=1`, and `VLLM_LOGGING_LEVEL=DEBUG` /
  `PYTHONFAULTHANDLER` deliberately **not** set: DEBUG output corrupts the stdout
  the usage-reporting thread parses, and `ray_runner._is_fatal_worker_line()`
  then reads the resulting traceback as a crash and kills a healthy worker.
- Weights were fetched by `patches/prefetch_weights.sh` before the sweep
  (1.6 TB, 15 models, zero incomplete files), so download time is not inside any
  task's `elapsed_s`.

One deviation, the same as on B200: `UV_CACHE_DIR` resolved to
`/tmp/cursor-sandbox-cache/.../uv` rather than `/data-fast/uv-cache`. This only
affects venv install speed (uv cannot hardlink, so wheels are copied in full)
and does not affect measurements.

## Harness settings

```
scenario table  fastkernels/scenarios/vllm_only.yaml, 15 models
                (archived as patches/vllm_only.yaml; 14 run, GLM skipped)
execution       strictly serial, whole node per task (FASTKERNELS_VALIDATE_SERIAL=1)
                no --resume, so every number is a real measurement
results dir     /code/users/alexsu/vllm-validate-h200   (deliberately separate
                from the B200 tree so the two studies cannot mix)
repository      main @ 9acebaa1349c78af8bb0ecb7e0719b5372d26fd8
                plus the same three uncommitted local changes as the B200 run
```

## Local changes (uncommitted)

The same three as the B200 study; the patches are in `patches/` and are the only
reliable record. Verified present on this node before the sweep:

```bash
grep -c 'getattr(mnnvl, "IpcSocket", None)' fastkernels/validate/bench_vllm.py   # 4
grep -c '_WHISPER_WINDOW_S'                 fastkernels/validate/bench_vllm.py   # 3
grep -c FASTKERNELS_VALIDATE_SERIAL         fastkernels/validate/ray_runner.py   # 1
```

1. `patches/bench_vllm.py.patch` — the `IpcSocket` fix (four call sites) and the
   whisper 30s clamp. LibriSpeech test.clean does contain samples longer than
   30s; the clamp works around a vLLM 0.29 whisper bug and must be disclosed.
2. `patches/ray_runner.py.patch` — the `FASTKERNELS_VALIDATE_SERIAL` switch.
3. `patches/compare_vllm_versions_datafast.sh` and
   `patches/prefetch_weights.sh` — untracked driver scripts, archived in full.

## Archive contents

```
README.md                          the dataset card, generated from REPORT.md
REPORT.md                          analysis report
MANIFEST.md                        this file
CANONICAL.md                       canonical run per (version x model)
make_tables.py                     regenerates the report tables from results/
make_card.py                       regenerates README.md from REPORT.md

results/<run-id>/<task>/results.json   41 files
results/<run-id>/run.jsonl             event stream per run

compare/0.18-vs-0.26.txt           pairwise tables, generated from the canonical
compare/0.26-vs-0.29.txt             run set (same source as REPORT.md's tables)
compare/fullsweep.log.gz           batch 1 driver log
compare/backfill.log.gz            batch 2 driver log

logs.tar.gz                        43 run.log (14 models x 3 legs + 1 tfpin;
                                   GLM was skipped so it produced none)
patches/                           uncommitted local changes + scenario tables
```

## Re-checking the pass matrix

```bash
python3 - <<'PY'
import json
p = 'results/vllm-0.29.0-vllm-only-h200-clean/run.jsonl'
subs, fins = {}, []
for line in open(p):
    r = json.loads(line)
    if r.get('event') == 'task_submitted':
        subs[r['job']['index']] = r['job']['name']
    if r.get('event') == 'run_finished':
        fins.append(r['results'])
for i, s in sorted(fins[-1].items(), key=lambda kv: int(kv[0])):
    print(f'{i:>3} {s:22} {subs.get(int(i))}')
PY
```

`SKIP(nvfp4-hopper)` on index 2 is `GLM-5.2-NVFP4` and is expected on every leg.