´

C# - la palabra clave volatile, explicación y ejemplos

Puedes ver el articulo original en  mi blog:

http://juank.black-byte.com/c-explicacion-ejemplo-volatile/

 ---

La palabra clave volatile es una de esas palabras clave muy pocas veces comprendidas, la documentación presente en msdn 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 msdn

En msdn encontramos la siguiente definición de la palabra clave volatile:

información completa

Debemos resaltar dos aspectos importantes de ese texto:

1. Se menciona que los campos volatile no son susceptibles de optimizaciones por parte del compilador. Cuales optimizaciones?
2. 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 las cosas en el ejecutable que no están en manos del programador ni del propio lenguaje para que a la hora de ejecutarse el programa sea más eficiente.

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 (de acuerdo a los estándares) todo lo que pueda hacer referencia a las variables en el contexto de ‘subproceso’ 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 ), así que con base a lo analizado realiza las optimizaciones, por ello el problema surge cuando un hilo trata de acceder a una variable que esta siendo modificada por un objeto que se ejecuta en un hilo diferente, ya que es posible que el hilo dueño de la variable se encuentre en  medio de un proceso optimizado para funcionar por cache en los registros y al no estar verificando el valor de la variable en memoria pues no vera los cambios realizados, de hecho los sobrescribirá al finalizar. 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.

El Ejemplo

Bien después de la teoría veamos 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), y finalmente un caso que de acuerdo a la teoría que acabamos de ver funcionara perfectamente desde que lo compiles para x86.

Sobra decir que para probar los ejemplos lo debes hacer con la versión Release del ejecutable.

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 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 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, ya que 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 "stopping" también es optimizado, trayendo como resultado que siempre este en uno de los registros y por tanto nunca se entere en que momento “stopping” cambio de valor para que saliera del bucle.

using System.Threading;
using System;

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 codigo parece que todo saldra bien, al ejecutarse el programa este nunca terminara pues el hilo nunca se entera que "stopping" cambio su valor. En pantalla veriamos perpetuamente

Main Exit

Y nada más :(

Ese es el ejemplo perfecto de la funcionalidad de volatile, así que podemos ahora marcar el campo "stopping" como volatile, compilar y ejecutar la versión release... y AHORA SI FUNCIONA COMO DEBERIA DE SER!!!

using System.Threading;
using System;

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 veríamos

Main Exit
EfectuarTrabajo exit xxxxxxxx

:)

Ejemplo 4

Este es el mismo ejemplo un poco mas elaborado haciendo uso de algunas operaciones de System.Math las cuales son suceptibles de optimización:

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);
    }
}

Prueben quitando y poniendo volatile y verán la diferencia.

Eso es todo.

Hasta pronto.