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