¿Por qué el código que muta una variable compartida a través de subprocesos aparentemente NO sufre una condición de carrera?

Estoy usando Cygwin GCC y ejecuto este código:

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

unsigned u = 0;

void foo()
{
    u++;
}

int main()
{
    vector<thread> threads;
    for(int i = 0; i < 1000; i++) {
        threads.push_back (thread (foo));
    }
    for (auto& t : threads) t.join();

    cout << u << endl;
    return 0;
}

Compilado con la línea: g++ -Wall -fexceptions -g -std=c++14 -c main.cpp -o main.o.

Imprime 1000, que es correcto. Sin embargo, esperaba un número menor debido a que los subprocesos sobrescribían un valor incrementado previamente. ¿Por qué este código no sufre de acceso mutuo?

Mi máquina de prueba tiene 4 núcleos y no pongo restricciones al programa que conozco.

El problema persiste al reemplazar el contenido del compartido foopor algo más complejo, p. Ej.

if (u % 3 == 0) {
    u += 4;
} else {
    u -= 1;
}

foo()es tan corto que cada hilo probablemente termina antes de que se genere el siguiente. Si agrega un sueño por un tiempo aleatorio foo()antes del u++, puede comenzar a ver lo que espera.

Es importante comprender que una condición de carrera no garantiza que el código se ejecute incorrectamente, simplemente que podría hacer cualquier cosa, ya que es un comportamiento indefinido. Incluyendo correr como se esperaba.

Particularmente en las máquinas X86 y AMD64, las condiciones de carrera en algunos casos rara vez causan problemas, ya que muchas de las instrucciones son atómicas y las garantías de coherencia son muy altas. Estas garantías se reducen algo en los sistemas multiprocesador donde se necesita el prefijo de bloqueo para que muchas instrucciones sean atómicas.

Si en su máquina, el incremento es una operación atómica, es probable que se ejecute correctamente aunque de acuerdo con el estándar del lenguaje sea Comportamiento indefinido.

Específicamente, espero que en este caso el código se esté compilando en un Fetch and Add atómico instrucción (ADD o XADD en el ensamblaje X86) que de hecho es atómico en sistemas de un solo procesador, sin embargo, en sistemas multiprocesador no se garantiza que sea atómico y un bloqueo sería necesario para hacerlo así. Si está ejecutando en un sistema multiprocesador, habrá una ventana donde los subprocesos podrían interferir y producir resultados incorrectos.

Específicamente, compilé su código para ensamblar usando https://godbolt.org/ y lo foo()compila para:

foo():
        add     DWORD PTR u[rip], 1
        ret

Esto significa que solo está realizando una instrucción de adición que para un solo procesador será atómica (aunque como se mencionó anteriormente no es así para un sistema multiprocesador).

Creo que no es tanto la cosa si pones un sueño antes o después del u++. Se trata más bien de que la operación se u++traduce en un código que, en comparación con la sobrecarga de los subprocesos de generación que llaman foo, se realiza muy rápidamente, de modo que es poco probable que sea interceptado. Sin embargo, si "prolonga" la operación u++, la condición de carrera será mucho más probable:

void foo()
{
    unsigned i = u;
    for (int s=0;s<10000;s++);
    u = i+1;
}

resultado: 694

Por cierto: también lo intenté

if (u % 2) {
    u += 2;
} else {
    u -= 1;
}

y me dio la mayoría de las veces 1997, pero a veces 1995.

Sufre de una condición de carrera. Ponga usleep(1000);antes u++;en fooy veo diferente de salida (<1,000) cada vez.

1. La respuesta probable que la razón por la condición de carrera no se manifestó para usted, a pesar de que hace existir, es que foo()es tan rápido, en comparación con el tiempo que se necesita para iniciar un hilo, que cada hilo acabados antes de la próxima puede incluso comenzar. Pero...

2. Incluso con su versión original, el resultado varía según el sistema: lo probé a su manera en una Macbook (de cuatro núcleos) y, en diez ejecuciones, obtuve 1000 tres veces, 999 seis veces y 998 una vez. Entonces la carrera es algo rara, pero claramente presente.

3. Compilaste con '-g', que tiene una forma de hacer desaparecer los errores. Volví a compilar su código, todavía sin cambios pero sin el '-g', y la carrera se volvió mucho más pronunciada: obtuve 1000 una vez, 999 tres veces, 998 dos veces, 997 dos veces, 996 una vez y 992 una vez.

4. Re. la sugerencia de agregar un sueño - eso ayuda, pero (a) un tiempo de sueño fijo deja los hilos todavía sesgados por la hora de inicio (sujeto a la resolución del temporizador), y (b) un sueño aleatorio los distribuye cuando lo que queremos es acercarlos más juntos. En su lugar, los codificaría para esperar una señal de inicio, de modo que pueda crearlos todos antes de dejarlos trabajar. Con esta versión (con o sin '-g'), obtengo resultados en todas partes, tan bajos como 974 y no más altos que 998:

   #include <iostream>
   #include <thread>
   #include <vector>
   using namespace std;
   
   unsigned u = 0;
   bool start = false;
   
   void foo()
   {
       while (!start) {
           std::this_thread::yield();
       }
       u++;
   }
   
   int main()
   {
       vector<thread> threads;
       for(int i = 0; i < 1000; i++) {
           threads.push_back (thread (foo));
       }
       start = true;
       for (auto& t : threads) t.join();
   
       cout << u << endl;
       return 0;
   }