Valore minimo e massimo possibile di una variabile condivisa quando incrementato da più thread

Question

Ho una variabile globale condivisa e che viene aggiornata 5 volte da ciascuno dei 5 thread generati. Come per la mia comprensione l'operazione di incremento è composto da 3 istruzioni

load reg, M 
inc reg 
store reg, M 

Quindi voglio chiedere che in questo scenario che cosa sarebbe il valore massimo e minimo dato interleaving arbitraria nei 5 filetti.

Quindi secondo me il valore massimo sarà 25 (sono sicuro al 100% che può essere superiore a 25) e il valore minimo è 5. Ma non sono così sicuro sul valore minimo. Può essere inferiore a 5 in qualche interleaving arbitrario? Qualsiasi input sarà molto apprezzato.

/* Global Variable */ 
int var = 0; 

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

Answer 1

Data la tua definizione di incremento, sono d'accordo con il vostro massimo di 25.

Tuttavia, credo che il minimo può essere di 2 sotto il seguente scenario. Ho chiamato i 5 fili A, B, C, D ed E.

1. A carichi 0
2. C, D, E correre a compimento
3. B attraversa 4 dei suoi 5 iterazioni.
4. A incrementa da 0 a 1 e memorizza il risultato (1).
5. carichi B 1
6. A fino al completamento
7. incrementi B 1 a 2 e negozi 2.

Answer 2

Se uso la stessa logica data dal jtdubs, il valore minimo dovrebbe essere 1 nella seguente Astuccio.

Consente utilizzare la stessa denominazione su 5 thread come A, B, C, D e E.

1. A carichi 0
2. B, C, D, E correre a completamento e incrementata alla massima valore 20 (5 incrementi per ciascuno dei 4 fili).
3. A incrementi 0 a 1 e memorizzare il risultato 1.

Answer 3

Concordo con un minimo di 2 (non 1).

La soluzione minima uguale a 1 ignora il fatto che A non è ancora in esecuzione dopo aver memorizzato 1 nella memoria condivisa. Con nessun altro thread lasciato per "interferire", il thread A deve ancora scorrere tra le 4 iterazioni rimanenti che terminano con il risultato 5.

Ciò che il minimo di 2 soluzioni consente è un gioco finale tra i due thread rimanenti A e B, dopo che tutti gli altri thread hanno finito di funzionare, portando al risultato minimo possibile. B "spreca" 4 iterazioni solo per caricare nuovamente 1, incrementarlo e memorizzare 2 dopo che A è terminato.