Valor máximo y mínimo posible de una variable compartida cuando se incrementa mediante varios subprocesos

Question

Tengo una variable compartida global y se actualiza 5 veces por cada uno de los 5 subprocesos generados. Según mi entendimiento de la operación de incremento está consistiendo en 3 Instrucciones

load reg, M 
inc reg 
store reg, M 

lo tanto, quiero pedir que en este escenario lo que sería el valor máximo y mínimo dado intercalado arbitraria en los 5 hilos.

Por lo tanto, según mi opinión, el valor máximo será de 25 (estoy 100% seguro de que puede ser más de 25) y el valor mínimo es 5. Pero no estoy tan seguro del valor mínimo. ¿Puede ser menos de 5 en algún entrelazado arbitrario? Cualquier entrada será muy apreciada.

/* Global Variable */ 
int var = 0; 

/* Thread function */ 
void thread_func() 
{ 
    for(int c = 0; c < 5; c++) 
      var++; 
} 

Answer 1

Dada su definición de la subasta, estoy de acuerdo con su máximo de 25.

Sin embargo, creo que el mínimo puede ser de 2 bajo el siguiente escenario. He nombrado los 5 hilos A, B, C, D y E.

1. A cargas 0
2. C, D, E se termina de ejecutar
3. B corre a través de 4 de sus 5 iteraciones.
4. A incrementa de 0 a 1 y almacena el resultado (1).
5. cargas B 1
6. A ejecuta hasta su finalización
7. incrementos B 1 a 2 y tiendas 2.

Answer 2

Si uso la misma lógica dada por jtdubs, el valor mínimo debe ser 1 en el siguiente caso.

Permite utilizar la misma nomenclatura de 5 hilos como A, B, C, D, y E.

1. se carga un 0
2. B, C, D, E de ejecución para la terminación y incrementado a máximo valor 20 (5 incrementos por cada uno de 4 hilos).
3. incrementos A 0 a 1 y almacenar el resultado 1.

Answer 3

I de acuerdo con un mínimo de 2 (no 1).

La solución de mínimo igual a 1 ignora el hecho de que A todavía no se ha ejecutado después de almacenar 1 en la memoria compartida. Con ningún otro hilo de izquierda a "interferir", hilo A todavía debe ejecutar a través de los restantes 4 iteraciones que terminan con el resultado 5.

Lo que permite que el mínimo de 2 solución es un juego extremo entre los dos hilos restantes A y B, después de que todos los otros hilos hayan terminado de ejecutarse, lo que conduce al resultado mínimo posible. B "desperdicia" 4 iteraciones solo para cargar 1 de nuevo, incrementarlo y almacenar 2 después de que A se haya ejecutado hasta su finalización.