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.
- 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.
- 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. - 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.