PyTorch: Wie torch.compile bis zu 10× Beschleunigung durch Kernel Fusion erreicht

PyTorchs Compiler torch.compile erzielt auf GPUs Beschleunigungen von bis zu 10× ohne eine einzige Änderung am Modellcode. Der Schlüsselmechanismus hinter dieser Beschleunigung ist Kernel Fusion — eine Technik zum Zusammenführen mehrerer Operationen in einen einzigen GPU-Kernel, um das kostspielige Schreiben von Zwischenwerten in den globalen Speicher zu eliminieren.

Warum bremst GPU-Speicher das Modelltraining?

GPU-Computing berechnet nicht alle Operationen zu gleichen Kosten. Das Starten jedes GPU-Kernels verursacht einen festen Overhead, und jedes Schreiben von Zwischenwerten in den globalen Speicher ist hundertmal langsamer als Operationen in den eigenen Registern des Prozessors. Ohne Compiler führt PyTorch jede Operation (multiply, add, sigmoid) als separaten Kernel mit eigenen Schreib- und Lesevorgängen im globalen Speicher aus.

Konkret erfordern drei aufeinanderfolgende Pointwise-Operationen (x * w, + b, .sigmoid()) ohne Fusion 5 Lesevorgänge und 3 Schreibvorgänge — insgesamt 8 vollständige Tensor-I/O-Operationen. Nach Kernel Fusion: 3 Lesevorgänge + 1 Schreibvorgang = 4 Operationen, was einer 50%-Reduktion des Speicherdurchsatzes entspricht.

Wie fügt torch.compile Kernel automatisch zusammen?

torch.compile verwendet den Inductor-Compiler, der den Berechnungsgraph analysiert und mehrere Fusionstypen anwendet:

• Vertikale Fusion (am häufigsten): fügt abhängige Operationen zusammen, sodass Zwischenwerte in GPU-Registern verbleiben. Eliminiert alle temporären Tensoren, die andernfalls in den globalen Speicher müssten.
• Pointwise Fusion: fügt elementweise Operationen (multiply → add → sigmoid) in einen einzigen Triton-Kernel zusammen.
• Reduction Fusion: kombiniert Reduktionsoperationen (z. B. Summierungen) mit umliegenden Operationen — kritisch für Batch-Normalisierung.
• GEMM + Epilogue Fusion: fügt Bias und Aktivierungsfunktionen direkt am Ende der Matrixmultiplikation hinzu.
• Horizontale Fusion: führt unabhängige Operationen auf demselben Eingang (z. B. sin(x) und cos(x)) parallel in einem einzigen Kernel aus.

Was passiert mit Kerneln in der Praxis?

Der durch Fusion generierte Triton-Kernel hält alle Zwischenwerte in GPU-Registern und schreibt das Ergebnis erst am Ende:

Load x, Load w, Load b
→ tmp = x * w       (bleibt in Registern)
→ tmp = tmp + b     (bleibt in Registern)
→ tmp = sigmoid(tmp)(bleibt in Registern)
Store Ergebnis      (einziger Schreibvorgang in globalen Speicher)

Inductor benennt fusionierte Kernel automatisch mit der Konvention triton_poi_fused_* (Pointwise) und triton_per_fused_* (Reduction), was durch Setzen der Variable TORCH_LOGS="output_code" sichtbar wird.

Ergebnisse und Anwendung

Die PyTorch-Community dokumentiert Beschleunigungen von bis zu 10× in realen Modellen dank der Kombination aus Fusion, Eliminierung des Kernel-Launch-Overheads und reduziertem Speicherdurchsatz. Alles was benötigt wird ist eine einzige Codezeile:

model = torch.compile(model)

Der Inductor-Compiler erstellt dann selbstständig den optimalen Triton- oder CUDA-Kernel, ohne manuelles Schreiben von GPU-Code. Diese Automatisierung macht torch.compile zu einem der wichtigsten Werkzeuge für produktives ML-Training und Inferenz im PyTorch-Ökosystem.