# Online Softmax und das Register, das sich nicht bewegen kann > FlashAttention auf der 5090 im Detail: wie Online Softmax ohne die riesige Score-Matrix auskommt und warum ein Output in Registern rohes mma.sync statt WMMA erzwingt. Source: https://rfriedmann.de/de/blog/online-softmax-and-flashattention/ · English: https://rfriedmann.de/blog/online-softmax-and-flashattention/ Published: 2026-06-17 · Track: log · Level: Expert Der [Kernel-Post](/de/blog/optimizing-kernels-consumer-blackwell/) sagte, was FlashAttention-2 schnell macht, sei ein Output, der in Registern lebt, und ging weiter. Das hier ist die langsame Version dieses Satzes: was Online Softmax tatsächlich tut, warum der Output-Akkumulator in Registern leben muss und warum genau diese eine Einschränkung die bequeme High-Level-Matrix-API ausschließt und rohes `mma.sync` erzwingt. ## Die Matrix, die du nicht bauen willst Naive Attention bildet die vollständige Score-Matrix, jede Query gegen jeden Key, wendet zeilenweise Softmax darauf an und multipliziert mit den Values. Die Matrix ist das Problem. Bei einer langen Sequenz ist sie riesig, und sie zu materialisieren heißt, eine quadratische Datenmenge zu schreiben und zu lesen, die der Kernel eigentlich gar nicht aufheben muss. ## Online Softmax FlashAttention baut sie nie. Es lässt Keys und Values in Tiles vorbeiströmen und führt pro Zeile zwei laufende Zahlen mit: den bisher größten Score und die laufende Summe der Exponentialwerte.
Online Softmax: ein Tile nach dem anderen, keine riesige Matrix
[diagram omitted — see the page for the chart]
Statt die ganze Score-Matrix zu bilden und Softmax darauf anzuwenden, streamt der Kernel Keys und Values in Tiles. Er führt ein laufendes Maximum und eine laufende Summe mit und skaliert den Output jedes Mal neu, wenn ein größerer Wert auftaucht. Die quadratische Matrix existiert nie.
Der Trick ist das Rescaling. Enthält ein neues Tile einen größeren Score als alles davor, springt das laufende Maximum, und alles bisher Akkumulierte muss auf das neue Maximum korrigiert werden. Pro Tile aktualisiert der Kernel deshalb alle drei laufenden Größen mit *demselben* Faktor `exp(m_old - m_new)`: ``` m_new = max(m_old, rowmax(S)) l_new = l_old * exp(m_old - m_new) + rowsum(exp(S - m_new)) O_new = O_old * exp(m_old - m_new) + exp(S - m_new) @ V ``` Der laufende Normalisierer `l` (die Summe der Exponentialwerte) wird in jedem Tile mit genau demselben Faktor neu skaliert wie der Output-Akkumulator `O`. Die Identität, die das exakt macht, ist simpel: `exp(S - m_old) * exp(m_old - m_new) = exp(S - m_new)`. Wende sie in jedem Tile an, und teile nach dem letzten Tile den Akkumulator durch den Normalisierer, `O <- O / l`, um das Endergebnis zu bekommen. Ohne diese letzte Division ist der Akkumulator nicht normalisiert. Sobald `l` in jedem Tile neu skaliert und `O` am Ende durch `l` geteilt wird, ist der Output identisch mit dem Softmax über die volle Matrix, ohne dass die Matrix je existiert hätte. ## Warum der Output in Registern leben muss Jetzt kommt der Teil, der alles Weitere diktiert. Dieses Rescaling, `O *= exp(m_old - m_new)`, läuft **pro Zeile**, und zwar in jedem Tile. Um es anzuwenden, muss der Kernel genau wissen, welches Register welche Output-Zeile hält. Die bequeme High-Level-API für Matrixmultiplikation (WMMA) verbirgt genau das. Sie gibt dir den Akkumulator als undurchsichtiges Fragment und behält die Zuordnung von Register zu Zeile für sich. Du kommst also nicht heran, um Zeile 7 des Outputs neu zu skalieren, du müsstest den ganzen Akkumulator ins Shared Memory auslagern, ihn dort neu skalieren und zurücklesen, was den ganzen Sinn der Sache zerstört. Rohes `mma.sync.m16n8k16` legt die Register direkt offen. Du weißt genau, welches welche Zeile ist, also ist das Rescaling eine Handvoll Multiplikationen in Registern. Deshalb verlangt die prägende Eigenschaft, dass der Output-Akkumulator während der ganzen Schleife nie das Shared Memory berührt, eine API, die das mma-Layout von Registern zu Threads offenlegt (rohes PTX oder CuTe/CUTLASS), nicht die undurchsichtige WMMA-Fragment-API. WMMA scheidet nicht aus stilistischen Gründen aus, sondern aus arithmetischen. ## Das Budget, das daraus folgt Weil der Output kein Shared Memory kostet (er lebt in Registern), kann das Shared-Memory-Budget komplett an die Daten gehen, die zwischengelagert werden müssen. Gratis ist das aber nicht: Es kostet stattdessen Register (154 pro Thread im fertigen Kernel). Und das Shared-Memory-Budget unten reicht für einen Block pro SM, und genau das deckelt die Occupancy bei den unten genannten ~17 %.
Ein Attention-Block, 97 KB von 99 KB Budget
[diagram omitted — see the page for the chart]
Das Budget des Spec-Kernels aus imps Docs. Es passt, knapp; die 102 KB weiter unten gehören zum eigenständigen Referenz-Kernel. Der Output-Akkumulator kostet nichts, weil er nie ins Shared Memory kommt; er bleibt die ganze Zeit in Registern. Genau diese eine Tatsache erzwingt rohes mma.sync statt des freundlicheren WMMA.
Die 97 KB sind das Budget des Spec-Kernels in imps Docs, eine Schätzung gegen eine Obergrenze von 99 KB: ein 128x128-FP16-Q-Tile (32 KB), ein 2x64x128-FP16-K/V-Doppelpuffer (32 KB), ein 128x64-FP32-Score-Tile, das das FP16-P mitbenutzt (32 KB), und rund 1 KB für laufendes Maximum und Summe. Die 102 KB gehören zum eigenständigen Referenz-Kernel, der Q und P in Registern hält und nur K und V zwischenlagert: Drei K+V-Slots mit dem aufgefüllten Zeilenabstand von head_dim + 8, den die 16-Byte-Ausrichtung von `ldmatrix` verlangt, brauchen 102 KB, mehr als die Obergrenze von 99 KB, also kann auch dieser Kernel nicht tiefer pipelinen. Ein bisschen mehr holt sich der Kernel mit einem Trick ohne Umweg zurück: Die Zuordnung von Spalten zu Lanes im Score-Output passt zufällig zu dem, was die Value-Multiplikation braucht, also werden die Scores direkt aus den Registern umgepackt, statt durchs Shared Memory zu wandern. Das Value-Produkt in f16 zu akkumulieren halbiert den Register-Footprint des Akkumulators; dasselbe für das Score-Produkt wurde probiert und zurückgenommen, das Entpacken kostete mehr, als es sparte. ## Die Decke Nach all dem ist der Kernel latenzgebunden bei etwa 17 % Occupancy und hängt am Warten auf die Async-Kopie. Sowohl diese Zahl als auch das Zwei-Block-Ergebnis unten stammen vom eigenständigen Referenz-Kernel auf der RTX 5090 (8 Batch-Heads, kausal, head_dim 128, FP16); Sequenzlänge und Taktraten dieser Läufe wurden nicht protokolliert. Tiefer pipelinen geht nicht (kein Shared Memory), und die Matrixmultiplikation selbst kannst du nicht verstecken, weil Consumer-Blackwell keine asynchrone Matrix-Engine hat, kein `tcgen05`, kein Tensor Memory. Die Instruktion blockiert den Warp, der sie ausgegeben hat, Punkt. Der Versuch, die Occupancy mit zwei Blöcken pro SM zu erhöhen, war gemessen 24 % *langsamer*. Die verbleibende Lücke zu einem FlashAttention-4-Kernel im Rechenzentrum ist zum Teil Silizium: Das warp-spezialisierte TMEM-Design von FlashAttention-4 lässt sich nicht auf sm_120 portieren ([kein TMEM/tcgen05 auf dem Chip](/de/blog/what-the-5090-lacks-vs-datacenter/)). Andere Software-Verbesserungen sind damit nicht ausgeschlossen. Bei demselben Tiling setzt später [APA](/de/blog/apa-adaptive-precision-attention/) an: jede Attention-Kachel in FP4 und die wenigen, die die Softmax-Masse tragen, noch einmal exakt in FP16.