ch versuche, Speicherbarrieren auf einem Niveau zu verstehen, das für Java-Programmierer ohne Sperren nützlich ist. Dieses Niveau liegt meiner Meinung nach irgendwo zwischen dem Erlernen von Informationen zu flüchtigen Bestandteilen und dem Erlernen der Arbeit mit Store / Load-Puffern aus einem x86-Handbuc

Ich habe einige Zeit damit verbracht, eine Reihe von Blogs / Kochbüchern zu lesen, und habe mir die folgende Zusammenfassung ausgedacht. Könnte jemand besser informiert sein, wenn er in der Zusammenfassung nachschaut, ob ich etwas verpasst oder falsch aufgelistet habe?

LFENCE:

Name             : LFENCE/Load Barrier/Acquire Fence
Barriers         : LoadLoad + LoadStore
Details          : Given sequence {Load1, LFENCE, Load2, Store1}, the
                   barrier ensures that Load1 can't be moved south and
                   Load2 and Store1 can't be moved north of the
                   barrier. 
                   Note that Load2 and Store1 can still be reordered.

Buffer Effect    : Causes the contents of the LoadBuffer 
                   (pending loads) to be processed for that CPU.This
                   makes program state exposed from other CPUs visible
                   to this CPU before Load2 and Store1 are executed.

Cost on x86      : Either very cheap or a no-op.
Java instructions: Reading a volatile variable, Unsafe.loadFence()

SFENCE

Name             : SFENCE/Store Barrier/Release Fence
Barriers         : StoreStore + LoadStore
Details          : Given sequence {Load1, Store1, SFENCE, Store2,Load2}
                   the barrier ensures that Load1 and Store1 can't be
                   moved south and Store2 can't be moved north of the 
                   barrier.
                   Note that Load1 and Store1 can still be reordered AND 
                   Load2 can be moved north of the barrier.
Buffer Effect    : Causes the contents of the StoreBuffer flushed to 
                   cache for the CPU on which it is issued.
                   This will make program state visible to other CPUs
                   before Store2 and Load1 are executed.
Cost on x86      : Either very cheap or a no-op.
Java instructions: lazySet(), Unsafe.storeFence(), Unsafe.putOrdered*()

MFENCE

Name             : MFENCE/Full Barrier/Fence
Barriers         : StoreLoad
Details          : Obtains the effects of the other three barrier.
                   Given sequence {Load1, Store1, MFENCE, Store2,Load2}, 
                   the barrier ensures that Load1 and Store1 can't be
                   moved south and Store2 and Load2 can't be moved north
                   of the barrier.
                   Note that Load1 and Store1 can still be reordered AND
                   Store2 and Load2 can still be reordered.
 Buffer Effect   : Causes the contents of the LoadBuffer (pending loads) 
                   to be processed for that CPU.
                   AND
                   Causes the contents of the StoreBuffer flushed to
                   cache for the CPU on which it is issued.
 Cost on x86     : The most expensive kind.
Java instructions: Writing to a volatile, Unsafe.fullFence(), Locks

Finally, wenn sowohl SFENCE als auch MFENCE den storeBuffer entleeren (Cacheline ungültig machen und auf Bestätigungen von einem anderen CPU warten), warum ist einer ein No-Op und der andere ein sehr teurer Op?

Vielen Dan

(Cross-posted aus dem Mechanical Sympathy-Forum von Google)