# Drei Kernel für einen Chip, den das Ökosystem ausgelassen hat
> FlashAttention-2 und NVFP4-GEMM von Grund auf für die RTX 5090 getunt, und was mir der Profiler beigebracht hat, als sich jede Lehrbuch-Optimierung als falsche Fährte erwies.
Source: https://rfriedmann.de/de/blog/optimizing-kernels-consumer-blackwell/ · English: https://rfriedmann.de/blog/optimizing-kernels-consumer-blackwell/
Published: 2026-06-11 · Track: log · Level: Expert
Es gibt drei Dateien in [imp](https://github.com/kekzl/imp), die du für sich allein
kompilieren und ausführen kannst, ohne Engine, ohne CUTLASS, ohne cuDNN. Jede ist eine
einzelne `.cu`-Datei: der Kernel, eine CPU-Referenz, ein Korrektheits-Check und eine
Timing-Schleife. Sie liegen in
[`tools/standalone`](https://github.com/kekzl/imp/tree/main/tools/standalone), und es
gibt sie, weil der interessante Teil beim Bau einer schnellen Inference-Engine nicht die
Engine ist, sondern die Handvoll Kernel darunter und die Profiler-Läufe, die sie geformt
haben.
Dieser Post handelt von diesen Läufen. Und von dem, wovor dich niemand warnt, wenn du
einen GPU-Optimierungsguide liest: Die meisten „Production-Standard“-Tricks sind
Antworten auf ein Problem, das du vielleicht gar nicht hast.
## Der Chip, für den das Playbook nicht geschrieben wurde
Consumer-Blackwell, der `sm_120a`-Chip in einer 5090, sieht aus wie eine kleine B200 und
verhält sich wie ein anderes Tier. Er hat FP4-Tensor-Cores und schnellen Speicher, aber
ihm fehlt die gesamte Familie der asynchronen Matrixmultiplikations-Instruktionen, auf
der moderne Rechenzentrums-Kernel aufbauen: kein `wgmma` (die Hopper-Instruktion für
`sm_90`) und kein `tcgen05`/UMMA (der Rechenzentrums-Pfad für `sm_100`). Was er hat, ist
`mma.sync` (die synchrone Familie aus der Ampere-Linie) in der Block-Scale-Variante, die
die FP4-Matrixmultiplikation ausführt, aber den ausgebenden Warp blockiert. TMA
(`cp.async.bulk.tensor`) ist vorhanden, das fehlende Stück ist also die asynchrone
Matrixmultiplikation selbst, nicht die asynchrone Kopie. Das Flaggschiff-Design von
FlashAttention-4 und die Warp-spezialisierte CUTLASS-GEMM setzen beide Hardware voraus,
die nicht auf dem Chip ist.
Also kannst du nicht portieren. Du schreibst für die Instruktionen, die du wirklich
hast, und lässt dir vom Profiler zeigen, wo es wehtut. Drei Kernel, drei verschiedene
Lektionen.
## Kernel eins: FlashAttention-2 und das Register, das sich nicht bewegen kann
Was FlashAttention-2 schnell macht, ist nicht das Tiling, sondern dass der laufende
Output in Registern lebt und während der gesamten Attention-Schleife nie ins Shared
Memory geschrieben wird. Diese eine Bedingung diktiert alles andere, bis hin zur Frage,
welche Tensor-Core-Instruktion du benutzen darfst. (Die bequeme High-Level-Variante
versteckt genau das Detail, das du brauchst; du musst auf die rohe Instruktion runter.)
Von da an sind es acht profilergetriebene Schritte, jeder auf das gerichtet, was der
vorherige Lauf als Engpass gemeldet hat, gemessen, nie geraten. Ein paar der Highlights:
- **Einen Shared-Memory-Buffer um 8 Elemente auffüllen.** Eine Zeile. Das hat einen
Memory-Bank-Konflikt mit 7,8 Millionen Events beseitigt und **+25 %** gebracht.
- **Values per Async Copy statt über einen transponierenden Read laden**, was einen
Stall versteckt, über den sich der Profiler beschwert hatte. Noch einmal **+25 %**.
- **Die Key/Value-Tiles doppelt puffern**, also das nächste vorladen, während das
aktuelle gerechnet wird. **+13 %.**
FlashAttention-2 Forward - TFLOP/s auf einer einzelnen RTX 5090
[diagram omitted — see the page for the chart]
Derselbe Kernel, acht Optimierungsschritte auseinander. 2,0 bis 2,3× die ungetunte Referenz (der von Grund auf geschriebene Kernel vor jedem Profiler-Schritt), und bei langen Sequenzen an imps produktiver FA2 vorbei. TFLOP/s bei S = 4k / 8k / 16k; FP16-Eingaben auf dense mma.sync.m16n8k16, QK^T in FP32 akkumuliert, P·V in FP16, BH = 8, causal, head_dim 128.
Jede Zahl ist der Mittelwert von 200 Launches direkt hintereinander (100 für die GEMM
unten) nach mindestens 1,5 s Clock-Warm-up, gebaut mit nvcc aus dem CUDA-13.3.0-Container,
wie in den veröffentlichten Dateien. Treiber 610.47 wurde am 10. und 12. Juni von imps
Roofline-Läufen geloggt; Power Cap und Streuung pro Launch wurden nicht erfasst. Die
Durchsatzzahlen (113,7 / 157,7 / 186,8 TFLOP/s bei 4k / 8k / 16k) sind dense FP16 mit
in FP32 akkumuliertem QK^T: 186,8 sind 74 % der 253 TFLOP/s, die die 5090 für diesen
Modus über `mma.sync` misst (FP32-Akkumulation läuft pro Takt mit einem Viertel der
FP16-Akkumulationsrate).
Das ist 2,0 bis 2,3× die ungetunte Referenz (der von Grund auf geschriebene Ausgangspunkt,
vor jedem der acht Profiler-Schritte) und bei langen Sequenzen an imps eigener
produktiver Attention vorbei. Nicht jede Idee hat den Kontakt mit der Realität
überlebt: f16-Akkumulation im Score-Schritt *sah* offensichtlich schneller aus, wurde
gebaut und wieder zurückgenommen, als sich zeigte, dass das Entpacken mehr kostete, als
es brachte. Die Spur hat fast so viele Reverts wie Erfolge, und genau darum geht es.
Und dann ist Schluss. Der verbleibende Stall ist das Warten auf die Async Copy, und die
Lehrbuchlösung, eine tiefere Pipeline, passt nicht: Drei Buffer brauchen 102 KB Shared
Memory bei einer Obergrenze von 99 KB. Der tiefere Grund, warum es ohnehin nicht helfen
würde: Ohne asynchrone Matrixmultiplikations-Instruktion begrenzt die Abhängigkeitskette,
wie viel Arbeit sich überlappen kann, egal wie weit du die Occupancy hochdrehst. Die
Lücke zu einem Kernel der B200-Klasse ist hier Silizium, nicht Code.
## Kernel zwei: die GEMM, bei der das Playbook gelogen hat
Das ist die Matrixmultiplikation, die den Prefill dominiert, und sie läuft auf dem
schnellsten FP4-Pfad des Chips: 4-Bit-Gewichte mit einem Block-Skalierungsfaktor in
Hardware. Die Optimierungsspur führt von einem ungetunten Referenz-Kernel mit
1,8 TFLOP/s zu **972**, und die *Form* dieses Anstiegs ist die ganze Geschichte. Die
540× sind der Abstand zu diesem ungetunten Startpunkt, keine Aussage über die
Ingenieursleistung; die interessante Arbeit steckt in den späteren Schritten, wenn die
leichten Gewinne schon aufgebraucht sind.
NVFP4-GEMM - TFLOP/s, Schritt für Schritt (einzelne RTX 5090, K=8k)
[diagram omitted — see the page for the chart]
1,8 → 972 TFLOP/s, wobei 1,8 der ungetunte Referenz-Kernel ist. Der Knick bei Schritt 4 sind die echten Block-Skalierungsfaktoren; der Sprung bei Schritt 5 ist die neue Diagnose (Request-bound, nicht Bandwidth-bound) plus ein Layout-Fix. Bei denselben quadratischen Shapes ist imps produktiver CUTLASS-Pfad weiterhin schneller (Korrektur unten). Mittelwert von 100 Launches pro Punkt, Bedingungen wie oben.
Die ersten vier Schritte sind die, die du erwarten würdest: die Gewichte dicht packen,
die Loads doppelt puffern, ein größeres Tile mit Register Blocking nehmen, die echten
Block-Skalierungsfaktoren verdrahten. Das bringt dich auf ~680 TFLOP/s und zu einer
sauberen Diagnose: Der Kernel hängt am L2-Cache.
Nun sind die Standardantworten auf einen L2-Engpass bekannt, und ich habe sie probiert.
Jede einzelne war ein Blindgänger:
- **Threadblock-Swizzle**, zurückgenommen, −7 %. Das verbessert die *Hit Rate* des Cache;
durch die *Pipe* des Cache flossen trotzdem dieselben Bytes.
- **Dreistufige Pipeline**, kein Gewinn. Das ist ein Fix gegen *Latenz*, und das hier
war kein Latenzproblem.
- **TMA + Warp-Spezialisierung**, die volle Rechenzentrums-Antwort, von Grund auf
gebaut. Es funktionierte, es war bitgenau, und es war **langsamer**. (Dazu gleich
mehr.)
Drei Hebel auf Produktionsniveau, drei falsche Fährten, weil jeder eine Frage
beantwortete, die der Kernel gar nicht gestellt hatte. Der eigentliche Fix kam aus dem
Misstrauen gegenüber der Diagnose selbst. Beim genaueren Lesen des Profilers: Der Cache
lag bei 82 % für *Requests*, aber nur bei 44 % für *Sectors*. Das heißt nicht „keine
Bandbreite mehr“, das heißt „der größte Teil jeder Cache Line wird verschwendet“. Das
Datenlayout hatte die Zeilen jedes Tiles mit 25 % Füllung über getrennte Cache Lines
verstreut. Zwei Layout-Änderungen, jedes Tile als einen zusammenhängenden Block ablegen
und dann die gepackten Werte so verschränken, dass ein Fragment in einem Zug lädt, und
der Durchsatz sprang von 683 auf **972 TFLOP/s**. Das sind etwa 48 % von 2019 TOPS, dem
FP4-Peak, gemessen mit einem gesättigten dense `mma.sync`-Block-Scale-Microbenchmark
(FP32-Akkumulation, wie im Kernel selbst); die 3354 TOPS aus dem Datenblatt sind über
`mma.sync` auf diesem Chip nicht erreichbar.
**Korrektur (2026-06-17):** Dieser Post sagte zuerst, der Kernel schlage auch imps
produktiven CUTLASS-Pfad. Das tut er nicht. Dieser Vergleich stellte diesen Benchmark
mit quadratischen Shapes den ~41 % der Produktion auf Modell-Shapes mit kleinem M
gegenüber. Direkt gemessen bei denselben quadratischen Shapes erreicht das produktive
CUTLASS 903 / 1284 TFLOP/s bei 4k / 8k gegen 813 / 972 dieses Kernels, und es bleibt die
produktive GEMM.
Die einfache Layout-Änderung schlug die brachialen Kernel-Rewrites um ~40 %. Die Lektion,
die ich immer wieder neu lernen muss: Die Optimierung, zu der du greifst, enthält eine
Annahme über deinen Engpass. Prüf die Annahme, bevor du eine Woche in den Fix steckst.
## Kernel drei: der, den ich behalten habe, weil er verloren hat
Die dritte Datei ist ein dokumentierter Fehlschlag, und ihr Header sagt das in
Großbuchstaben. Es ist die vollständige Implementierung mit TMA +
Warp-Spezialisierung, der Ansatz auf Rechenzentrums-Niveau, zu dem jeder zuerst greifen
würde. Sie ist korrekt, sie läuft nicht in einen Deadlock, und sie verliert: 509 TFLOP/s
gegen 629 des einfacheren Kernels, weil die aufwendige Version dem Chip die Parallelität
entzieht, um ihren einen cleveren Loader zu füttern. Der Datei-Header hält das Paar
fest, aber nicht die Problemgröße, bei der es gemessen wurde, und 629 passt zu keiner
der 4k/8k-Zahlen oben, also vergleich 509 und 629 miteinander, nicht über Abschnitte
hinweg.
Ich habe sie mit Absicht im Repo behalten. Eine Benchmark-Tabelle, die nur Siege zeigt,
ist Marketing; ein negatives Ergebnis, das du kompilieren und ausführen kannst, ist
Evidenz. Auf diesem Chip, für diesen Kernel, ist die Technik, zu der jeder greifen
würde, die falsche, und die Datei ist da, damit die nächste Person nicht eine Woche
damit verbringen muss, das zu beweisen.
## Warum sie eigenständig sind
Diese drei hätten in der Engine vergraben bleiben können. Sie sind als einzelne,
lauffähige Dateien herausgelöst, weil das die ehrliche Form dieses Wissens ist: nicht
„imp ist schnell“, sondern „hier ist der exakte Kernel, hier ist die Profiler-Spur, die
ihn geformt hat, hier ist die Referenz, die beweist, dass er korrekt ist, kompilier es
selbst“. Jeder baut mit einem Befehl und prüft seine eigene Antwort, bevor er eine Zahl
ausgibt.
Und wie alles andere in imp wurde jede Zeile von [Claude
Code](https://claude.com/product/claude-code) geschrieben. Mein Teil war, Profiler-Ausgaben
zu lesen und zu entscheiden, welchem Engpass als Nächstes nachzugehen ist; der Agent hat
die Kernel, die Referenzen und die Reverts geschrieben. Die Reverts zählen so viel wie
die Erfolge. Überraschend viel schneller GPU-Code ist schlicht die Disziplin, das
Clevere zu löschen, das sich nicht ausgezahlt hat.
Wenn du eine 5090 hast, findest du die Dateien in
[`tools/standalone`](https://github.com/kekzl/imp/tree/main/tools/standalone):
MIT, in sich abgeschlossen, und jede gibt beim Ausführen ihre eigenen TFLOP/s aus.