mescolare le variabili atomiche e non atomiche e le cache

Diciamo che abbiamo questo codice che è corretto (almeno spero):

std::atomic a; std::atomic ready{false}; void threadA() { a.store(666, std::memory_order_relaxed); ready.store(true, std::memory_order_release); } void threadB() { while(!ready.load(std::memory_order_acquire)); process(a.load(std::memory_order_relaxed)); } 

La mia domanda è: nel caso tu stia usando un int a; invece di std::atomic a; , è corretto pure? O c’è un problema di svuotamento della cache / invalidazione?

Indipendentemente dal fatto che questa sia una buona idea, ad esempio, il tuo codice va bene ..

Puoi sostituire il tipo atomico di a con un normale int (o qualsiasi altro tipo).
Lo standard C ++ supporta il tuo caso con la seguente frase (§ 1.10.1-6):

Alcune chiamate di libreria si sincronizzano con altre chiamate di libreria eseguite da un altro thread. Ad esempio, un atomic store-release si sincronizza con un load-acquis che prende il suo valore dal negozio

Poiché threadB carica il valore di ready memorizzato da threadA (lo sta aspettando in un ciclo), viene stabilita la relazione synchronize-with . Pertanto, a.load() osserva gli effetti di memoria di a.store() . Un altro modo per dirlo è che a.store() succede-prima di a.load()