El aplanamiento de flujo y el JIT escalonado
El aplanamiento reescribe un método como un despachador `while(true){ switch(state) }`, y eso cambia cómo lo trata el JIT escalonado de .NET: un método lineal se convierte en uno con bucle, así que ahora pasa por On-Stack Replacement, y su IL crecida suele quedar fuera del inliner. El despacho en sí es barato —una tabla de saltos sobre enteros densos en el nivel 1— pero perder el inlining y pagar el nivel 0 por un bucle extra es donde se esconde el coste real. Este artículo lee qué hace el JIT con un cuerpo aplanado a través del nivel 0, OSR y el nivel 1, y muestra cómo acotar el aplanamiento para que los métodos calientes e inlineables queden intactos.
Una forma habitual de razonar sobre el aplanamiento de flujo de control es medirlo una vez —envolver el método en un benchmark, anotar “un 8% más lento” y tomarlo como el precio—. Ese número es real, pero oculta el mecanismo, y el mecanismo es más interesante que el número, porque el aplanamiento no solo añade instrucciones. Cambia la forma del método desde el punto de vista del JIT: un cuerpo lineal se convierte en uno con bucle. Y en el .NET moderno, si un método tiene bucle es una de las primeras cosas que el JIT escalonado pregunta sobre él.
La pregunta de verdad
El aplanamiento reescribe un método como un despachador: los bloques básicos originales se numeran, y un bucle while(true){ switch(state) } los ejecuta en un orden elegido por una variable de estado en lugar de por caída natural y saltos. Todo el mundo sabe que el despacho añade algo de contabilidad. La pregunta que vale la pena hacer es la de un nivel más abajo: ¿qué hace el JIT escalonado con un método que de pronto contiene un bucle caliente que antes no tenía —a través del nivel 0, On-Stack Replacement y el nivel 1— y dónde aterriza realmente el coste?
Qué produce el aplanamiento
Empecemos con un método corriente y su forma aplanada, para que el cambio de forma sea concreto.
// original — lineal, sin bucle
static int Classify(int score)
{
if (score < 0) return -1;
if (score < 50) return 0;
return 1;
}
// aplanado — un bucle despachador sobre bloques numerados
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;
}
}
}
Los dos compilan a las mismas respuestas, pero el segundo tiene un bucle y un switch. En IL el switch es un único opcode switch sobre una tabla de desplazamientos de salto, alimentado por el 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 // vuelve a la cabecera del despachador
Nebula numera los bloques con enteros pequeños y densos a propósito: un conjunto denso de casos es lo que permite al JIT optimizador reducir esto a una tabla de saltos en lugar de a una cadena de comparaciones. Esa decisión se toma en el nivel 1, que es el primer lugar donde el JIT escalonado entra en la historia.
Nivel 0, OSR y nivel 1
El JIT de .NET es escalonado. Un método se compila primero en el nivel 0 —“quick JIT”, optimización mínima, producido rápido para que el arranque sea barato—. El runtime cuenta las llamadas y, tras un umbral, recompila el método en el nivel 1 —el JIT optimizador completo— en un hilo de fondo, y luego cambia el punto de entrada. Para un método que solo se llama, contar llamadas es suficiente.
Un método que itera es el caso problemático. Si un método entra en un bucle de larga duración en su primera llamada, el conteo de llamadas nunca tiene ocasión de promoverlo; se quedaría ejecutando código lento del nivel 0 dentro del bucle. Antes de .NET 7 el JIT esquivaba esto compilando cualquier método con bucle directamente en el nivel 1, saltándose el nivel 0 por completo. Desde .NET 7, lo gestiona en su lugar el On-Stack Replacement (OSR): el método arranca en el nivel 0 con un patchpoint plantado en el bucle, y si el bucle itera lo suficiente, el runtime compila una versión optimizada y transfiere la invocación en ejecución a ella a mitad del bucle —reemplazando el marco en la pila—.
Esta es exactamente la maquinaria que el aplanamiento despierta. El Classify original no tiene bucle; va por el camino sencillo de nivel 0 → nivel 1 por conteo de llamadas. El Classify aplanado tiene un bucle despachador, así que toma el camino de OSR: nivel 0 con patchpoint, y una transición de OSR si el despachador gira lo suficiente en una llamada.
De esa imagen se desprenden dos consecuencias prácticas.
El despacho es barato una vez optimizado. En el nivel 1 el switch denso se convierte en una tabla de saltos: una comprobación de límites, un salto indirecto por transición de bloque. Con el PGO dinámico activado (el valor por defecto desde .NET 8), la pasada de instrumentación del nivel 0 incluso registra qué casos corren más calientes y lo realimenta, de modo que la ruta común por el despachador queda bien dispuesta. El coste en estado estable del despachador es pequeño y constante; no es ahí donde se va el tiempo.
El inliner es donde se va el tiempo. El JIT inlinea un invocado solo cuando parece barato: IL pequeño, control de flujo simple, una estimación favorable de tamaño frente a beneficio. Un método con un bucle explícito y un recuento de bloques multiplicado es un mal candidato en todos los ejes —es más grande, y un bucle lo convierte en un rechazo rotundo para el inlining en la mayoría de los casos—. Así que un ayudante pequeño que el JIT solía inlinear —borrando la llamada por completo— se convierte en una llamada genuina fuera de línea una vez aplanado. Para un método pequeño y caliente, ese inlining perdido empequeñece el coste del despacho. Para un método que ya era demasiado grande para inlinear, el aplanamiento no cambia nada sobre su coste de llamada; siempre fue una llamada real.
Eso invierte la intuición ingenua. Los métodos donde el aplanamiento es “más caro” en términos relativos son los ayudantes pequeños y calientes —justo los que no deberías estar aplanando—. Los métodos fríos y valiosos que sí quieres aplanar rara vez eran candidatos a inlining para empezar.
Cómo acotarlo en Nebula
La guía se sigue directamente del mecanismo: aplana lo que es valioso y frío; deja en paz los métodos calientes e inlineables. La transformación de flujo de control de Nebula admite acotación por include/exclude y un preset de intensidad, así que la diriges en lugar de accionar un único interruptor global.
<Nebula>
<Assembly file="MyApp.dll">
<Rename enabled="true" />
<StringEncryption enabled="true" />
<ControlFlow enabled="true" intensity="normal">
<!-- Aplana los métodos que encarnan la IP que proteges. -->
<Include type="MyApp.Licensing.LicenseValidator" />
<Include type="MyApp.Core.PricingEngine" method="ComputeQuote" />
<!-- Mantén el aplanamiento fuera de la ruta caliente, apretada e inlineable. -->
<Exclude type="MyApp.Core.Geometry" />
<Exclude type="MyApp.Core.Buffers" member="public" />
</ControlFlow>
</Assembly>
</Nebula>
Una comprobación de licencia se ejecuta una vez al arranque o una vez por sesión; nunca está en un bucle caliente, así que sus iteraciones de nivel 0 y el inlining perdido no cuestan nada que un usuario pueda percibir, y aplanarla es ganancia pura. Un ayudante de aritmética vectorial llamado un millón de veces en un bucle de render es el caso opuesto —exclúyelo, y déjalo pequeño e inlineable—. Si no estás seguro de si un método dado es caliente, eso es una pregunta de profiler, no una suposición: aplana, mide la carga real (no un microbenchmark que llama al método de forma aislada) y mira adónde se movió de verdad el tiempo.
Advertencias y cuándo se rompe
La historia del escalonado tiene aristas que conviene decir con claridad.
Un microbenchmark que desactiva el escalonado —o que mide solo el nivel 0, o solo una primera llamada en frío— te engañará en ambas direcciones. El código de nivel 0 no está optimizado para nadie, así que el aplanamiento parece barato ahí; una ejecución en frío paga el coste completo de JIT-más-OSR una vez y parece cara. Ninguno es tu estado estable. Mide código ya calentado bajo un patrón de llamadas realista.
OSR solo ayuda a un método que de verdad itera mucho en una llamada. Un método aplanado cuyo despachador ejecuta un puñado de bloques y retorna nunca dispara el patchpoint —simplemente ejecuta esos bloques en el nivel 0 hasta que el conteo de llamadas promueve el método entero—. Eso está bien; también es por lo que el camino de OSR importa sobre todo para métodos aplanados que contienen un bucle interno propio real.
[MethodImpl(MethodImplOptions.AggressiveOptimization)] fuerza un método directamente al nivel 1 y lo fija ahí, saltándose el nivel 0 y OSR y renunciando al PGO dinámico. En un método aplanado eso es a veces lo correcto —una rutina aplanada que debe ser rápida en su primera invocación—, pero cuesta arranque y un perfil, así que recúrrela deliberadamente, no por defecto.
Y la regla de base bajo todo ello: el aplanamiento es para proteger tu propio código. Acótalo a los métodos cuya lógica te corresponde defender, mide con honestidad y deja que la ruta caliente siga siendo rápida.
Conclusión
El aplanamiento de flujo de control no es un impuesto fijo. Cambia la forma de un método de lineal a con bucle, y el JIT escalonado los trata de forma distinta: el método aplanado toma el camino de On-Stack Replacement, su despachador se reduce a una tabla de saltos barata en el nivel 1, y su coste real suele ser el inlining que pierde al crecer un bucle —no el despacho—. Por eso la regla honesta es la sencilla. Aplana los métodos fríos y valiosos, donde nada de esto está en una ruta caliente; mantenlo fuera de los ayudantes pequeños y calientes que el JIT inlineaba gratis. La acotación include/exclude y los presets de intensidad de Nebula existen para trazar exactamente esa línea, y el nivel Pro es donde viven las transformaciones de flujo de control y virtualización más fuertes para los pocos métodos que las justifican.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.