# 30B-Modelle mit 300 tok/s auf einer einzelnen RTX 5090 betreiben
> Warum keine bestehende Inference-Engine Consumer-Blackwell voll ausnutzt, was NVFP4 ändert, und die Zahlen aus dem Bau einer Engine, die es tut.
Source: https://rfriedmann.de/de/blog/serving-30b-models-rtx-5090/ · English: https://rfriedmann.de/blog/serving-30b-models-rtx-5090/
Published: 2026-06-02 · Track: log · Level: Advanced
Eine einzelne RTX 5090 dekodiert 30B-total-MoE-Modelle (~3B aktive Parameter) mit rund
300 Tokens pro Sekunde, Single-Stream, Batch 1.
Nicht im Labor, nicht hochgerechnet, sondern gemessen, auf meinem Schreibtisch,
reproduzierbar bis auf den Commit-SHA. Das Überraschende ist nicht die Zahl. Es ist, dass
keine bestehende Engine auf `sm_120` einen nativen NVFP4-Decode-Pfad hat, und deshalb
keine an imps Single-Stream-FP4-Decode auf dieser Karte herankommt.
Diese Lücke ist der ganze Grund, warum es [imp](https://github.com/kekzl/imp) gibt.
Dieser Post handelt davon, was drinsteckt und warum eine Grafikkarte für 2.000 Dollar den
Großteil ihres eigenen Siliziums abgeschaltet ließ.
## Eine 5090 ist keine kleine Rechenzentrums-GPU
Auf dem Papier sieht die 5090 aus wie eine geschrumpfte B200: dieselbe
Blackwell-Architektur, FP4-Tensor-Cores, 32 GB schneller Speicher. In der Praxis ist der
Consumer-Chip (`sm_120a`) eine andere Maschine, die denselben Familiennamen trägt. Ihm
fehlt der Async-Compute-Pfad, um den die Rechenzentrums-Blackwell-Kernels herum gebaut
sind (tcgen05/TMEM); die Async-Copy-Engine (TMA, cp.async) behält er.
Rechenzentrums-Blackwell - B200 (sm_100)
tcgen05 / TMEM Async MMA
TMA / cp.async Copy-Engine
FP4-Tensor-Cores
Consumer-Blackwell - RTX 5090 (sm_120a)
tcgen05 / TMEM
TMA / cp.async Copy-Engine
FP4-Tensor-Cores
32 GB GDDR7 @ 1,79 TB/s
Diese Diskrepanz spaltet das Ökosystem sauber, und nicht zugunsten der 5090:
- **vLLM** ist für Rechenzentrums-Blackwell gebaut, und dort ist es exzellent. Sein
NVFP4-Pfad setzt `tcgen05` voraus, einen Befehl, den die 5090 nicht hat, also fällt es
auf einer Consumer-Karte auf langsamere Kernels zurück oder lädt diesen Pfad gar nicht
erst. Anderes Ziel, kein Mangel.
- **llama.cpp** läuft absichtlich auf allem, das ist eine echte Stärke und der Grund,
warum es das Rückgrat der lokalen Inferenz ist. Sein Decode ist wirklich gut gebaut
(quantisierte Integer-Kernels, kein FP16-Umweg). Aber universell zu bleiben heißt, dass
es sich nicht auf die Eigenheiten eines einzelnen Chips stützen kann, also bleiben die
nativen FP4-Tensor-Cores der 5090 ungenutzt.
Die eine Consumer-Karte mit nativer FP4-Hardware hatte also keine Engine, die natives FP4
sprach. Diese 30B-MoE-Modelle passen quantisiert bequem in 32 GB, und die
Speicherbandbreite sagt, dass sie mit über 250 tok/s dekodieren *sollten*. Niemand
lieferte das. Also habe ich das Ding gebaut, das es tut.
## Was NVFP4 dir wirklich bringt
NVFP4 ist das native Gewichtsformat für Blackwells FP4-Tensor-Cores: 4-Bit-Gleitkomma mit
einem Skalierungsfaktor pro Block, direkt exportiert aus NVIDIAs Model Optimizer oder
llm-compressor.
Hier ist die eine Tatsache, die es wichtig macht. Die Decode-Geschwindigkeit auf einer
einzelnen GPU ist fast vollständig ein Problem der Speicherbandbreite: Jedes Token, das
du erzeugst, muss die aktiven Gewichte durch den Chip schleppen. Die Bytes pro Gewicht zu
halbieren (FP4 gegenüber FP8) oder zu vierteln (FP4 gegenüber FP16) verschiebt die Decke
um denselben Faktor. Weniger Bytes zu bewegen, mehr Tokens pro Sekunde. Das ist der ganze
Trick.
Der Haken ist der Teil, den dir niemand abnimmt: Für `sm_120` gibt es keine fertigen
FP4-Matrix-Kernels. Wenn du das willst, schreibst du das GEMM selbst, in imps Fall
`mma.sync mxf4nvf4` mit Block-Scaling, aufgebaut auf
CUTLASS, weil die Kernel-Designs von Hopper und B200 auf diesem Chip schlicht nicht laufen
können.
## Die Zahlen
Einzelne RTX 5090, Greedy Decoding, CUDA 13.3, CUDA Graphs an. Jede Zahl hier ist in
[BENCHMARKS.md](https://github.com/kekzl/imp/blob/main/docs/BENCHMARKS.md) datiert und an
einen Commit gebunden, mit dem exakten Befehl zum Reproduzieren.
[diagram omitted — see the page for the chart]
Natives NVFP4-Decode auf Consumer-Blackwell, Single-Stream (Batch 1), greedy, CUDA 13.3. tg256 = 256 erzeugte Tokens bei kurzem Kontext. Gemessen laut BENCHMARKS.md: 2026-06-09, Commit ec9145b3, ein Modell pro Prozess, 10 Wiederholungen. Treiber 610.47, wie von imps Roofline-Läufen am 2026-06-07 und 2026-06-10 geloggt; die Streuung pro Wiederholung wurde nicht erfasst.
Auf diesem Chart gibt es aus einem einfachen Grund keine „vs.“-Spalte: Auf `sm_120` gibt es
nichts zum Vergleichen. vLLMs NVFP4-Pfad braucht `tcgen05`, und llama.cpp hat gar keine
native NVFP4-Unterstützung. Natives NVFP4-Decode auf Consumer-Blackwell ist im Moment ein
Feld mit einem Teilnehmer.
Wo es *doch* einen fairen Vergleich gibt, nämlich bei dense GGUF, dem Heimspiel von
llama.cpp, dekodiert imp beide gemessenen dense Modelle
**37 % bis 72 % schneller als llama.cpp**: Qwen3-8B Q8_0 mit 274,4 tok/s gegenüber 159,7,
Qwen3-14B Q6_K mit 155,4 gegenüber 113,7 (2026-05-29, llama.cpp-Commit `19e92c3`,
CUDA 12.8, Full Offload, Flash Attention an; Treiber nicht geloggt). Der Trick ist ein
kleiner: GGUF-Gewichte werden beim Laden einmal in FP4 konvertiert, der heiße Decode-Pfad
streamt also Sub-Byte-Gewichte, während Prefill die Quelle in voller Präzision behält.
## Wo imp verliert
Benchmarks, die nur Siege zeigen, sind Werbung. Hier ist also die ehrliche Liste, die
erfreulicherweise kürzer geworden ist, seit ich diesen Post zum ersten Mal entworfen habe,
weil Prefill die Schwachstelle war und Prefill die Aufmerksamkeit bekommen hat:
- **GGUF-Prefill war früher ein klarer Verlust; jetzt ist es ungefähr ausgeglichen.** Ein
neuer INT8-Prefill-Pfad (Standard seit #617) hob den Durchsatz pro Modell um +36 % bis
+151 %. imp liegt jetzt bei MoE (Qwen3-30B-A3B, +7 %) und dense (Qwen3-14B, +1,5 %) knapp
vor llama.cpp und liegt nur bei Gemma-4-26B (1,20×) und einem Hybridmodell (1,55×)
zurück.
- **NVFP4-Prefill ist praktisch gleichauf.** Die Überarbeitung des Attention-Kernels
(#687) brachte MoE-Long-Context-Prefill *vor* vLLM und verringerte den dense-Abstand von
1,27× auf 1,04×. Um präzise zu sein, was das schlägt: Auf `sm_120` läuft vLLM auf einem
Fallback-Pfad, weil seine tcgen05-NVFP4-Kernels auf Consumer-Blackwell nicht laufen, das
ist also ein Vorsprung vor vLLMs Fallback, nicht vor seinem optimierten
Rechenzentrums-Pfad. Der eine Überlebende ist dense Long-Context-Prefill, das um etwa 4 %
verliert.
- **Qwen3.6-35B-GGUF-Decode verliert noch ~31 %** gegen llama.cpp, strukturelle Kosten des
speziellen Attention-Designs dieses Modells, die FP4-Gewichte nicht wettmachen können.
- **Batched Durchsatz in der Summe unter Parallelität ist nicht imps Achse.** Jede Zahl
hier ist Single-Stream, Batch 1; bei vielen parallelen Requests liegen Engines wie vLLM
vorn, und genau dafür sind sie gebaut.
- Es ist **experimentell, Single-GPU, Single-Author**. llama.cpp bleibt die richtige Wahl,
wenn du Reife und Universalität willst; vLLM, wenn du auf Rechenzentrumskarten batchst.
imp beantwortet genau eine Frage: Wie schnell kann eine einzelne 5090 sein?
## Der Teil, den ich immer noch leicht absurd finde
imp umfasst rund 97k Zeilen C++20 und CUDA (GGUF- und SafeTensors-Loader, ein
BPE-Tokenizer, ein Paged KV-Cache, der CUTLASS-NVFP4-Dispatch, die Attention-Kernels,
MoE-Routing, ein OpenAI- und Anthropic-kompatibler Server), und jede Zeile davon wurde von
[Claude Code](https://claude.com/product/claude-code) geschrieben. Mein Job ist die
Architektur, die Modellauswahl, das Benchmarking und die Richtung. Der Agent schreibt den
Code. Wir sind bei 1.000+ Commits. Wie sich dieser Workflow in dieser Größenordnung
schlägt, ist eine Geschichte für einen eigenen Post.
Wenn du eine 5090 hast und zusehen willst, wie es läuft: Alles kommt als Docker-Images auf
[GHCR](https://github.com/kekzl/imp/pkgs/container/imp), kein lokales CUDA-Toolkit nötig.
Das Repo ist [github.com/kekzl/imp](https://github.com/kekzl/imp): MIT, experimentell und
ganz klar eine Wette auf eine einzige Architektur.