Prestazioni di Interlocked.Increment

Question

Interlocked.Increment(ref x) è più veloce o più lento di x++ per ints e long su varie piattaforme?

Answer 1

È più lento poiché forza l'azione a verificarsi in modo atomico e funge da barriera di memoria, eliminando la capacità del processore di riordinare la memoria accede a tutte le istruzioni.

Si dovrebbe usare Interlocked.Increment quando si desidera che l'azione sia atomica su stato che può essere condivisa tra i thread, non è intesa come sostituzione completa per x ++.

Answer 2

Sarà sempre più lento perché deve eseguire un blocco del bus CPU rispetto all'aggiornamento di un registro. Tuttavia, le moderne CPU raggiungono quasi le prestazioni del registro, quindi è trascurabile anche nell'elaborazione in tempo reale.

Answer 3

È più lento. Tuttavia, è il modo generale più performante che io conosca per raggiungere la sicurezza del thread su variabili scalari.

Answer 4

Pensaci per un momento e ti renderai conto che una chiamata Increment non può essere più veloce di una semplice applicazione dell'operatore di incremento. Se lo fosse, allora l'implementazione del compilatore dell'operatore di incremento chiamerebbe internamente Increment, e avrebbero eseguito lo stesso.

Ma, come puoi vedere provandolo per te, non hanno lo stesso rendimento.

Le due opzioni hanno scopi diversi. Utilizzare generalmente l'operatore di incremento. Utilizzare Increment quando è necessario che l'operazione sia atomica e si è sicuri che tutti gli altri utenti di tale variabile stiano utilizzando anche operazioni interbloccate. (Se non collaborano tutti, non è di grande aiuto.)

Answer 5

Nella nostra esperienza, InterlockedIncrement() e altri su Windows hanno impatti piuttosto significativi. In un caso campione siamo stati in grado di eliminare l'interlock e usare ++/- invece. Questo da solo ha ridotto il tempo di esecuzione da 140 a 110 secondi. La mia analisi è che l'interlock forza un roundtrip di memoria (altrimenti come potrebbero vederlo gli altri core?). Una cache L1 lettura/scrittura è di circa 10 cicli di clock, ma una memoria di lettura/scrittura più simile 100.

In questo caso di esempio, ho stimato il numero di operazioni di incremento/decremento a circa 1 miliardo. Quindi su una CPU da 2 GHz questo è qualcosa come 5 secondi per il ++/- e 50 secondi per l'interblocco. Diffondi la differenza su più thread e il suo vicino a 30 secondi.

Answer 6

La mia prova di perfomance:

volatile: 65.174.400

serratura: 62.428.600

asservita: 113.248.900

TimeSpan span = TimeSpan.FromSeconds(5); 

object syncRoot = new object(); 
long test = long.MinValue; 

Do(span, "volatile",() => { 

    long r = Thread.VolatileRead(ref test); 

    r++; 

    Thread.VolatileWrite(ref test, r); 
}); 

Do(span, "lock",() => 
{ 
    lock (syncRoot) 
    { 
     test++; 
    } 
}); 

Do(span, "interlocked",() => 
{ 
    Interlocked.Increment(ref test); 
});