Garantiert C ++ 11, dassmemory_order_seq_cst verhindert, dass StoreLoad eine atomare Operation für nicht-atomare Speicherzugriffe neu anordnet?

ie bekannt, gibt es 6std::memory_orders in C ++ 11 und seine Angabenie regelmäßig, nicht atom Speicherzugriffe sind um eine atomare Operation zu ordnen - Working Draft, Standard für Programmiersprache C ++ 12.07.2016:http: //www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pd

§ 29.3 Reihenfolge und Konsistenz

§ 29.3 / 1

Die Aufzählung memory_order gibt das detaillierte @ regular (non-atomic) memory Synchronisationsreihenfolge wie in 1.10 definiert und kann eine Operationsreihenfolge vorsehen. Die aufgezählten Werte und ihre Bedeutung lauten wie folgt:

Auch bekannt, dass diese 6 Speicherreihenfolgen einige dieser Umordnungen verhindern:

Aber tutmemory_order_seq_cst StoreLoad-Neuordnung um eine atomare Operation für @ verhinderegular, non-atomic Speicherzugriffe oder nur für andere Atome mit dem gleichenmemory_order_seq_cst?

D. um diese StoreLoad-Neuordnung zu verhindern, sollten wir @ verwendstd::memory_order_seq_cst für STORE und LOAD oder nur für einen?

std::atomic<int> a, b;
b.store(1, std::memory_order_seq_cst); // Sequential Consistency
a.load(std::memory_order_seq_cst); // Sequential Consistency

Über Acquire-Release Semantik ist alles klar, es gibt genau nicht-atomaren Speicherzugriff Neuordnung über atomare Operationen:http: //en.cppreference.com/w/cpp/atomic/memory_orde

Um StoreLoad-Nachbestellungen zu verhindern, sollten wir @ verwendestd::memory_order_seq_cst.

Zwei Beispiele:

std::memory_order_seq_cst für STORE und LOAD:es gibtMFENCE

StoreLoad kann nicht nachbestellt werden - GCC 6.1.0 x86_64:https: //godbolt.org/g/mVZJs

std::atomic<int> a, b;
b.store(1, std::memory_order_seq_cst); // can't be executed after LOAD
a.load(std::memory_order_seq_cst); // can't be executed before STORE

std::memory_order_seq_cst nur für LOAD:es ist nichtMFENCE

StoreLoad kann nachbestellt werden - GCC 6.1.0 x86_64:https: //godbolt.org/g/2NLy1

std::atomic<int> a, b;
b.store(1, std::memory_order_release); // can be executed after LOAD
a.load(std::memory_order_seq_cst); // can be executed before STORE

Auch wenn C / C ++ - Compiler eine alternative Zuordnung von C / C ++ 11 zu x86 verwendet, wodurch der Speicherpuffer vor dem LOAD geleert wird:MFENCE,MOV (from memory), also müssen wir @ verwendstd::memory_order_seq_cst auch für LOAD:http: //www.cl.cam.ac.uk/~pes20/cpp/cpp0xmappings.htm Da dieses Beispiel in einer anderen Frage als Ansatz (3) diskutiert wird: Ist es sinnvoll, die Anweisung LFENCE in den Prozessoren x86 / x86_64 auszuführen?

D. Wir sollten ... benutzenstd::memory_order_seq_cst für STORE und LOAD, um @ zu generierMFENCE garantiert, das verhindert das Nachbestellen von StoreLoad.

Ist es wahr dassmemory_order_seq_cst für atomares Laden oder Speichern:

specifi Acquire-Release-Semantik - verhindern: LoadLoad, LoadStore, StoreStore-Neuordnung um eine atomare Operation fürregular, non-atomic Speicherzugriffe,

aber StoreLoad nicht um eine atomare Operation herum neu anordnennur für andere atomare Operationen mit dem gleichenmemory_order_seq_cst?