---
license: apache-2.0
language:
  - en
tags:
  - benchmark
  - vllm
  - inference
  - ablation
  - b200
  - blackwell
pretty_name: FastKernels vLLM version ablation (8xB200)
---
# vLLM 0.18 → 0.26 → 0.29: ablation, a three-way comparison

2026-09-21, 8×B200 (`alexsu-dev-b200-0`). How it was run, the runtime stacks and
the uncommitted local changes are all in `MANIFEST.md`.

**This is the first environment-clean dataset, and it is citable.** Every
performance number from the 2026-09-20 round is void: the 0.26 leg was
contaminated by the `vllm-omni` plugin, and all jobs ran concurrently. All three
legs in this report use isolated venvs, run strictly serially with the whole node
to themselves, and were measured without `--resume`, so every number was actually
measured. But **there is still almost no repeated measurement** — throughput is a
single timed pass except for one model; see "Known limitations".

## About this dataset

This page **is** the report. It is generated from [`REPORT.md`](REPORT.md); the
two are always identical.

Companion study: the same ablation on **H200 (Hopper)** is at
[Alexsssu/fastkernels-h200-vllm-ablation](https://huggingface.co/datasets/Alexsssu/fastkernels-h200-vllm-ablation). Same scenario
table, same tensor-parallel degrees, same three runtime stacks -- only the GPU
differs, which is what makes the two comparable. Most of the conclusions below do **not** reproduce there; each headline bullet is annotated with its H200 counterpart.

| path | what it is |
| --- | --- |
| [`REPORT.md`](REPORT.md) | the analysis below, as a file |
| [`CANONICAL.md`](CANONICAL.md) | which run is authoritative for each (version x model), and what was excluded |
| [`MANIFEST.md`](MANIFEST.md) | runtime stacks, harness settings, uncommitted local changes |
| `results/` | 49 `results.json` plus the per-run `run.jsonl` event streams |
| `compare/` | pairwise comparison tables, built from the same canonical runs as the tables below |
| `logs.tar.gz` | 58 `run.log`, one per task |
| `patches/` | the uncommitted local changes, the scenario tables, the driver scripts |
| `moe_backend_235b/`, `diag_silent4_summary.txt` | the two diagnostic sub-studies |
| [`SOURCE_NOTES.md`](SOURCE_NOTES.md) | internal working documents deliberately not shipped, and why |
| [`raw/`](raw) | raw harness output (194 MB tarball); see [`raw/RAW_CONTENTS.md`](raw/RAW_CONTENTS.md) |
| `make_tables.py`, `make_card.py` | regenerate the tables from `results/`, and this page from `REPORT.md` |

Every number below comes from `results/`. If the tables, `compare/*.txt` and
`results/` ever disagree, that is a bug -- please open a discussion.

## Coverage

| leg | passing | failing |
| --- | --- | --- |
| 0.18.0 | **13/15** | `GLM-5.2-NVFP4`, `gemma-4-26B` |
| 0.26.0 | **15/15** | — |
| 0.29.0 | **15/15** | — |

**13 models support a three-way comparison** (the clean re-run alone gave only 7).
The 6 that came back all did so from a single dependency pin, see "Failure
attribution". The 2 remaining 0.18 failures look identical from the outside, but
only `gemma-4-26B` is genuinely a case of "this older version does not support
this architecture".

## Headline findings

> **Read this first.** A companion run of this exact ablation on 8×H200
> (2026-09-22, same scenario table, same tp, same three runtime stacks) shows
> that **most of the findings below are Blackwell-specific and do not reproduce
> on Hopper.** Each bullet is annotated with its H200 counterpart. Treat them as
> architecture-conditional claims, not as properties of the vLLM versions.

- **0.18 → 0.26 is a story about whether a model runs at all, and about
  quantization support maturity** — not about a general speedup. Plain dense bf16
  `Llama-3.1-8B` lands within 1% across all three legs (21,943 / 22,263 / 22,157
  tok/s). The single large jump is `gpt-oss-120b` at **3.31x** (7,304 → 24,184),
  which corresponds to mxfp4 support maturing.
  **On H200 this is 1.03x.** vLLM 0.18 already reaches 11,290 tok/s there, so the
  3.31x measures a Blackwell-specific deficiency in 0.18 rather than an
  improvement in 0.26.
- **0.26 → 0.29 is a story about quantized-MoE and linear-attention kernels.**
  The winners are `GLM-5.2-NVFP4` at 2.47x, `Qwen3-VL-235B-FP8` image at 2.08x,
  `Qwen3-Next-80B` at 1.76x and `Kimi-Linear-48B` at 1.69x. Dense, ASR and the
  multimodal encoder paths are essentially flat (0.99–1.05x).
  **On H200 this story disappears**: 235B image 1.17x, `Qwen3-Next-80B` 1.01x,
  `Kimi-Linear-48B` 1.13x, and `GLM-5.2-NVFP4` cannot run at all because NVFP4 is
  SM100-only. 0.26 → 0.29 is close to flat across the board on Hopper.
- **Version progress is not monotonic.** `Qwen3-VL-235B-FP8` is *slower* on 0.26
  than on 0.18 (image 7,004 → 4,896, i.e. 0.70x) and only recovers to 10,175 on
  0.29. This one has since been measured three times per leg and it holds; the
  cause is still open, see "Is the 0.26 regression real?". `Qwen3-VL-8B` is flat
  across all three (15,582 / 15,496 / 15,336), with 0.29 marginally lowest. Do
  not tell this as "newer is faster".
  **This is the one finding that does transfer**: H200 measures 6,539 → 4,614,
  i.e. **0.71x** against 0.70x here, on a different architecture with a different
  attention backend. That agreement makes a real vLLM 0.26 decode-path defect the
  most likely explanation.

The three-way agreement on `Llama-3.1-8B` is the most important cross-check in
this round: it positively confirms that the 3x dip in the old data was an
artifact of the `vllm-omni` plugin plus concurrent neighbours, not a vLLM
version difference. The old claim of a "3.03x speedup from 0.26 to 0.29" does
not hold.

## Full data

### Throughput (tok/s, higher is better)

| model | tp | workload | 0.18 | 0.26 | 0.29 | 26/18 | 29/26 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `Llama-3.1-8B-Instruct` | 1 | mixed | 21,943 | 22,263 | 22,157 | 1.01x | 1.00x |
| `Llama-3.1-8B-Instruct` | 1 | long-context | 300 | 300 | 300 | 1.00x | 1.00x |
| `Mixtral-8x7B-Instruct-v0.1` | 2 | mixed | 14,177 | 15,351 | 18,740 | 1.08x | 1.22x |
| `Mixtral-8x7B-Instruct-v0.1` | 2 | long-context | 549 | 581 | 579 | 1.06x | 1.00x |
| `gpt-oss-120b` | 2 | mixed | 7,304 | 24,184 | 25,478 | 3.31x | 1.05x |
| `gpt-oss-120b` | 2 | long-context | 277 | 644 | 651 | 2.33x | 1.01x |
| `mamba-2.8b-hf` | 1 | mixed | 8,572 | 8,889 | 10,298 | 1.04x | 1.16x |
| `mamba-2.8b-hf` | 1 | long-context | 331 | 362 | 362 | 1.10x | 1.00x |
| `Mamba-Codestral-7B-v0.1` | 1 | mixed | 10,333 | 11,640 | 11,775 | 1.13x | 1.01x |
| `Mamba-Codestral-7B-v0.1` | 1 | long-context | 481 | 490 | 497 | 1.02x | 1.01x |
| `Qwen3-Next-80B-A3B-Instruct` | 2 | mixed | 10,201 | 10,329 | 18,227 | 1.01x | 1.76x |
| `Qwen3-Next-80B-A3B-Instruct` | 2 | long-context | 589 | 749 | 807 | 1.27x | 1.08x |
| `AI21-Jamba-Mini-1.7` | 1 | mixed | 4,404 | 5,498 | 5,552 | 1.25x | 1.01x |
| `AI21-Jamba-Mini-1.7` | 1 | long-context | 184 | 209 | 213 | 1.14x | 1.02x |
| `Kimi-Linear-48B-A3B-Instruct` | 2 | mixed | 13,224 | 13,550 | 22,910 | 1.02x | 1.69x |
| `Kimi-Linear-48B-A3B-Instruct` | 2 | long-context | 563 | 885 | 903 | 1.57x | 1.02x |
| `whisper-large-v3` | 1 | librispeech | 7,888 | 8,008 | 8,135 | 1.02x | 1.02x |
| `Qwen2-VL-7B-Instruct` | 1 | text-only | 16,079 | 17,482 | 17,620 | 1.09x | 1.01x |
| `Qwen2-VL-7B-Instruct` | 1 | image | 14,424 | 16,247 | 16,837 | 1.13x | 1.04x |
| `Qwen2-VL-7B-Instruct` | 1 | video | 2,487 | 2,600 | 3,082 | 1.05x | 1.19x |
| `Qwen3-VL-8B-Instruct` | 1 | text-only | 13,236 | 13,772 | 13,913 | 1.04x | 1.01x |
| `Qwen3-VL-8B-Instruct` | 1 | image | 15,582 | 15,496 | 15,336 | 0.99x | 0.99x |
| `Qwen3-VL-8B-Instruct` | 1 | video | 2,656 | 2,612 | 2,702 | 0.98x | 1.03x |
| `Qwen3-VL-235B-A22B-Instruct-FP8` | 4 | text-only | 4,444 | 3,985 | 6,934 | 0.90x | 1.74x |
| `Qwen3-VL-235B-A22B-Instruct-FP8` | 4 | image | 7,004 | 4,896 | 10,175 | 0.70x | 2.08x |
| `Qwen3-VL-235B-A22B-Instruct-FP8` | 4 | video | 1,390 | 1,451 | 2,075 | 1.04x | 1.43x |
| `Qwen2.5-Omni-7B` | 1 | text | 16,254 | 17,532 | 17,576 | 1.08x | 1.00x |
| `Qwen2.5-Omni-7B` | 1 | image | 13,120 | 13,627 | 13,957 | 1.04x | 1.02x |
| `Qwen2.5-Omni-7B` | 1 | video | 2,120 | 2,105 | 2,166 | 0.99x | 1.03x |
| `Qwen2.5-Omni-7B` | 1 | audio | 4,851 | 6,746 | 6,836 | 1.39x | 1.01x |
| `GLM-5.2-NVFP4` | 8 | mixed | — | 4,306 | 10,617 | — | 2.47x |
| `GLM-5.2-NVFP4` | 8 | long-context | — | 248 | 267 | — | 1.08x |
| `gemma-4-26B-A4B-it` | 1 | mixed | — | 10,528 | 12,171 | — | 1.16x |
| `gemma-4-26B-A4B-it` | 1 | long-context | — | 100 | 117 | — | 1.17x |

### Latency (ms/tok, lower is better)

| model | tp | workload | 0.18 | 0.26 | 0.29 | 18→26 | 26→29 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `Llama-3.1-8B-Instruct` | 1 | single-request | 3.82 | 3.73 | 3.83 | 1.02x | 0.97x |
| `Llama-3.1-8B-Instruct` | 1 | fixed-batch-32 | 0.18 | 0.17 | 0.18 | 1.04x | 0.99x |
| `Mixtral-8x7B-Instruct-v0.1` | 2 | single-request | 4.81 | 3.76 | 3.52 | 1.28x | 1.07x |
| `Mixtral-8x7B-Instruct-v0.1` | 2 | fixed-batch-32 | 0.38 | 0.33 | 0.33 | 1.15x | 1.00x |
| `gpt-oss-120b` | 2 | single-request | 4.04 | 2.45 | 2.50 | 1.65x | 0.98x |
| `gpt-oss-120b` | 2 | fixed-batch-32 | 0.49 | 0.19 | 0.19 | 2.51x | 1.01x |
| `mamba-2.8b-hf` | 1 | single-request | 3.61 | 3.16 | 3.20 | 1.14x | 0.99x |
| `mamba-2.8b-hf` | 1 | fixed-batch-32 | 0.37 | 0.35 | 0.35 | 1.05x | 1.00x |
| `Mamba-Codestral-7B-v0.1` | 1 | single-request | 5.01 | 4.02 | 3.74 | 1.25x | 1.07x |
| `Mamba-Codestral-7B-v0.1` | 1 | fixed-batch-32 | 0.27 | 0.23 | 0.23 | 1.15x | 1.03x |
| `Qwen3-Next-80B-A3B-Instruct` | 2 | single-request | 5.88 | 4.31 | 3.56 | 1.36x | 1.21x |
| `Qwen3-Next-80B-A3B-Instruct` | 2 | fixed-batch-32 | 0.36 | 0.28 | 0.27 | 1.31x | 1.03x |
| `AI21-Jamba-Mini-1.7` | 1 | single-request | 7.53 | 6.93 | 6.93 | 1.09x | 1.00x |
| `AI21-Jamba-Mini-1.7` | 1 | fixed-batch-32 | 0.86 | 0.82 | 0.81 | 1.05x | 1.01x |
| `Kimi-Linear-48B-A3B-Instruct` | 2 | single-request | 4.62 | 3.75 | 2.48 | 1.23x | 1.51x |
| `Kimi-Linear-48B-A3B-Instruct` | 2 | fixed-batch-32 | 0.29 | 0.24 | 0.22 | 1.19x | 1.11x |
| `whisper-large-v3` | 1 | single-utterance | 2.63 | 2.35 | 2.49 | 1.12x | 0.95x |
| `whisper-large-v3` | 1 | fixed-batch-32 | 0.18 | 0.17 | 0.17 | 1.02x | 0.98x |
| `Qwen2-VL-7B-Instruct` | 1 | single-image | 3.83 | 3.82 | 3.77 | 1.00x | 1.01x |
| `Qwen2-VL-7B-Instruct` | 1 | single-video | 5.20 | 5.12 | 4.76 | 1.02x | 1.08x |
| `Qwen3-VL-8B-Instruct` | 1 | single-image | 4.66 | 4.27 | 4.22 | 1.09x | 1.01x |
| `Qwen3-VL-8B-Instruct` | 1 | single-video | 5.79 | 5.44 | 5.30 | 1.06x | 1.03x |
| `Qwen3-VL-235B-A22B-Instruct-FP8` | 4 | single-image | 10.21 | 8.23 | 7.56 | 1.24x | 1.09x |
| `Qwen3-VL-235B-A22B-Instruct-FP8` | 4 | single-video | 12.30 | 10.24 | 8.92 | 1.20x | 1.15x |
| `Qwen2.5-Omni-7B` | 1 | single-text | 3.67 | 3.65 | 3.61 | 1.01x | 1.01x |
| `Qwen2.5-Omni-7B` | 1 | single-image | 3.92 | 3.90 | 3.88 | 1.01x | 1.00x |
| `Qwen2.5-Omni-7B` | 1 | single-video | 5.46 | 5.47 | 5.41 | 1.00x | 1.01x |
| `Qwen2.5-Omni-7B` | 1 | single-audio | 3.90 | 3.97 | 3.96 | 0.98x | 1.00x |
| `GLM-5.2-NVFP4` | 8 | single-request | — | 8.98 | 6.97 | — | 1.29x |
| `GLM-5.2-NVFP4` | 8 | fixed-batch-32 | — | 0.50 | 0.46 | — | 1.09x |
| `gemma-4-26B-A4B-it` | 1 | single-request | — | 4.34 | 4.10 | — | 1.06x |
| `gemma-4-26B-A4B-it` | 1 | fixed-batch-32 | — | 0.40 | 0.38 | — | 1.06x |

## Failure attribution

### Two root causes, not three

The targeted backfill on 2026-09-21 overturned the earlier three-way split. Our
runbook had grouped the 0.18 leg's 8 failures as A (architecture not recognized),
B (cutlass API drift) and C (multimodal encoder dying silently). **B and C turned
out to be the same bug**, and a fixable one.

| root cause | models | error | fixable? |
| --- | --- | --- | --- |
| **A · config not parseable by this leg's transformers** | 2 | pydantic `ValidationError` while constructing `ModelConfig`: model type `glm_moe_dsa` / `gemma4` not recognized | No, not within 0.18's declared constraints |
| **B · cutlass `ThrMma` relocation** | **6** | `AttributeError: module 'cutlass.cute.core' has no attribute 'ThrMma'` | **Yes** — pin `nvidia-cutlass-dsl==4.5.3` |

Group B is `Kimi-Linear-48B` and `Qwen3-VL-235B-FP8` (originally class B) plus
`whisper-large-v3`, `Qwen2-VL-7B`, `Qwen3-VL-8B` and `Qwen2.5-Omni-7B`
(originally class C). All six now pass and have real numbers.

**So the number of models that can be described as "this older version does not
support this architecture" is 1** (`gemma-4-26B`), not the 8 we originally
assumed. The other 7 are all dependency-version problems: 6 are fully recovered
by a single cutlass pin, and `GLM-5.2-NVFP4` is a different flavour of
version-window problem, covered next.

### Group A: only one of the two is genuinely unsupported

Both models fail identically from the outside, so it is tempting to write both
off as "vLLM 0.18 does not support this architecture". Only one of them is.

- **`gemma-4-26B` genuinely is unsupported.** It declares
  `Gemma4ForConditionalGeneration` / `model_type: gemma4`, and vLLM 0.18 contains
  no Gemma4 code at all — `grep -rn Gemma4 vllm/model_executor/models/` returns
  nothing, and the registry stops at `Gemma3nForConditionalGeneration`. Even with
  a transformers that could parse the config, there would be no implementation to
  run.
- **`GLM-5.2-NVFP4` is a version-window problem, not missing support.** The model
  declares `GlmMoeDsaForCausalLM` / `glm_moe_dsa`, and **vLLM 0.18 implements
  exactly that**: `registry.py:119` maps `GlmMoeDsaForCausalLM`, implemented at
  `deepseek_v2.py:1638`. What blocks it is transformers: the error text says
  *Transformers* does not recognize the architecture, not vLLM. `glm_moe_dsa`
  first appears in transformers 5.x (absent in 4.57.6, present in 5.17.0), while
  vLLM 0.18 declares `transformers<5,>=4.56.0`. Since 4.57.6 is the final 4.x
  release — transformers went straight to 5.0.0 — no version inside that
  constraint can parse this checkpoint.

So **vLLM 0.18 ships an architecture whose config it can never parse under its
own dependency constraints.** Structurally this is the same kind of version-window
defect as the cutlass one below; the difference is that the cutlass window
(`>=4.4.0.dev1, <4.6.0`) falls *inside* what vLLM declares, so a pin fixes it,
whereas the transformers window for `glm_moe_dsa` (`>=5`) falls entirely outside.

Wording to use externally: say "0.18 does not support this architecture" only for
`gemma-4-26B`. For `GLM-5.2-NVFP4`, say that 0.18 implements the architecture but
cannot be paired with a transformers able to parse the checkpoint.

One assumption here is inferred rather than measured: that vLLM 0.18 cannot run
against transformers 5.x at all. That rests on the declared `<5` bound, not on an
experiment. Force-installing transformers 5.x into the 0.18 venv and retrying
`GLM-5.2-NVFP4` would settle it in minutes. Prior is that it breaks — transformers
5.17 already broke vLLM 0.26's `config.head_dim` access (the gemma-4 failure
below), and 0.18 is older.

### Why group C looked like a silent crash

All four models stopped on the same line during the sweep,

```
Encoder cache will be initialized with a budget of 16384 tokens
```

then exited rc=1 with no traceback. The crash was not actually silent: the error
is raised inside the EngineCore subprocess, and **the sweep deliberately runs
without DEBUG logging** (`compare_vllm_versions_datafast.sh:61`). DEBUG output
corrupts the stdout of the `cpuinfo` subprocess that vLLM's usage-reporting
thread json-parses; the resulting thread exception prints a traceback into the
worker log, and `ray_runner._is_fatal_worker_line()` treats that as a crash and
kills a healthy worker — which is how one attempt at this sweep lost the entire
0.18 leg.

Re-running outside the harness with DEBUG on, `diag_silent4_018.sh` surfaced the
traceback immediately:

```
AttributeError: module 'cutlass.cute.core' has no attribute 'ThrMma'
RuntimeError: Engine core initialization failed
```

Word for word the group B error.

### The cutlass chain, end to end

1. vLLM 0.18 bundles its own CuTe flash-attention wrapper,
   `vllm/vllm_flash_attn/cute/utils.py`, whose line 115 carries the module-level
   annotation `thr_mma: cute.core.ThrMma` — **evaluated at import time**.
2. `nvidia-cutlass-dsl` moved `ThrMma` out of `cute.core` into `cute.atom` in
   **4.6.0** (still exported as `cutlass.cute.ThrMma`). Measured directly:
   4.3.4 / 4.4.0 / 4.5.3 have it under `cute.core`; 4.6.0 / 4.7.1 / 4.8.0 do not.
3. vLLM 0.18 requires `nvidia-cutlass-dsl>=4.4.0.dev1` and flashinfer 0.6.6
   requires `>=4.3.4` — **neither declares an upper bound**, so uv resolves 4.8.0.
4. A fresh 0.18 install therefore cannot import its own flash-attention wrapper.
   The working window is `>=4.4.0.dev1, <4.6.0`, and 4.5.3 is the newest in it.

**This is directly reportable upstream: vLLM 0.18.0's dependency metadata admits
a range of `nvidia-cutlass-dsl` in which vLLM 0.18.0 cannot work.**

The `diag_silent4_018.sh` control is single-variable — four falsification arms
all fail, and only changing the cutlass version makes all four models pass (full
output in `diag_silent4_summary.txt`):

| arm | whisper | Qwen2-VL | Qwen3-VL-8B | Omni |
| --- | --- | --- | --- | --- |
| baseline (cutlass 4.8.0) | rc=1 | rc=1 | rc=1 | rc=1 |
| `--enforce-eager` | rc=1 | rc=1 | rc=1 | rc=1 |
| `VLLM_ATTENTION_BACKEND=TRITON_ATTN` | rc=1 | rc=1 | rc=1 | rc=1 |
| `--gpu-memory-utilization 0.5` | rc=1 | rc=1 | rc=1 | rc=1 |
| **cutlass-dsl 4.5.3** | **rc=0** | **rc=0** | **rc=0** | **rc=0** |
| 0.26 control | rc=0 | rc=0 | rc=0 | rc=0 |

### gemma-4 on the 0.26 leg: transformers' fault, not vLLM's

```
AmbiguousGlobalPerLayerAttributeError: 'head_dim' is a per-layer attribute and
may vary across layers. Access it via the individual layer configs instead
```

transformers 5.17.0 tightened per-layer attribute access, while vLLM 0.26's
`model_arch_config_convertor.py:597` still reads `config.head_dim` directly.
Pinning `transformers==5.14.1` — the version `pyproject.toml` declares and the one
validated against 0.26 — makes it run, at 10,528 tok/s mixed. **Do not write this
up as "0.26 does not support gemma-4".**

## Is the 0.26 regression on Qwen3-VL-235B-FP8 real?

Yes, and the cause is still unknown. This is the only non-monotonic result in the
table, so it was the first thing re-measured.

### Three repeats per leg: it holds

`scenarios_repeat235b.yaml` with `REPS=3`, both legs, repetition as the outer
loop so slow drift cannot line up with the version axis. Archived under
`results/vllm-*-vllm-only-rep235-r[123]`.

| workload | 0.18 (3 reps) | median | 0.26 (3 reps) | median | 26/18 |
| --- | --- | --- | --- | --- | --- |
| text-only | 4,503 / 4,512 / 4,482 | 4,503 | 3,947 / 3,956 / 3,953 | 3,953 | 0.88x |
| image | 7,030 / 6,985 / 6,948 | 6,985 | 4,862 / 4,919 / 5,049 | 4,919 | **0.70x** |
| video | 1,406 / 1,460 / 1,410 | 1,410 | 1,422 / 1,450 / 1,478 | 1,450 | 1.03x |

Repeat spread is under 1.5% on both legs while the image gap is 42%, so this is
signal, not noise. Both medians also land within ~1% of the single-pass values in
the main table (0.18 image 6,985 vs 7,004; 0.26 image 4,919 vs 4,896), which is
why the table was left as it is.

### The MoE kernel is not the explanation

Both legs log the *same* nominal MoE backend (`FLASHINFER_TRTLLM Fp8`), but 0.26
routes it differently:

| | prepare/finalize | SM split |
| --- | --- | --- |
| 0.18 | `MoEPrepareAndFinalizeNoDPEPModular` | none |
| 0.26 | `MoEPrepareAndFinalizeNoDPEPMonolithic` | `140 SMs used for MoE, 8 reserved` |

That looked like the answer, so `--moe-backend` was added to `bench_vllm.py` (it
is part of the phase fingerprint, so `--resume` cannot reuse a run measured under
a different backend) and the alternatives were forced. Results in
`moe_backend_235b/summary.txt`:

| arm | image tok/s | prepare/finalize | SM split |
| --- | --- | --- | --- |
| 0.18 auto | **7,457** | Modular | none |
| 0.26 auto (resolves to trtllm) | 5,536 | Monolithic | 140 SMs |
| 0.26 `flashinfer_trtllm` | 5,614 | Monolithic | 140 SMs |
| 0.26 `triton` | 5,782 | Modular | none |
| 0.26 `flashinfer_cutlass` | refused | — | — |
| 0.26 `cutlass` | refused | — | — |

`flashinfer_cutlass` and `cutlass` refuse this model legitimately —
`does not support quantization scheme QuantKey(f8e4m3fn...)` — not a bug. The
same arm was also run on 0.18 (`018_flashinfer_cutlass`, rc=1) and refuses for
the same reason; it is in `moe_backend_235b/summary.txt` but carries no number,
so it is not in the table above.

**The decisive negative result is `triton`.** It restores exactly the structure
0.18 has (Modular prepare/finalize, no SM reservation) and still only reaches
5,782, nowhere near 7,457. So the Monolithic prepare/finalize and the SM
reservation are *not sufficient* to explain the gap. This is not airtight —
triton is a slower kernel in its own right, so the arm changes two things at once
— but no MoE backend available on 0.26 recovers 0.18's throughput.

### Ruled out so far

- **Work done**: identical. Same `num_seqs` (1000), same `vllm_output_tokens`
  (417,061 text-only / 512,000 image and video), same `output_len`, `tp`, `seed`.
  Only elapsed differs.
- **Attention backend**: both legs pick `FLASH_ATTN` for `MMEncoderAttention`.
- **Scheduling**: both have chunked prefill on with
  `max_num_batched_tokens=16384`.
- **KV cache and concurrency**: 2,173,456 tokens / 128.64x on 0.26 and
  2,192,112 / 129.74x on 0.18 — a 0.9% difference, not 42%.
- **MoE backend selection**: see above.
- **FlashInfer autotuning landing inside the timed region on one leg only**: it
  runs fresh on every launch and is paid equally by both. Each arm tunes the full
  22 `flashinfer::trtllm_fp8_block_scale_moe` configurations (~7–8s), and nothing
  persists between runs — `~/.cache/flashinfer/{0.6.6,0.6.14}` was last written
  hours before these runs and was not touched during them. So it is a constant
  overhead on every measurement, not a version-dependent one.

### The remaining lead

The regression tracks how decode-bound the workload is: image (decode-heavy)
0.70x, text-only (pure decode) 0.88x, video (prefill- and encoder-heavy, ~1,400
tok/s) 1.03x. That points at 0.26's decode path for this model rather than at the
vision encoder. Settling it needs a kernel-level profile of the image workload on
both legs; that has not been done.

## Runtime stack per leg

A "vLLM version comparison" is really a comparison of three whole runtime stacks,
so this table has to travel with the numbers.

| leg | vllm | torch | CUDA | transformers | nvidia-cutlass-dsl |
| --- | --- | --- | --- | --- | --- |
| 0.18 | 0.18.0 | 2.10.0+cu128 | 12.8 | 4.57.6 | 4.8.0 → **4.5.3** (6 models) |
| 0.26 | 0.26.0 | 2.11.0+cu130 | 13.0 | 5.17.0 → **5.14.1** (gemma-4) | 4.6.0 |
| 0.29 | 0.29.0 | 2.13.0+cu130 | 13.0 | 5.17.0 | not recorded |

### Why the pins did not contaminate the existing numbers

The 0.18 leg spans two cutlass configurations: 7 models measured under 4.8.0 and
6 under 4.5.3. **This does not affect the comparability of the first 7**, and the
argument is deterministic: they already passed under 4.8.0, which proves they
never reach the `vllm_flash_attn/cute` code path — reaching it fails at import —
so the cutlass version cannot have changed their measurements. Likewise
`transformers==5.14.1` was used only for gemma-4; the other 14 numbers on the
0.26 leg were still measured under 5.17.0.

The stricter alternative is to re-measure each leg whole under one pinned set, at
a cost of several GPU hours. The argument above holds, so that was not done.
**The inconsistency still has to be disclosed** — do not report a single cutlass
or transformers version per leg.

## Known limitations

1. **Almost no dispersion, and this is the biggest gap.** Throughput is one timed
   pass per scenario for 14 of the 15 models; `REPS=3` has only been run for
   `Qwen3-VL-235B-FP8`. We cannot currently answer "is the difference between
   22,263 and 21,943 real?", so every conclusion in the 0.99–1.05x band should be
   read as "no difference detected", not "no difference". This most affects the
   "flat across all three" claims for `Qwen3-VL-8B` and `whisper`. The one model
   that *was* repeated came back with under 1.5% spread, which is encouraging for
   the rest but does not substitute for measuring them. Note that
   `scenarios_repeat7.yaml` is now stale: 13 models are three-way comparable, not
   7, so repeated measurement needs either a 13-model table or an explicit
   statement that dispersion covers only some of them.
2. **Image and video throughput depends on the CPU allocation the harness hands
   the job, so these absolute numbers are not portable.** With
   `mm_processor_cache_gb=0` the multimodal preprocessing is re-run inside the
   timed region, which makes those workloads partly CPU-bound. Under the Ray
   harness a tp=4 job gets `OMP_NUM_THREADS=21` (`ray_runner.py:499`,
   `per_rank = num_cpus // tp`, with `num_cpus` allocated tp-proportionally out of
   192 cores). Running the same benchmark directly, without Ray, leaves the
   variable unset and each rank takes all 192 cores — which moved
   `Qwen3-VL-235B-FP8` image by 6–12% (0.26: 105.3s → 92.5s; 0.18: 72.8s → 68.7s)
   while leaving text-only unchanged, exactly as a CPU-bound preprocessing step
   would. **Version-to-version comparisons in this report are unaffected**, since
   every leg ran through the same harness at the same tp, but do not compare these
   image/video figures against numbers produced by a different runner.
   Counter-intuitively the direct runs are also much noisier (17% between two
   identically configured arms, against ~1% in the harness), most likely because
   4 ranks × 192 threads oversubscribes 192 cores; the Ray-imposed 21 threads is
   the better-behaved configuration.
3. **Whisper audio is clamped to 30s.** LibriSpeech test.clean does contain
   samples longer than that (longest ≈30.61s). The clamp works around the vLLM
   0.29 whisper bug, and Whisper's encoder is defined on a fixed 30s window
   anyway, so it does not change the semantics of the workload — but it must be
   stated explicitly.
4. **B200 only, and most conclusions do not generalise.** Do not put these
   absolute numbers in the same table as Hopper results; reasoning in
   `MANIFEST.md`. Beyond that, the H200 companion run shows that the two
   headline speedup stories above are Blackwell-specific — see the note at the
   top of "Headline findings". The `0.18` failure set is also Blackwell-specific:
   on Hopper 0.18 reaches 13/14 with no dependency pins at all.
5. **Two dependency pins leave two legs internally non-homogeneous.** See "Why the
   pins did not contaminate the existing numbers". The argument holds but must be
   disclosed.
6. **`gemma-4` has two-way data only** (pinned 0.26 plus 0.29); 0.18 cannot load
   it, so it carries no three-way comparison. Its long-context figure of
   117 tok/s is the lowest in the table, but it is the largest model running at
   tp1 (26B), and being 2.5x slower than `Llama-3.1-8B` at tp1 (300) for the same
   amount of work is reasonable, not an outlier.

## Three defects found along the way (independent of the performance numbers)

- **vLLM 0.18.0's dependency metadata admits an `nvidia-cutlass-dsl` range in
  which it cannot work.** 0.18 declares `>=4.4.0.dev1` with no upper bound, but its
  own `vllm_flash_attn/cute/utils.py:115` evaluates `cute.core.ThrMma` at import,
  and that symbol left `cute.core` in cutlass-dsl 4.6.0. The real window is
  `>=4.4.0.dev1, <4.6.0`. Consequence: a fresh 0.18 install today resolves 4.8.0
  and six models (`Kimi-Linear-48B`, `Qwen3-VL-235B-FP8`, `whisper-large-v3`,
  `Qwen2-VL-7B`, `Qwen3-VL-8B`, `Qwen2.5-Omni-7B`) all die during engine
  initialization. Pinning 4.5.3 makes all six pass — the single-variable table in
  `diag_silent4_018.sh` is ready-made evidence.
  **The blast radius is Blackwell only, and a bug report should say so.** On
  H200 the same 0.18 venv resolves the same broken 4.8.0, and all six models
  pass unpinned: Hopper selects `FLASH_ATTN`/FA3, so the CuTe wrapper carrying
  the bad symbol is never imported. The metadata defect is real either way, but
  it is only reachable on SM100.
- **A whisper bug in vLLM 0.29.** For one ≈30.61s librispeech clip, 0.29 does not
  truncate to Whisper's standard 3000 frames and produces 3,061 mel frames; its own
  multimodal batching code then refuses to stack 3,061 with 3,000:
  `input_features contains inconsistent shapes`. Our harness hands vLLM **raw
  audio** and lets vLLM do its own feature extraction; running the same
  `WhisperProcessor` over the whole split independently yields `(128, 3000)` for
  all 2,620 samples. The input is entirely valid, and 0.26 passes in the same
  isolated venv. **Ready to file upstream.**
- **An `IpcSocket` defect in our own `bench_vllm.py` (worth upstreaming as a PR).**
  Before the fix, every tp>1 job on 0.29 died within 18–37 seconds on
  `AttributeError: module 'flashinfer.comm.mnnvl' has no attribute 'IpcSocket'`.
  After it, `Mixtral` (tp2), `gpt-oss-120b` (tp2), `Qwen3-Next-80B` (tp2),
  `Kimi-Linear-48B` (tp2), `Qwen3-VL-235B-FP8` (tp4) and `GLM-5.2-NVFP4` (tp8) all
  pass. This round's data is the before/after evidence.

## Where the numbers come from

The tables are generated from `results/` by `make_tables.py`, not transcribed, so
they cannot drift away from the data:

```bash
python3 make_tables.py   # run from the directory containing results/
```

`make_tables.py` reads exactly one run directory per (leg, model) — the canonical
measurement. Which directory that is, and why, is listed model by model in
`CANONICAL.md`. The repeat and MoE-backend runs that also live under `results/`
are deliberately *not* folded into these tables; they are supporting evidence for
the two diagnostic sections above.