Skip to content
← Alle Beiträge
· Delta1 Labs PerformanceNebula

Control-Flow-Flattening und der gestufte JIT

Flattening schreibt eine Methode in einen `while(true){ switch(state) }`-Dispatcher um, und das verändert, wie der gestufte JIT von .NET sie behandelt: Aus einer geradlinigen Methode wird eine mit Schleife, sie geht also nun durch On-Stack Replacement, und ihre gewachsene IL fällt meist aus dem Inliner heraus. Der Dispatch selbst ist billig — eine Sprungtabelle über dichte Ganzzahlen auf Stufe 1 —, aber den Inlining-Verlust und die zusätzliche Schleife auf Stufe 0 zu bezahlen, dort versteckt sich der echte Preis. Dieser Beitrag liest, was der JIT mit einem geflatteten Rumpf über Stufe 0, OSR und Stufe 1 macht, und zeigt, wie man das Flattening so eingrenzt, dass die heißen, inlinebaren Methoden unberührt bleiben.

Eine verbreitete Art, über Control-Flow-Flattening nachzudenken, ist, es einmal zu messen — die Methode in ein Benchmark zu packen, „etwa 8 % langsamer” zu notieren und das als den Preis zu nehmen. Diese Zahl ist real, aber sie verbirgt den Mechanismus, und der Mechanismus ist interessanter als die Zahl, denn Flattening fügt nicht nur Instruktionen hinzu. Es ändert die Form der Methode aus Sicht des JIT: Aus einem geradlinigen Rumpf wird einer mit Schleife. Und im modernen .NET ist die Frage, ob eine Methode schleift, eine der ersten, die der gestufte JIT über sie stellt.

Die eigentliche Frage

Flattening schreibt eine Methode in einen Dispatcher um: Die ursprünglichen Basisblöcke werden nummeriert, und eine while(true){ switch(state) }-Schleife führt sie in einer von einer Zustandsvariablen gewählten Reihenfolge aus, statt per Durchfall und Sprüngen. Jeder weiß, dass der Dispatch etwas Buchhaltung hinzufügt. Die Frage, die zu stellen sich lohnt, liegt eine Ebene tiefer: Was macht der gestufte JIT mit einer Methode, die plötzlich eine heiße Schleife enthält, die sie vorher nicht hatte — über Stufe 0, On-Stack Replacement und Stufe 1 — und wo landet der Preis tatsächlich?

Was Flattening erzeugt

Beginnen wir mit einer gewöhnlichen Methode und ihrer geflatteten Form, damit die Formänderung konkret wird.

// Original — geradlinig, keine Schleife
static int Classify(int score)
{
    if (score < 0) return -1;
    if (score < 50) return 0;
    return 1;
}

// geflattet — eine Dispatcher-Schleife über nummerierte Blöcke
static int Classify(int score)
{
    int state = 0, result = 0;
    while (true)
    {
        switch (state)
        {
            case 0: state = (score < 0) ? 1 : 2; break;
            case 1: result = -1; state = 5; break;
            case 2: state = (score < 50) ? 3 : 4; break;
            case 3: result = 0; state = 5; break;
            case 4: result = 1; state = 5; break;
            case 5: return result;
        }
    }
}

Beide kompilieren zu denselben Antworten, aber die zweite hat eine Schleife und ein switch. In IL ist das switch ein einzelner switch-Opcode über eine Sprungoffset-Tabelle, gespeist vom lokalen state:

IL_0012:  ldloc.0            // state
IL_0013:  switch (IL_0030, IL_0040, IL_0050, IL_0060, IL_0070, IL_0080)
IL_002c:  br IL_0012         // zurück zum Dispatcher-Kopf

Nebula nummeriert die Blöcke absichtlich mit kleinen, dichten Ganzzahlen: Eine dichte Fallmenge ist es, die es dem optimierenden JIT erlaubt, dies zu einer Sprungtabelle statt zu einer Vergleichskette abzusenken. Diese Entscheidung wird auf Stufe 1 getroffen, dem ersten Ort, an dem der gestufte JIT in die Geschichte eintritt.

Stufe 0, OSR und Stufe 1

Der JIT von .NET ist gestuft. Eine Methode wird zuerst auf Stufe 0 kompiliert — „Quick JIT”, minimale Optimierung, schnell erzeugt, damit der Start billig ist. Die Laufzeit zählt die Aufrufe und rekompiliert die Methode nach einem Schwellenwert auf Stufe 1 — dem vollen optimierenden JIT — auf einem Hintergrund-Thread und tauscht dann den Einsprungpunkt. Für eine Methode, die nur aufgerufen wird, genügt das Zählen der Aufrufe.

Eine Methode, die schleift, ist der Problemfall. Betritt eine Methode in ihrem ersten Aufruf eine langlaufende Schleife, bekommt das Aufrufzählen nie die Gelegenheit, sie hochzustufen; sie steckte dann in langsamem Stufe-0-Code innerhalb der Schleife fest. Vor .NET 7 umging der JIT das, indem er jede Methode mit Schleife direkt auf Stufe 1 kompilierte und Stufe 0 ganz übersprang. Seit .NET 7 übernimmt das stattdessen On-Stack Replacement (OSR): Die Methode startet auf Stufe 0 mit einem in der Schleife gepflanzten Patchpoint, und wenn die Schleife ausreichend iteriert, kompiliert die Laufzeit eine optimierte Version und überträgt die gerade laufende Invocation mitten in der Schleife auf sie — der Frame auf dem Stack wird ersetzt.

Genau diese Maschinerie weckt das Flattening. Das ursprüngliche Classify hat keine Schleife; es fährt den einfachen Pfad Stufe 0 → Stufe 1 per Aufrufzählung. Das geflattete Classify hat eine Dispatcher-Schleife, also nimmt es den OSR-Pfad: Stufe 0 mit Patchpoint und ein OSR-Übergang, wenn der Dispatcher in einem Aufruf lange genug dreht.

Original — geradlinig, keine SchleifeStufe 0Quick JIT, min. OptStufe 1voller Optimiererin Aufrufer inlinedAufruf entfällt~N AufrufeGeflattet — Dispatcher-Schleife hinzugefügtStufe 0 + PatchpointQuick JIT, Schleife instrumentiertOSRFrame-TauschStufe 1switch als Tabellenicht inlinedAufruf bleibtheiße Schleife löst OSR aus; Zählung führt weiterhin zu Stufe 1

Aus diesem Bild folgen zwei praktische Konsequenzen.

Der Dispatch ist billig, sobald er optimiert ist. Auf Stufe 1 wird das dichte switch zu einer Sprungtabelle: eine Bereichsprüfung, ein indirekter Sprung pro Blockübergang. Mit eingeschaltetem dynamischem PGO (Standard seit .NET 8) zeichnet der Instrumentierungsdurchlauf der Stufe 0 sogar auf, welche Fälle am heißesten laufen, und speist das zurück, sodass der gewöhnliche Pfad durch den Dispatcher gut angeordnet ist. Die Kosten des Dispatchers im eingeschwungenen Zustand sind klein und konstant — dorthin geht die Zeit nicht.

Der Inliner ist, wohin die Zeit geht. Der JIT inlinet eine aufgerufene Methode nur, wenn sie billig aussieht: kleine IL, einfacher Kontrollfluss, eine günstige Schätzung von Größe gegen Nutzen. Eine Methode mit einer expliziten Schleife und einer vervielfachten Blockzahl ist auf jeder Achse ein schlechter Kandidat — sie ist größer, und eine Schleife macht sie in den meisten Fällen zu einer glatten Ablehnung fürs Inlining. So wird ein kleiner Helper, den der JIT zu inlinen pflegte — und damit den Aufruf vollständig löschte —, nach dem Flattening zu einem echten Aufruf außerhalb der Zeile. Bei einer kleinen, heißen Methode überschattet dieser verlorene Inline den Preis des Dispatchs. Bei einer Methode, die ohnehin zu groß zum Inlinen war, ändert Flattening nichts an ihren Aufrufkosten; es war immer ein echter Aufruf.

Das kehrt die naive Intuition um. Die Methoden, bei denen Flattening relativ „am teuersten” ist, sind die kleinen, heißen Helper — genau die, die Sie nicht flatten sollten. Die kalten, wertvollen Methoden, die Sie flatten wollen, waren von vornherein selten Inline-Kandidaten.

Wie man es in Nebula eingrenzt

Die Leitlinie folgt direkt aus dem Mechanismus: Flatten Sie das Wertvolle und Kalte; lassen Sie die heißen, inlinebaren Methoden in Ruhe. Nebulas Control-Flow-Transformation nimmt eine Eingrenzung per Include/Exclude und ein Intensitäts-Preset, sodass Sie sie steuern, statt einen einzigen globalen Schalter umzulegen.

<Nebula>
  <Assembly file="MyApp.dll">
    <Rename enabled="true" />
    <StringEncryption enabled="true" />
    <ControlFlow enabled="true" intensity="normal">
      <!-- Flatten Sie die Methoden, die das zu schützende geistige Eigentum verkörpern. -->
      <Include type="MyApp.Licensing.LicenseValidator" />
      <Include type="MyApp.Core.PricingEngine" method="ComputeQuote" />
      <!-- Halten Sie das Flattening vom engen, heißen, inlinebaren Pfad fern. -->
      <Exclude type="MyApp.Core.Geometry" />
      <Exclude type="MyApp.Core.Buffers" member="public" />
    </ControlFlow>
  </Assembly>
</Nebula>

Eine Lizenzprüfung läuft einmal beim Start oder einmal pro Sitzung; sie liegt nie in einer heißen Schleife, also kosten ihre Stufe-0-Iterationen und der verlorene Inline nichts, was ein Nutzer bemerken könnte, und sie zu flatten ist reiner Gewinn. Ein Vektormathematik-Helper, der in einer Render-Schleife millionenfach aufgerufen wird, ist der Gegenfall — schließen Sie ihn aus und lassen Sie ihn klein und inlinebar. Sind Sie unsicher, ob eine bestimmte Methode heiß ist, ist das eine Profiler-Frage, keine Vermutung: flatten, die reale Last messen (kein Micro-Benchmark, der die Methode isoliert aufruft) und schauen, wohin sich die Zeit tatsächlich verschoben hat.

Vorbehalte und wann es bricht

Die Stufen-Geschichte hat scharfe Kanten, die man besser klar ausspricht.

Ein Micro-Benchmark, das die Stufung abschaltet — oder nur Stufe 0 misst, oder nur einen kalten ersten Aufruf — führt Sie in beide Richtungen in die Irre. Stufe-0-Code ist für niemanden optimiert, also wirkt Flattening dort billig; ein kalter Lauf zahlt die vollen JIT-plus-OSR-Kosten einmal und wirkt teuer. Keines ist Ihr eingeschwungener Zustand. Messen Sie bereits aufgewärmten Code unter einem realistischen Aufrufmuster.

OSR hilft nur einer Methode, die in einem Aufruf wirklich viel iteriert. Eine geflattete Methode, deren Dispatcher eine Handvoll Blöcke ausführt und zurückkehrt, löst den Patchpoint nie aus — sie führt diese Blöcke einfach auf Stufe 0 aus, bis das Aufrufzählen die ganze Methode hochstuft. Das ist in Ordnung; es ist auch der Grund, warum der OSR-Pfad vor allem für geflattete Methoden zählt, die eine echte eigene innere Schleife enthalten.

[MethodImpl(MethodImplOptions.AggressiveOptimization)] zwingt eine Methode direkt auf Stufe 1 und fixiert sie dort, überspringt Stufe 0 und OSR und verzichtet auf dynamisches PGO. Bei einer geflatteten Methode ist das gelegentlich das Richtige — eine geflattete Routine, die ab ihrem ersten Aufruf schnell sein muss —, aber es kostet Start und ein Profil, also greifen Sie bewusst dazu, nicht standardmäßig.

Und die Grundregel unter alldem: Flattening dient dem Schutz Ihres eigenen Codes. Grenzen Sie es auf die Methoden ein, deren Logik zu verteidigen Ihnen zusteht, messen Sie ehrlich, und lassen Sie den heißen Pfad schnell bleiben.

Fazit

Control-Flow-Flattening ist keine pauschale Steuer. Es ändert die Form einer Methode von geradlinig zu schleifenbehaftet, und der gestufte JIT behandelt beide unterschiedlich: Die geflattete Methode nimmt den Pfad des On-Stack Replacements, ihr Dispatcher wird auf Stufe 1 zu einer billigen Sprungtabelle abgesenkt, und ihr echter Preis ist meist der Inline, den sie durch das Anwachsen einer Schleife verliert — nicht der Dispatch. Deshalb ist die ehrliche Regel die einfache. Flatten Sie die kalten, wertvollen Methoden, bei denen nichts davon auf einem heißen Pfad liegt; halten Sie es von den kleinen, heißen Helpern fern, die der JIT gratis inlinete. Nebulas Include/Exclude-Eingrenzung und Intensitäts-Presets existieren, um genau diese Linie zu ziehen, und die Pro-Stufe ist dort, wo die stärkeren Control-Flow- und Virtualisierungstransformationen für die wenigen Methoden wohnen, die sie rechtfertigen.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.