Raphael Friedmann
← Das Log

Wie imp Qwen3.8-Flash-Next auf einer 32-GB-Karte betreibt

56 GiB Experten, 32 GB VRAM: alle Experten auf dem Host, ein von der GPU verwalteter Cache im VRAM und Decode von 5,8 auf 75-80 Tokens pro Sekunde auf echtem Text.

imp ist eine Inference-Engine in C++23 und CUDA, gebaut für genau einen Chip: NVIDIA Blackwell sm_120a, die RTX 5090 mit 32 GB GDDR7. Keine Portabilitätsschicht, kein FP16-Fallback im heißen Pfad. Dieser Post beschreibt, wie imp ein Modell betreibt, das auf dem Papier nicht auf diese Karte passt: Qwen3.8-Flash-Next, im Checkpoint als Architektur qwen4_exp geführt, ein Mixture-of-Experts-Modell mit 512 Experten.

Der Stand: Auf echtem Text dekodiert imp dieses Modell mit 75 bis 80 Tokens pro Sekunde, wobei jeder Experte im Host-RAM liegt. Der Ausgangspunkt war 5,8.

Anatomie des Modells#

NVIDIAs NVFP4-Checkpoint belegt 123 GiB auf der Platte. Laut den Portierungsnotizen verteilen sich die Parameter auf 125 Milliarden im Hauptmodell, 51 Milliarden in einer N-Gramm-Tabelle und 4 Milliarden im MTP-Head. Etwa 6 Milliarden sind pro Token aktiv.

config.json beschreibt einen Hybrid:

Eigenschaft Wert
Layer 48
davon Gated DeltaNet (linear_attention) 36
davon volle Attention (full_attention) 12, jeder vierte Layer
Experten pro MoE-Layer 512, 10 pro Token aktiv, plus 1 Shared Expert
Intermediate Size der Experten 640
Hidden Size 2560
Attention: Q-Heads / KV-Heads / Head Dim 24 / 2 / 256
Vokabular 248320
Maximaler Kontext 262144
Residual-Streams (hc_count) 4

Die Gated-DeltaNet-Layer sind für imp bekanntes Terrain. Drei andere Eigenschaften nicht.

Gated Residual statt eines einfachen Residuals. Der Residual-Stream ist vierfach breit, [T, 4*2560], initialisiert als das viermal wiederholte Embedding. Vor jedem Block mischt ein kleines Netz (Low-Rank-Dimension 320) die vier Streams über Sigmoid-Gewichte zu einer Eingabe; danach wird die Blockausgabe mit je eigenem Gewicht in jeden Stream eingespeist. Das Modell hat keine input_layernorm und keine finale Norm: Die Pre-Norm lebt im Gated Residual, und am Ende speist der Mixer direkt den LM-Head. imp ist daran zweimal abgestürzt, weil rmsnorm() ein Null-Gewicht bekam. Der Fix: Ein Null-Gewicht bedeutet jetzt Identität, zentral in rmsnorm() behandelt.

Die PLE-N-Gramm-Tabelle. Layer 1 trägt einen zusätzlichen Embedding-Block. Ein Hash über die letzten Tokens ergibt eine Menge von N-Gramm-IDs: 16 Heads, 8 für Bigramme und 8 für Trigramme. Jede ID indiziert eine Zeile in einer riesigen FP8-Tabelle. Das Server-Log:

ngram table: layer 1, 128 shards, 320001536 rows x 160, 16 heads x ngram 3,
scale 0.00019932, eos 248044, 47.7 GiB host-mapped (page cache, not resident)

Die 16 Lookups erzeugen einen Key und einen Value, ein Gate gegen den aktuellen Residual-Stream und eine kausale dilatierte Depthwise-Convolution (Kernel 4, Dilation 3). Das ist keine Dekoration: Eine Ablation ohne PLE brachte die Prosa-Perplexity von 14,3 auf 24,8. Die Tabelle trägt ungefähr die Hälfte der Qualität.

Mehr als 256 Experten. Klingt nach einer Zahl unter vielen. Sie hat einen Bug offengelegt, siehe unten.

Warum die Experten nicht passen#

Nur die Experten sind NVFP4; alles andere ist BF16. Das Lade-Log:

NVFP4 experts (56.25 GiB) do not fit the 13.68 GiB budget: all 48 MoE layer(s)
stay host-resident so the expert cache gets the VRAM (a partial upload starves it).

56 GiB Experten gegen eine 32-GB-Karte. Der naheliegende Zug wäre, so viele Experten-Layer in den VRAM zu laden, wie passen, und den Rest vom Host zu holen. imp macht absichtlich das Gegenteil. Ein residenter Experten-Layer bringt 100 % Trefferrate auf 1/48 der Arbeit und kostet 1,17 GiB. Derselbe VRAM als Cache ergibt etwa 28 Slots pro Layer auf allen 48 Layern. Teilweise Residenz verliert, solange der Cache den Rest bedienen muss. Regel: Wenn nicht alles passt, bleibt alles auf dem Host.

Host-Experten, Device-Cache, Zero-Copy#

Der Experten-Pfad hat drei Ebenen.

  1. Gepinnte Slabs im Host-RAM. Die Experten einer Projektion liegen hintereinander in einem gepinnten Block, der in den Adressraum der GPU gemappt ist. Ein Experte sind zwei Bytebereiche: gepackte FP4-Gewichte und FP8-Mikro-Skalierungsfaktoren.
  2. Ein LRU-Cache im VRAM. Eine feste Zahl von 0,88-MiB-Slots pro MoE-Layer. Im hier gezeigten Lauf: 48 layers × 221 slots × 0.88 MiB = 9323.48 MiB.
  3. Ein vollständig auf der GPU verwalteter Cache (src/exec/expert_cache_device.{h,cu}). Ein Resolve-Kernel liest die geroutete Expertenauswahl, schlägt sie in LRU-Tabellen auf der GPU nach, wählt Opfer für die Misses und schreibt die Slot-Indizes. Ein Gather-Kernel kopiert die fehlenden Experten zero-copy direkt aus gemapptem Host-Speicher über PCIe, gemessen mit 51 GB/s. Kein Umweg über den Host, kein Sync pro Layer.

Dieser letzte Punkt ist die Voraussetzung für alles Weitere. Der ältere Host-LRU-Pfad musste die Routing-Entscheidung jedes Layers auf den Host kopieren, dort die Buchführung erledigen und dann die Kopien starten. Im direkten Vergleich schafft er 30,3 Tokens pro Sekunde; der Device-Cache schafft 74,5 bis 79,6.

Eine Feinheit steckt in den Skalierungsfaktoren: Die Kernels lesen den Per-Tensor-Skalierungsfaktor mit demselben Index wie das Gewicht. Dieser Index ist jetzt ein Slot, keine Expertennummer, also hält der Cache einen Spiegel der Skalierungsfaktoren pro Slot, der aktualisiert wird, sobald ein Slot den Besitzer wechselt.

Wie groß der Cache werden darf, ist eine Frage der Messung. Sweep auf echtem Text (5 Prosa-Prompts, je 200 Tokens, Median):

Anteil am freien VRAM Slots/Layer VRAM danach frei Decode
45 % 186 4995 MiB 74,1 / 76,5 tok/s
55 % 227 3242 MiB 77,5 / 77,2 tok/s
62 % 256 2170 MiB hängt

Bei 62 % ist der Server nicht langsam, er hängt: Der GDN-State für eine Sequenz lässt sich nicht mehr committen, Requests werden angenommen und nie beantwortet. Der Default für host-residente NVFP4-Experten ist deshalb 55 %. Der Hänger liefert jetzt HTTP 503 statt Stille.

Die Obergrenze zeigt sich auch von der anderen Seite: In einem früheren Lauf hob 60 % statt 45 % die Trefferrate von 98,8 auf 99,2 %, aber Decode fiel von 102,42 auf 78,26 Tokens pro Sekunde. Die Allokation gelang, die Bytes liefen über. Unter WSL2 beweist ein erfolgreiches cudaMalloc nicht, dass der Speicher wirklich auf der Karte liegt.

Zwei naheliegende Optimierungen wurden gemessen und verworfen:

  • Klügere Eviction. Ein Simulator spielt Routing-Traces ab und reproduziert die gemessene Trefferrate von 62,7 % bei 186 Slots. Heiße Experten festzupinnen verliert bei jedem Budget gegen LRU, 59,4 gegenüber 62,0 %. Das Routing ist zu flach: Layer 0 berührt in 300 Tokens 384 von 512 Experten, und die Top 64 tragen 41 %.
  • Misses auf der CPU rechnen. Auf dem Ryzen 9800X3D liest der Host verstreute 0,88-MiB-Blöcke mit 58 bis 60 GB/s; PCIe schafft 52. Das sind 13 % Luft, nicht 2x.

Decode: von 5,8 auf 75-80 Tokens pro Sekunde#

Die Beschleunigung kam in Schritten, jeder mit einer benannten Ursache. Gemessen mit 96 erzeugten Tokens auf demselben Prompt; der Ausgabetext war über alle Schritte hinweg Byte für Byte identisch:

Schritt tg96 tok/s Was sich geändert hat
Baseline (mmap, 15 % Budget) 5,81 3 cudaMemcpyAsync pro Miss; ein 4-Byte-Skalierungsfaktor vom Stack synchronisiert den Stream
Gepinnte Host-Experten 8,10 DMA-fähige Quelle
Skalierungsfaktor und Index als Kernel-Parameter 14,35 kein Sync pro Miss
N-Gramm-Speculation aus, 45 % Budget 20,6 186 Slots/Layer, 71 % Treffer
cudaMemcpyBatchAsync pro Layer 27,2 31 bis 56 µs Host-Zeit pro Einzelkopie entfallen
Device-Cache 33,2 Resolve und Gather auf der GPU, kein D2H pro Layer
Graph Replay 53,0 etwa 2600 Kernel-Starts pro Token waren die Host-Untergrenze

Graph Replay hatte ein Hindernis: Der PLE-Block braucht pro Token einen Host-Schritt (Hash berechnen, Zeilen aus der gemappten Tabelle einsammeln). Dieser Schritt läuft jetzt vor jedem Replay in prepare_decode_step_host, außerhalb des Graphen.

Mit dem Cache-Budget von 55 % und automatischer Konfiguration landete Decode bei 74,5 bis 79,6 Tokens pro Sekunde auf echtem Text.

Wohin die Zeit geht, aus dem Profil eines Decode-Schritts von 16,6 ms: 7,2 ms in expert_cache_gather (PCIe-Misses), 3,1 ms in GEMV-Kernels, 1,1 ms im Resolve-Kernel. Im Resolve-Kernel durchsuchte ursprünglich Thread 0 für jeden Miss seriell 256 Kandidaten. Eine Baumreduktion mit 8 Schritten brachte ihn bei identischer Trefferrate von 1147,0 auf 888,7 µs pro Token.

Die Misses können sich nicht hinter Rechenarbeit verstecken. Der Forward Pass ist strikt sequenziell: Attention oder GDN, dann Gated Residual, dann MoE. Das Routing kennt seine Experten erst nach der Attention, und Vorhersage über Layer hinweg scheitert, weil die Misses genau die unvorhersehbaren sind.

Prefill: CUTLASS in Expertenblöcken#

Beim Prefill sind viele Experten zugleich aktiv, und ein Cache hilft wenig. imp kopiert die Experten eines Layers in einen Staging-Buffer und lässt sie durch ein Grouped CUTLASS GEMM auf den FP4-Tensor-Cores laufen. Drei Schritte haben das schnell gemacht.

Staging für 512 Experten. Die Hilfs-Kernels des Grouped GEMM waren für weniger Experten ausgelegt und mussten geändert werden (Multi-Block-Scan, Limit 4096). Danach ging ein Prompt mit 1353 Tokens von 4,11 auf 1,96 s.

Nur die getroffenen Experten kopieren. Der erste Staging-Pfad kopierte alle 512 Experten mit allen drei Projektionen pro Layer, 63 GB pro Prefill. Dadurch war die Zeit bis zum ersten Token fast unabhängig von der Prompt-Länge. Jetzt liest ein Gather-Kernel die Routing-Offsets und holt nur Experten, die Tokens bekommen haben:

Prompt-Tokens TTFT vorher TTFT nachher
67 1267 ms 499 ms
328 1287 ms 811 ms
1022 1328 ms 1038 ms

Das Routing ist schief: Bei 67 Tokens sinkt die Kopie auf 39 %, nicht auf die 73 %, die eine Gleichverteilung vorhersagt.

Block-Staging. Ein Staging-Buffer für einen ganzen Layer nimmt dem Experten-Cache Slots weg. Der aktuelle Pfad staged Gate und Up in Blöcken, lässt die GEMMs laufen und staged dann Down in Blöcken. Im Log: MoE layer staging buffer: 225.00 MiB (128 experts x 2 projection slots, 4 expert block(s) per layer). Ein Konfigurationsbug hatte diesen Pfad eine Zeit lang abgeschaltet, sodass ein 13,9k-Prompt als 837k Einzelkopien aus nicht gepinntem Speicher lief. Gemessen nach dem Fix auf einem Prompt mit 3692 Tokens:

Variante Staging-Buffer Slots/Layer Prefill tok/s Decode tg512
vorher (Legacy-Pfad) - 227 202,67 / 196,39 60,09 / 58,23
1 Block 1350 MiB 191 1108 / 1084 54,58 / 55,06
4 Blöcke 225 MiB 221 1143 / 1131 / 1054 59,80 / 55,81 / 57,43

Mit vier Blöcken bleibt der Cache fast so groß wie vorher, und Prefill ist mehr als fünfmal so schnell. Die Release Notes von v0.45.0 nennen das „Qwen3.8-Flash-Next prefill 5.6x“.

Bugs unterwegs#

Experten ab 256 wurden nie gewählt. Nach der Portierung erzeugte imp kohärenten Text, aber die Perplexity auf einem selbst geschriebenen, ungesehenen Prosatext lag bei 14,25; llama.cpp kam auf 5,54, beide über llama-perplexity auf demselben Fenster. Dumps pro Layer zeigten: Die Router-Logits stimmen überein, die Auswahl nicht. topk_gating_kernel gab jedem seiner 256 Threads genau einen Experten, Experten mit Index 256 und höher waren also nie Kandidaten. Kein früheres Modell hatte mehr als 256 Experten. Nach dem Fix, der jedem Thread mehrere Slots gibt: 6,00 gegenüber 5,54 für llama.cpp und 1,422 gegenüber 1,4238 auf einem Gutenberg-Auszug. Ein Regressionstest deckt das jetzt ab. Das Modell war vorher nicht sichtbar kaputt; erst der Vergleich mit einer unabhängigen Referenz zeigte den Bug.

Der QSA-Indexer ist per Default aus. Die zwölf Attention-Layer bringen einen gelernten Block-Top-k-Indexer mit (Budget 2048, Kompression 4). Unter 2051 Tokens Kontext ist seine Maske komplett wahr, und die Attention ist exakt dicht. imp hat ihn implementiert und den Default dann auf aus gesetzt. Die erste Begründung, eine Rundungsdifferenz kippe das MoE-Routing, überstand das Review nicht: Kein Test in der Suite erreichte 2051 Tokens, der Indexer war also nie aktiv gewesen. Die Messung, ein Server pro Variante:

Probe QSA aus QSA an
Needle bei 11283 Tokens gefunden gefunden
1024-Token-Decode bei 11283 Kontext 18,14 tok/s 15,88 tok/s (-12,5 %)
Degenerations-Suite 50/50 47 bis 48/50

Der strukturelle Grund: Nur 12 von 48 Layern haben Attention, je 2 KiB KV pro Token, also 24 KiB pro Token. Bei 12k Kontext sind das 288 MB, rechnerisch (nicht gemessen) etwa 0,19 ms Lesezeit gegenüber einem Decode-Schritt von 63 ms, der den Host-Experten gehört. QSA hat fast nichts zu sparen, fügt aber pro Layer ein Index-GEMM, Selektion, Gather und einen zweiten Attention-Kernel hinzu. Der Selektions-Kernel läuft mit einem Thread-Block pro Query-Zeile und wird mit wachsendem Kontext teurer. Zwei echte Defekte im QSA-Pfad wurden unterwegs gefunden und behoben; der Default bleibt aus.

Auto-Defaults, die den Start blockierten. Mit Default-Einstellungen startete das Modell zunächst gar nicht: the slot path needs at least 30 slots per layer and has 0. Vier Defaults blockierten sich gegenseitig:

Defekt Wirkung
Experten-Layer gierig in den VRAM geladen 13 von 48 im VRAM, Cache mit 0 Slots
Cache-Budget pauschal 15 % 3- bis 4-mal zu klein für host-residentes NVFP4
Auto-max_seq_len ignorierte den Experten-Cache KV-Cache fraß dessen VRAM
Pinning an einen einzigen Schalter gebunden keine Device-Sicht, Host-LRU-Pfad, keine Graphen

Auch die Gewichtsschätzung hatte einen Bug: Sie zählte jeden Experten, als läge er im VRAM. Das ergab 78,5 GB statt 3,5 GB und deckelte den automatischen Kontext bei 4096 Tokens. Nach dem Fix wählt imp 131072. Aktuelles Log:

max_seq_len: auto → 131072 (model=262144, vram_cap=221810, auto_cap=131072,
kv=24576 B/tok, attn_layers=12/48)

Dazu ein Container-Problem: In einem Container zeigt /proc/meminfo die Zahl des Hosts. Ein Container mit --memory=8g auf dem 78-GB-Host las 76 GB frei. imp nimmt jetzt das Minimum aus MemAvailable und dem Cgroup-Spielraum, abzüglich Page Cache.

Abgeschnittene Tool Calls. Bei N-Gramm-Speculation übernimmt der Verify-Schritt einen Snapshot des GDN-States, wenn null Tokens akzeptiert werden. Die Default-Scan-Kernels haben diesen Snapshot nie geschrieben, also wurde uninitialisierter Speicher übernommen. In 3 von 8 frischen Server-Prozessen endeten Tool Calls mitten im Argument. Nach dem Fix: 0 von 12.

Batch-Größe 1#

Die Auto-Konfiguration würde für dieses Modell 32 parallele Sequenzen wählen. imp setzt sie auf 1, und das Log sagt, warum:

max_batch_size 32 -> 1: this model's PLE block holds one n-gram context, so batched
decode would answer every sequence from the first one's context.

Der PLE-Block hält die letzten zwei Tokens und neun Zeilen Convolution-State für genau eine Sequenz. Vor diesem Fix loggte der Code „output is wrong“ und rechnete trotzdem weiter. Acht parallele Streams brachten den Server zuverlässig zum Absturz. Parallele Requests werden jetzt nacheinander bedient, jeder Decode-Schritt für eine Sequenz. Das schließt Continuous Batching für dieses Modell vorerst aus.

Wie der Speicher am Ende aussieht#

Aus dem Server-Log eines aktuellen Laufs:

Posten Größe
Experten-Cache im VRAM 9323,5 MiB (221 Slots/Layer)
Device-Cache-Tabellen 2,1 MiB
Prefill-Staging-Buffer 225 MiB
KV-Cache beim Start 1750 Blöcke, 28000 Tokens, 656,25 MiB, wächst bis 131072 Tokens
Experten im Host-RAM 57600 MiB
N-Gramm-Tabelle 47,7 GiB gemappt, Page Cache, nicht resident
GPU gesamt 29128 von 32579 MiB belegt

Die PLE-Tabelle ist mit MADV_RANDOM gemappt und wird nie vollständig gelesen. Über 1300 Decode-Tokens kamen 25 MiB von der NVMe; im Decode kostet sie praktisch nichts. RAM ist die enge Stelle: 56 GiB gepinnte Experten plus PLE lassen auf einem 78-GB-Host nach dem Laden 9 bis 16 GB frei. Wenn der RAM zum Pinnen nicht reicht, lässt imp das Pinnen aus, statt den Prozess zu riskieren. Der Preis ist hoch: Mit einem Container-Limit von 40 GB fällt Decode auf 4,3 Tokens pro Sekunde.

Ehrliche Grenzen#

  • Eine Sequenz auf einmal. Solange der PLE-Kontext nicht pro Sequenz gehalten wird, gibt es kein gebatchtes Decode. Ein Mehrbenutzer-Server hat den Durchsatz eines einzelnen Streams.
  • Die Trefferrate hängt vom Text ab. Der Benchmark-Modus erzeugt repetitiven Text und trifft zu 98,8 % im Cache; echter Text trifft zu 62,7 %. Ein Request mit 120 Tokens lief mit 54 Tokens pro Sekunde, derselbe Build im Benchmark mit 102. Benchmark-Zahlen überzeichnen das echte Tempo dieses Modells deutlich.
  • PCIe ist die Untergrenze. Fast die Hälfte eines Decode-Schritts ist Gather über PCIe. Weder bessere Eviction noch CPU-Rechnen versprechen mehr als ein paar Prozent.
  • Das Cache-Budget hat eine harte Obergrenze. Mehr Slots nehmen dem GDN-State den Platz. 55 % sind gemessen, nicht hergeleitet.
  • Nicht erledigt: Der MTP-Head (1 Layer, im FP8-Shard) läuft nicht. Auch Prefix-Cache-Resumes für den PLE-Kontext fehlen.
  • QSA bringt auf diesem Modell nichts. Gemessen bis 23k Kontext; 131k ist ungetestet.

Der Kern des Ansatzes ist unspektakulär: alle Experten auf dem Host, VRAM für einen Cache, der ohne den Host auskommt, und jeder Schritt gegen echten Text geprüft statt gegen den Benchmark.