¿Cómo cambio atómicamente 2 ints en C#?

Question

Lo que (si existe) es el equivalente de C# del comando ASM "XCHG".

Con ese comando, que es un intercambio genuino (a diferencia de Interlocked.Exchange), podría simplemente cambiar atómicamente dos ints, que es lo que realmente estoy tratando de hacer.

Actualización:

Código de ejemplo basado en mi sugerencia. Variable con el sufijo "_V" están decoradas tan volátil:

// PART 3 - process links 
// prepare the new Producer 
address.ProducerNew.WorkMask_V = 0; 
// copy the current LinkMask 
address.ProducerNew.LinkMask_V = address.Producer.LinkMask_V; 
// has another (any) thread indicated it dropped its message link from this thread? 
if (this.routerEmptyMask[address.ID] != 0) 
{ 
    // allow all other bits to remain on (i.e. turn off now defunct links) 
    address.ProducerNew.LinkMask_V &= ~this.routerEmptyMask[address.ID]; 
    // reset 
    this.routerEmptyMask[address.ID] = 0; 
} 
// PART 4 - swap 
address.ProducerNew = Interlocked.Exchange<IPC.Producer>(ref address.Producer, address.ProducerNew); 
// PART 5 - lazily include the new links, make a working copy 
workMask = address.Producer.LinkMask_V |= address.ProducerNew.WorkMask_V; 

Nota del perezoso actualización.

Answer 1

He aquí una especie de idea extraña. No sé exactamente cómo configuró su estructura de datos. Pero si es posible que pueda almacenar sus dos valores int en un long, entonces creo que puede cambiarlos atómicamente.

Por ejemplo, digamos que envuelven sus dos valores de la siguiente manera:

class SwappablePair 
{ 
    long m_pair; 

    public SwappablePair(int x, int y) 
    { 
     m_pair = ((long)x << 32) | (uint)y; 
    } 

    /// <summary> 
    /// Reads the values of X and Y atomically. 
    /// </summary> 
    public void GetValues(out int x, out int y) 
    { 
     long current = Interlocked.Read(ref m_pair); 

     x = (int)(current >> 32); 
     y = (int)(current & 0xffffffff); 
    } 

    /// <summary> 
    /// Sets the values of X and Y atomically. 
    /// </summary> 
    public void SetValues(int x, int y) 
    { 
     // If you wanted, you could also take the return value here 
     // and set two out int parameters to indicate what the previous 
     // values were. 
     Interlocked.Exchange(ref m_pair, ((long)x << 32) | (uint)y); 
    } 
} 

entonces parece que podría añadir el Swap método siguiente para dar lugar a un par intercambiado "atómicamente" (en realidad, Don "No sé si es justo decir realmente que la siguiente es atómica; es más como si produce el mismo resultado que un intercambio atómico).

/// <summary> 
/// Swaps the values of X and Y atomically. 
/// </summary> 
public void Swap() 
{ 
    long orig, swapped; 
    do 
    { 
     orig = Interlocked.Read(ref m_pair); 
     swapped = orig << 32 | (uint)(orig >> 32); 
    } while (Interlocked.CompareExchange(ref m_pair, swapped, orig) != orig); 
} 

Es muy posible que haya implementado esto incorrectamente, por supuesto. Y podría haber un error en esta idea. Es solo una idea

Answer 2

¿Por qué no es Interlocked.Exchange adecuado para usted?

Si necesita cambiar las ubicaciones exactas de la memoria, está utilizando un lenguaje y una plataforma incorrectos, ya que .NET abstrae la gestión de la memoria para que no tenga que pensar en ello.

Si tiene que hacer algo como esto sin Interlocked.Exchange, podría escribir algo de código marcado como unsafe y hacer un intercambio tradicionales basados ​​en punteros como puede ser que en C o C++, pero que había necesidad de envolverlo en una sincronización adecuada contexto para que sea una operación atómica.

actualización
No es necesario recurrir a unsafe código para hacer un intercambio atómicamente. Puede ajustar el código en un contexto de sincronización para que sea atómico.

lock (myLockObject) 
{ 
    var x = Interlocked.Exchange(a, b); 
    Interlocked.Exchange(b, x); 
} 

Actualización 2
Si la sincronización no es una opción (como se indica en los comentarios), entonces yo creo que estás fuera de suerte. A medida que persigue una eficiencia no medida, es posible que desee concentrarse en otro lugar. Si el intercambio de dos valores enteros es un gran obstáculo de rendimiento, probablemente esté utilizando la plataforma incorrecta.

Answer 3

Interlocked.Exchange es realmente la única cosa que puede hacer:

var x = Interlocked.Exchange(a, b); 
    Interlocked.Exchange(b, x); 

Tiene razón en que esto no será atómica, pero con una variable local utiliza se le garantiza que los valores son consistentes, siempre y cuando ambas líneas ejecutar. Sus otras opciones son un código inseguro (para usar punteros), usar p/invoke a una biblioteca nativa o rediseñar para que ya no sea necesario.

Answer 4

Fuera de Interlocked.Exchange, asumo que el comando XCHG es probablemente una implementación del XOR Swap, por lo que podría escribir el suyo.

C sintaxis: (de enlace de Wikipedia)

void xorSwap (int *x, int *y) { 
    if (x != y) { 
     *x ^= *y; 
     *y ^= *x; 
     *x ^= *y; 
    } 
} 

Editar esto no es atómico, que tendría que sincronizar usted mismo

Answer 5

Según MSDN, Interlocked.Exchange es atómica.

Si no es adecuado para usted, puede implementar XCHG en una sección insegura usando C/C++.

Answer 6

Ésta es la aplicación probable para Interlocked.Exchange() en el CLR, copiada de la fuente SSCLI20:

FASTCALL_FUNC ExchangeUP,8 
     _ASSERT_ALIGNED_4_X86 ecx 
     mov  eax, [ecx]  ; attempted comparand 
retry: 
     cmpxchg [ecx], edx 
     jne  retry1   ; predicted NOT taken 
     retn 
retry1: 
     jmp  retry 
FASTCALL_ENDFUNC ExchangeUP 

Es superior a la utilización de XCHG ya que este código funciona sin tener una cerradura de autobuses. El código de salto de aspecto extraño es una optimización en caso de que los datos de predicción de bifurcación no estén disponibles. Huelga decir que tal vez, tratando de hacer un mejor trabajo que lo que ha sido reflexionado durante muchos años por muy buenos ingenieros de software con generosas aportaciones de los fabricantes de chips, es una gran tarea.

Answer 7

Interlocked.Exchange es la mejor manera de intercambiar dos valores int de manera segura para subprocesos en C#.

Utilice esta clase, incluso si tiene un ordenador multiprocesador y nunca sabe en qué procesador se ejecutará su hilo.

Answer 8

Creo que acabo de encontrar la mejor solución. Es:

Interlocked.Exchange() Método (ref T, T)

Todas las "nuevas" variables se pueden definir en una clase (Of T) y la intercambian con las variables actuales. Esto permite que se produzca una instantánea atómica, al tiempo que se intercambia efectivamente cualquier cantidad de variables.