L'aplatissement de flux et le JIT à paliers
L'aplatissement réécrit une méthode en un répartiteur `while(true){ switch(state) }`, ce qui change la façon dont le JIT à paliers de .NET la traite : une méthode linéaire devient une méthode à boucle, elle passe donc désormais par le On-Stack Replacement, et son IL grossie sort généralement de l'inliner. La répartition en elle-même est bon marché — une table de sauts sur des entiers denses au palier 1 — mais perdre l'inlining et payer le palier 0 pour une boucle supplémentaire, c'est là que se cache le vrai coût. Cet article lit ce que le JIT fait d'un corps aplati à travers le palier 0, l'OSR et le palier 1, et montre comment cibler l'aplatissement pour que les méthodes chaudes et inlinables restent intactes.
Une façon courante de raisonner sur l’aplatissement de flux de contrôle est de le mesurer une fois — envelopper la méthode dans un benchmark, noter « environ 8 % plus lent » et en faire le prix. Ce chiffre est réel, mais il masque le mécanisme, et le mécanisme est plus intéressant que le chiffre, car l’aplatissement n’ajoute pas que des instructions. Il change la forme de la méthode du point de vue du JIT : un corps linéaire devient un corps à boucle. Et dans le .NET moderne, savoir si une méthode boucle est l’une des premières choses que le JIT à paliers se demande à son sujet.
La vraie question
L’aplatissement réécrit une méthode en un répartiteur : les blocs de base d’origine sont numérotés, et une boucle while(true){ switch(state) } les exécute dans un ordre choisi par une variable d’état plutôt que par enchaînement et sauts. Tout le monde sait que la répartition ajoute un peu de comptabilité. La question qui mérite d’être posée est celle d’un cran en dessous : que fait le JIT à paliers d’une méthode qui contient soudain une boucle chaude qu’elle n’avait pas auparavant — à travers le palier 0, le On-Stack Replacement et le palier 1 — et où atterrit réellement le coût ?
Ce que produit l’aplatissement
Partons d’une méthode ordinaire et de sa forme aplatie, pour rendre le changement de forme concret.
// original — linéaire, sans boucle
static int Classify(int score)
{
if (score < 0) return -1;
if (score < 50) return 0;
return 1;
}
// aplati — une boucle de répartition sur des blocs numérotés
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;
}
}
}
Les deux compilent vers les mêmes réponses, mais la seconde a une boucle et un switch. En IL, le switch est un unique opcode switch sur une table de décalages de saut, alimenté par le local 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 // retour à la tête du répartiteur
Nebula numérote les blocs avec de petits entiers denses à dessein : un ensemble dense de cas est ce qui permet au JIT optimisant d’abaisser ceci en une table de sauts plutôt qu’en une chaîne de comparaisons. Cette décision est prise au palier 1, qui est le premier endroit où le JIT à paliers entre dans l’histoire.
Palier 0, OSR et palier 1
Le JIT de .NET est à paliers. Une méthode est compilée d’abord au palier 0 — « quick JIT », optimisation minimale, produit vite pour que le démarrage soit bon marché. Le runtime compte les appels et, après un seuil, recompile la méthode au palier 1 — le JIT optimisant complet — sur un thread de fond, puis bascule le point d’entrée. Pour une méthode qui n’est qu’appelée, compter les appels suffit.
Une méthode qui boucle est le cas problématique. Si une méthode entre dans une boucle de longue durée à son premier appel, le comptage d’appels n’a jamais l’occasion de la promouvoir ; elle resterait coincée à exécuter du code lent de palier 0 dans la boucle. Avant .NET 7, le JIT contournait cela en compilant toute méthode à boucle directement au palier 1, sautant entièrement le palier 0. Depuis .NET 7, c’est le On-Stack Replacement (OSR) qui s’en charge : la méthode démarre au palier 0 avec un patchpoint planté dans la boucle, et si la boucle itère suffisamment, le runtime compile une version optimisée et transfère l’invocation en cours d’exécution vers elle au milieu de la boucle — remplaçant la trame sur la pile.
C’est exactement la mécanique que l’aplatissement réveille. Le Classify original n’a pas de boucle ; il suit le chemin simple palier 0 → palier 1 par comptage d’appels. Le Classify aplati a une boucle de répartition, il prend donc le chemin de l’OSR : palier 0 avec patchpoint, et une transition OSR si le répartiteur tourne assez longtemps sur un appel.
Deux conséquences pratiques découlent de cette image.
La répartition est bon marché une fois optimisée. Au palier 1, le switch dense devient une table de sauts : une vérification de bornes, un saut indirect par transition de bloc. Avec le PGO dynamique activé (le défaut depuis .NET 8), la passe d’instrumentation du palier 0 enregistre même quels cas s’exécutent le plus chaud et le réinjecte, de sorte que le chemin courant à travers le répartiteur est bien disposé. Le coût en régime permanent du répartiteur est petit et constant — ce n’est pas là que part le temps.
L’inliner est là où part le temps. Le JIT n’inline un appelé que lorsqu’il paraît bon marché : IL réduite, flux de contrôle simple, une estimation taille/bénéfice favorable. Une méthode avec une boucle explicite et un nombre de blocs démultiplié est un mauvais candidat sur tous les axes — elle est plus grosse, et une boucle en fait un rejet net pour l’inlining dans la plupart des cas. Ainsi, un petit helper que le JIT inlinait — effaçant l’appel entièrement — devient un véritable appel hors ligne une fois aplati. Pour une méthode petite et chaude, cet inlining perdu éclipse le coût de la répartition. Pour une méthode déjà trop grosse pour être inlinée, l’aplatissement ne change rien à son coût d’appel ; c’était toujours un appel réel.
Cela inverse l’intuition naïve. Les méthodes où l’aplatissement est « le plus cher » en termes relatifs sont les petits helpers chauds — précisément ceux que vous ne devriez pas aplatir. Les méthodes froides et précieuses que vous voulez aplatir étaient rarement des candidats à l’inlining au départ.
Comment le cibler dans Nebula
La consigne découle directement du mécanisme : aplatissez ce qui est précieux et froid ; laissez tranquilles les méthodes chaudes et inlinables. La transformation de flux de contrôle de Nebula accepte un ciblage par include/exclude et un préréglage d’intensité, de sorte que vous la dirigez au lieu d’actionner un unique interrupteur global.
<Nebula>
<Assembly file="MyApp.dll">
<Rename enabled="true" />
<StringEncryption enabled="true" />
<ControlFlow enabled="true" intensity="normal">
<!-- Aplatissez les méthodes qui incarnent la PI que vous protégez. -->
<Include type="MyApp.Licensing.LicenseValidator" />
<Include type="MyApp.Core.PricingEngine" method="ComputeQuote" />
<!-- Gardez l'aplatissement hors du chemin chaud, serré et inlinable. -->
<Exclude type="MyApp.Core.Geometry" />
<Exclude type="MyApp.Core.Buffers" member="public" />
</ControlFlow>
</Assembly>
</Nebula>
Une vérification de licence s’exécute une fois au démarrage ou une fois par session ; elle n’est jamais dans une boucle chaude, donc ses itérations de palier 0 et l’inlining perdu ne coûtent rien qu’un utilisateur puisse percevoir, et l’aplatir est un pur gain. Un helper d’arithmétique vectorielle appelé un million de fois dans une boucle de rendu est le cas opposé — excluez-le, et laissez-le petit et inlinable. Si vous n’êtes pas sûr qu’une méthode donnée soit chaude, c’est une question de profileur, pas une supposition : aplatissez, mesurez la charge réelle (pas un micro-benchmark qui appelle la méthode isolément) et regardez où le temps s’est réellement déplacé.
Mises en garde et quand cela casse
L’histoire des paliers a des arêtes vives qu’il vaut mieux énoncer clairement.
Un micro-benchmark qui désactive les paliers — ou qui ne mesure que le palier 0, ou seulement un premier appel à froid — vous trompera dans les deux sens. Le code de palier 0 n’est optimisé pour personne, donc l’aplatissement y paraît bon marché ; une exécution à froid paie le coût complet de JIT-plus-OSR une fois et paraît chère. Aucun n’est votre régime permanent. Mesurez du code déjà chauffé sous un schéma d’appels réaliste.
L’OSR n’aide qu’une méthode qui itère vraiment beaucoup sur un appel. Une méthode aplatie dont le répartiteur exécute une poignée de blocs puis retourne ne déclenche jamais le patchpoint — elle exécute simplement ces blocs au palier 0 jusqu’à ce que le comptage d’appels promeuve la méthode entière. C’est très bien ; c’est aussi pourquoi le chemin de l’OSR compte surtout pour les méthodes aplaties contenant une vraie boucle interne propre.
[MethodImpl(MethodImplOptions.AggressiveOptimization)] force une méthode directement au palier 1 et l’y fige, sautant le palier 0 et l’OSR et renonçant au PGO dynamique. Sur une méthode aplatie, c’est parfois le bon choix — une routine aplatie qui doit être rapide dès son premier appel — mais cela coûte du démarrage et un profil, alors recourez-y délibérément, pas par défaut.
Et la règle de fond sous tout cela : l’aplatissement sert à protéger votre propre code. Ciblez-le sur les méthodes dont la logique vous revient de défendre, mesurez honnêtement, et laissez le chemin chaud rester rapide.
À retenir
L’aplatissement de flux de contrôle n’est pas un impôt fixe. Il change la forme d’une méthode de linéaire à à-boucle, et le JIT à paliers les traite différemment : la méthode aplatie emprunte le chemin du On-Stack Replacement, son répartiteur s’abaisse en une table de sauts bon marché au palier 1, et son vrai coût est généralement l’inlining qu’elle perd en acquérant une boucle — pas la répartition. C’est pourquoi la règle honnête est la simple. Aplatissez les méthodes froides et précieuses, où rien de tout cela n’est sur un chemin chaud ; gardez-le hors des petits helpers chauds que le JIT inlinait gratuitement. Le ciblage include/exclude et les préréglages d’intensité de Nebula existent pour tracer exactement cette ligne, et le niveau Pro est là où vivent les transformations de flux de contrôle et de virtualisation les plus fortes, pour les rares méthodes qui les justifient.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.