Diferentes resultados de suma con Parallel.ForEach

Question

Tengo un loop foreach que estoy paralelizando y noté algo extraño. El código es el siguiente

double sum = 0.0; 

Parallel.ForEach(myCollection, arg => 
{ 
    sum += ComplicatedFunction(arg); 
}); 

// Use sum variable below 

Cuando uso una foreach bucle regulares consigo resultados diferentes. Puede haber algo más profundo en el interior del ComplicatedFunction, pero es posible que la variable sum no se vea afectada por la paralelización?

Answer 1

¿Es posible que la variable de suma no se vea afectada por la paralelización?

Sí.
El acceso a un double no es atómico y la operación sum += ... nunca es segura para subprocesos, ni siquiera para los tipos que son atómicos. Entonces tienes múltiples condiciones de carrera y el resultado es impredecible.

Se podría utilizar algo como:

double sum = myCollection.AsParallel().Sum(arg => ComplicatedFunction(arg)); 

o, en una notación más corta

double sum = myCollection.AsParallel().Sum(ComplicatedFunction); 

Answer 2

Si se piensa que sum += ComplicatedFunction que se compone realmente de un grupo de operaciones, dice:

r1 <- Load current value of sum 
r2 <- ComplicatedFunction(...) 
r1 <- r1 + r2 

Así que ahora intercala aleatoriamente dos (o más) instancias paralelas de esto. Un hilo puede contener un "valor antiguo" añejo de la suma que utiliza para realizar su cálculo, cuyo resultado se escribe sobre la parte superior de alguna versión modificada de la suma. Es una condición de carrera clásica, porque algunos resultados se pierden de una manera no determinista en función de cómo se realiza el entrelazado.

Answer 3

Al igual que las otras respuestas mencionadas, la actualización de la variable sum de varios subprocesos (que es lo que hace Parallel.ForEach) no es una operación segura para subprocesos. La solución trivial de adquirir un bloqueo antes de realizar la actualización solucionará ese problema.

double sum = 0.0; 
Parallel.ForEach(myCollection, arg => 
{ 
    lock (myCollection) 
    { 
    sum += ComplicatedFunction(arg); 
    } 
}); 

Sin embargo, que introduce otro problema. Dado que el bloqueo se adquiere en cada iteración, eso significa que la ejecución de cada iteración se serializará efectivamente. En otras palabras, hubiera sido mejor usar un simple loop viejo foreach.

Ahora, el truco para hacer esto bien es dividir el problema en mandriles separados e independientes. Afortunadamente, es muy fácil hacerlo cuando todo lo que desea hacer es sumar el resultado de las iteraciones porque la operación suma es conmutativa y asociativa, y porque los resultados intermedios de las iteraciones son independientes.

Así que aquí está cómo lo haces.

double sum = 0.0; 
Parallel.ForEach(myCollection, 
    () => // Initializer 
    { 
     return 0D; 
    }, 
    (item, state, subtotal) => // Loop body 
    { 
     return subtotal += ComplicatedFunction(item); 
    }, 
    (subtotal) => // Accumulator 
    { 
     lock (myCollection) 
     { 
      sum += subtotal; 
     } 
    });