La palabra clave volatile es una de esas palabras clave muy pocas veces comprendidas, la documentación permite concluir que hay que utilizarla siempre que se manejen hilos, pero esto no siempre es así.
Sin embargo lograr identificar que es lo que hace realmente esta palabra clave es una labor complicada así que dedicaré este artículo a explorar esta funcionalidad y a crear un ejemplo práctico que permita entender su verdadera naturaleza.
La documentación
En docs encontramos la siguiente definición de la palabra clave volatile:
La palabra clave volatile indica que varios subprocesos que se ejecutan a la vez pueden modificar un campo. Los campos que se declaran como volatile no están sujetos a optimizaciones del compilador que suponen el acceso por un subproceso único. Esto garantiza que el valor más actualizado está en todo momento presente en el campo
Revisa acá la referencia completa
Debemos resaltar dos aspectos importantes de ese texto:
- Se menciona que los campos
volatileno son susceptibles de optimizaciones por parte del compilador. Cuales optimizaciones? - Dice que esto garantiza que el valor más actualizado siempre esta presente en el campo. No se supone que esto es así siempre?
A continuación revisaremos estas dos preguntas.
Optimizaciones del compilador
Siempre que compilamos un programa hecho con C# el compilador se encarga de convertir ese código C# en código de lenguaje IL, bueno realmente en OpCodes de IL.
Esto es así de sencillo, pero resulta que cuando compilamos nuestro código en la configuración release o más específicamente cuando se marca la casilla de Optimizar código en el proyecto (ver imagen) el compilador realiza una revisión general del código par determinar que cosas puede hacer funcionar de una manera mejor a la que codificó el programador inicialmente, o incluso como puede cambiar cosas en el ejecutable que no están en manos del programador ni del propio lenguaje para que el programa sea más eficiente.
Usando la línea de comandos podemos también adicionar optimize en los modificadores del compilador.
Ejemplo
csc t2.cs -optimize
Estas optimizaciones son calculadas por el compilador haciendo uso de un complejo juego de reglas algunas de las cuales dependen de la arquitectura del procesador ( x86, x64, IA64, etc) y algunas otras del modelo de memoria que se esta trabajando.
Los modelos de memoria son un tema complejo incluso desde sus fundamentos si bien no es algo imposible de aprender, pero quien quiera puede profundizar un poco más al respecto puede leer el libro de Sistemas Operativos Modernos de Andrew Tanembaum y desde luego buscar referencias adicionales en internet.
Adicionalmente a las optimizaciones realizadas por el compilador de C# tenemos una segunda etapa de compilación y optimizaciones realizadas por el JIT al momento de ejecutarse el programa, las cuales tiene su propio conjunto de reglas algunas de las cuales también están influenciadas por la arquitectura del procesador y el modelo de memoria.
El Valor Actualizado
Parte de las optimizaciones realizadas por el compilador pueden evitar que en algún momento determinado los campos de memoria donde se encuentran las variables no sean actualizados con su valor más reciente, porque?
Cada vez que el procesador hace una operación necesita colocar el valor de las variables en uno de sus registros, de tal forma que si tenemos por ejemplo un bucle con una suma de esta manera:
int i = 0;
while (condicion)
{
i = i + 1;
}
El procesador enviaría el valor de i a uno de sus registros y el valor 1 en otro registro, al obtener el valor de la suma el procesador debe colocar este valor de nuevo en memoria en la variable i de tal forma que al continuar el bucle todo el proceso se repite.
Esta secuencia sin embargo puede ser optimizada por el compilador ya que se hace innecesario que el valor de i sea copiado de los registros de la CPU a la memoria y viceversa tantas veces como dure el bucle, así que el compilador genera un código ejecutable que permite que los cálculos sean hechos en su totalidad en los registros de la CPU y solo hasta salir del bucle estos datos serian copiados de nuevo a la memoria.
Este tipo de optimizaciones que usan cache trae una mejora considerable en la ejecución de procesos intensivos a nivel matemático y funcionan bastante bien en la mayoría de los escenarios.
Optimizaciones de cache y el problema de los hilos
Cuando el compilador esta realizando las optimizaciones analiza todo lo que pueda hacer referencia a las variables en el contexto del subproceso (hilo) actual.
Realmente en la mayoría de sistemas operativos no se ejecutan los procesos sino los subprocesos y se le llama proceso a un grupo de subprocesos que comparten la memoria.
Con base en lo analizado realiza las optimizaciones, por ello el problema surge cuando un hilo ("nuevo") trata de acceder al valor de una variable que esta siendo modificada en un hilo ("inicial") diferente.
Es posible que el hilo "inicial" se encuentre en medio de una rutina optimizada para funcionar por cache (en los registros de la CPU) y al no estar copiando el valor de la variable de nuevo en memoria tras cada operación, el hilo "nuevo" no verá los cambios realizados.
Así que en escenarios donde existan múltiples hilos lo ideal es bloquear este tipo de optimizaciones y estar muy atento a los casos donde no sea conveniente inactivarlas pues hay casos para todo.
Código de ejemplo
Bien después de la teoría vamos a la práctica, veremos ejemplos donde
- volatile no sirve para nada y creo que son la mayoría de casos en el mundo real – al menos en CPUs x86 ya que en IA64 al parecer el tema es muy diferente)
- casos que de acuerdo a la teoría que acabamos de ver funciona perfectamente desde que lo compiles en modo Release y para x86.
Ejemplo 1
Este es el ejemplo típico, donde todos usamos volatile porque así lo dice la documentación pero la realidad es que en estos casos no sirve de NADA.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
static int i = 0;
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
i++;
Console.WriteLine("Valor de i="+i);
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Podríamos poner a i como volatile pero no habría diferencia puesto que básicamente el código no necesita ni tiene como ser optimizado. Así que volatile no bloquearía ninguna optimización.
Ejemplo 2
Este es el ejemplo tampoco sirve de NADA, si bien en el bucle se ve la necesidad de optimizar el rendimiento del código evitando que se copie el valor de i o de stopping de los registros de la CPU a la memoria y viceversa.
Resulta que al convertir i a string estamos forzando al compilador a que no utilice el cache dado que necesita el valor mas reciente de i en la memoria para poder llamar el método ToString() y al método WriteLine().
Adicionalmente al llamar a alguno de esos métodos se requiere colocar en los registros de la CPU los valores necesarios para cambiar de contexto y para poder ejecutar las operaciones internas de dichos métodos, así que no hay manera de optimizar nada.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
while (!stopping)
{
i++;
Console.WriteLine("Valor de i=" + i.ToString());
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Nuevamente podríamos ponerle a i como volatile pero no habría diferencia puesto que básicamente el código no necesita ni tiene como ser optimizado. Así que volatile no bloquearía ninguna optimización.
Ejemplo 3
En este si que funcionan las optimizaciones! pero el programa no funcionará ya que ambas variables caen en la optimización.
El compilador optimizara el uso de i para que se apoye en los registros del procesador de principio a fin, eso es perfecto!.
Pero por otro lado la variable stopping también es optimizada, trayendo como resultado que siempre este en uno de los registros y por tanto los hilos nunca se enteren en que momento stopping cambio de valor para que saliera del bucle.
static class BackgroundTaskDemo
{
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
Console.WriteLine("Valor de i=" + i.ToString());
while (!stopping)
{
i++;
}
Console.WriteLine("Valor de i=" + i.ToString());
Console.WriteLine("EfectuarTrabajo exit ");
}
}
Al ejecutar la version release para x86 de este programa veremos como, aunque en código parece que todo saldrá bien, al ejecutarse el programa este nunca terminara pues el hilo nunca se entera que stopping cambió su valor. En pantalla veríamos perpetuamente:
Main Exit
Y nada más :(.
Ejemplo 4
Dado que el ejemplo anterior nos muestra como se activan las optimizaciones de código del compilador, es tiempo de evitarlas haciendo uso de volatile.
static class BackgroundTaskDemo
{
private volatile static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
Console.WriteLine("Valor de i=" + i.ToString());
while (!stopping)
{
i++;
}
Console.WriteLine("Valor de i=" + i.ToString());
Console.WriteLine("EfectuarTrabajo exit ");
}
}
Ahora si en pantalla veremos el resultado esperado
Main Exit
EfectuarTrabajo exit
:D
Ejemplo 5
Este es el mismo ejemplo anterior pero un poco mas elaborado haciendo uso de algunas operaciones de System.Math las cuales son suceptibles de optimización por el compilador.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
int j = 2;
while (!stopping)
{
i++;
j = 100 + (int)Math.Sin((double)i * 10d);
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Prueba quitando y poniendo volatile y verás la diferencia claramente.
HAS PRUEBAS Y COMPARTE TUS EJEMPLOS
Hasta la próxima!.
Top comments (2)
Thx...
Gran explicación