Desempeño del enclavamiento.Incremento

Question

¿Es Interlocked.Increment(ref x) más rápido o más lento que x++ para ints y longs en varias plataformas?

Answer 1

Es más lento ya que fuerza la acción a ocurrir atómicamente y actúa como una barrera de memoria, eliminando la capacidad del procesador para reordenar la memoria accesos alrededor de la instrucción.

Debe usar Interlocked.Increment cuando desee que la acción sea atómica en el estado que se puede compartir entre subprocesos; no se pretende que sea un reemplazo completo para x ++.

Answer 2

Siempre será más lento porque tiene que realizar un bloqueo de bus de CPU frente a simplemente actualizar un registro. Sin embargo, las CPU modernas alcanzan un rendimiento cercano al registro, por lo que es insignificante incluso en el procesamiento en tiempo real.

Answer 3

Es más lento. Sin embargo, es la forma general más eficiente que conozco para lograr seguridad de subprocesos en variables escalares.

Answer 4

Piénselo un momento y se dará cuenta de que una llamada Increment no puede ser más rápida que una simple aplicación del operador de incremento. Si lo fuera, entonces la implementación del operador de incremento del compilador llamaría internamente al Increment, y ellos realizarían lo mismo.

Pero, como puede ver probándolo usted mismo, no realizan lo mismo.

Las dos opciones tienen diferentes propósitos. Use el operador de incremento en general. Use Increment cuando necesite que la operación sea atómica y está seguro de que todos los demás usuarios de esa variable también están usando operaciones interconectadas. (Si no todos cooperan, entonces realmente no ayuda.)

Answer 5

En nuestra experiencia, InterlockedIncrement() et al en Windows son impactos bastante significativos. En un caso de muestra, pudimos eliminar el enclavamiento y usar ++/- en su lugar. Esto solo redujo el tiempo de ejecución de 140 segundos a 110 segundos. Mi análisis es que el enclavamiento obliga a una ida y vuelta de memoria (de lo contrario, ¿cómo podrían verlo otros núcleos?). Una lectura/escritura de caché L1 es de alrededor de 10 ciclos de reloj, pero una lectura/escritura de memoria es más parecida a 100.

En este caso de ejemplo, calculé el número de operaciones de incremento/disminución en aproximadamente mil millones. Entonces en una CPU de 2Ghz esto es algo así como 5 segundos para el ++/-, y 50 segundos para el enclavamiento. Extiende la diferencia en varios hilos, y está cerca de 30 segundos.

Answer 6

Mi prueba del perfomance:

volátil: 65174400

bloqueo: 62428600

entrelazados: 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); 
});