Manual del desarrollador de software de arquitecturas Intel® 64 e IA-32 dice:

8.2.3.4 Las cargas se pueden reordenar con tiendas anteriores a diferentes ubicaciones
El modelo de pedido de memoria Intel-64 permite reordenar una carga con una tienda anterior a una ubicación diferente. Sin embargo, las cargas no se reordenan con tiendas en la misma ubicación.

¿Qué pasa con las cargas que se superponen parcial o totalmente a las tiendas anteriores, pero que no tienen la misma dirección de inicio? (Ver el final de esta p, ost para un caso específico)

Supongamos el siguiente código tipo C:

// lock - pointer to an aligned int64 variable
// threadNum - integer in the range 0..7
// volatiles here just to show direct r/w of the memory as it was suggested in the comments
int TryLock(volatile INT64* lock, INT64 threadNum)
{
    if (0 != *lock)
        return 0;                           // another thread already had the lock

    ((volatile INT8*)lock)[threadNum] = 1;  // take the lock by setting our byte

    if (1LL << 8*threadNum != *lock)
    {   // another thread set its byte between our 1st and 2nd check.   unset ours
        ((volatile INT8*)lock)[threadNum] = 0;
        return 0;
    }

    return 1;
}

O su equivalente x64 asm:

; rcx - address of an aligned int64 variable
; rdx - integer in the range 0..7
TryLock PROC
cmp qword ptr [rcx], 0
jne @fail

mov r8, rdx
mov rax, 8
mul rdx

mov byte ptr [rcx+r8], 1

bts rdx, rax
cmp qword ptr [rcx], rdx
jz  @success

mov byte ptr [rcx+r8], 0

@fail:
mov rax, 0
ret

@success:
mov rax, 1
ret

Luego, suponga que TryLock se ejecuta simultáneamente en dos hilos:

INT64 lock = 0;

void Thread_1() {  TryLock(&lock, 1);  }
void Thread_5() {  TryLock(&lock, 5);  }

La pregunta:

los((INT8*)lock)[1] = 1; y((INT8*)lock)[5] = 1; las tiendas no están en la misma ubicación que la carga de 64 bits delock. Sin embargo, cada una está completamente contenida por esa carga, entonces, ¿eso "cuenta" como la misma ubicación? Parece imposible que una CPU pueda hacer eso.

Qué pasa((INT8*)lock)[0] = 1? La dirección de la tienda es entonces la misma que la dirección de la siguiente carga. ¿Estas operaciones están "en la misma ubicación", incluso si el caso anterior no lo fuera?

PD. tenga en cuenta que la pregunta no se trata del código C / Asm, sino del comportamiento de las CPU x86.