Lectura atómica de 16 bytes en CPU x64

Question

Necesito leer/escribir de forma atómica en 16 bytes. Solo escribo usando cmpxchg16, que está disponible en todos los procesadores x64 excepto en el caso de uno oscuro de AMD.

Ahora la pregunta es para los valores alineados de 16 bytes, solo se modifica utilizando cmpxchg16 (que actúa como una barrera de memoria completa) ¿es posible leer una ubicación de 16 bytes que es mitad de datos antiguos y mitad datos nuevos?

Mientras lea con una instrucción SSE (por lo que el hilo no se puede interrumpir en el medio de la lectura) creo que es imposible (incluso en sistemas multiprocesador numa) que la lectura vea datos inconsistentes. Creo que debe ser atómico.

Supongo que cuando se ejecuta cmpxchg16, modifica los 16 bytes atómicamente, no escribiendo dos bloques de 8 bytes con la posibilidad de que otros hilos hagan una lectura intermedia (sinceramente, no veo cómo podría funcionar si no fuera atómico.)

¿Estoy en lo correcto? Si estoy equivocado, ¿hay alguna manera de hacer una lectura atómica de 16 bytes sin recurrir al bloqueo?

Nota: Hay un couple similar questions here pero no se ocupan del caso en que las escrituras solo se realizan con cmpxchg16, por lo que creo que esta es una pregunta separada, sin respuesta.

Edit: En realidad, creo que mi razonamiento era defectuoso. Una instrucción de carga SSE se puede ejecutar como dos lecturas de 64 bits, y es posible que cmpxchg16 se ejecute entre las dos lecturas por otro procesador.

Answer 1

typedef struct 
{ 
    unsigned __int128 value; 
} __attribute__ ((aligned (16))) atomic_uint128; 

unsigned __int128 
atomic_read_uint128 (atomic_uint128 *src) 
{ 
    unsigned __int128 result; 
    asm volatile ("xor %%rax, %%rax;" 
       "xor %%rbx, %%rbx;" 
       "xor %%rcx, %%rcx;" 
       "xor %%rdx, %%rdx;" 
       "lock cmpxchg16b %1" : "=A"(result) : "m"(*src) : "rbx", "rcx"); 
    return result; 
} 

Eso debería hacer el truco. El typedef asegura la alineación correcta. El cmpxchg16b necesita que los datos se alineen en un límite de 16 bytes.

El cmpxchg16b probará si *src contiene un cero y escribe un cero si es así (nop). En cualquier caso, el valor correcto se mantendrá en RAX: RDX después.

El código anterior se evalúa como algo tan simple como

push %rbx 
xor %rax,%rax 
xor %rbx,%rbx 
xor %rcx,%rcx 
xor %rdx,%rdx 
lock cmpxchg16b (%rdi) 
pop %rbx 
retq 

Answer 2

Según referencias http://siyobik.info/main/reference/instruction/CMPXCHG8B%2FCMPXCHG16B la CMPXCHG16 no es por defecto atómico pero se pueden hacer atómica utilizando LOCKhttp://siyobik.info/main/reference/instruction/LOCK

Eso significa que, por defecto, los datos pueden ser modificados dentro de la lectura y escritura fases. Locking hace que tanto la lectura como la escritura sean atómicas.