When should you use memory barrier functions in multithreaded code?

Memory Barrier Functions in Multithreaded Code and When to Use Them

Introduction

In multithreaded programming, ensuring data consistency and coherence across multiple threads is crucial. Intel provides intrinsic functions, such as _mm_sfence(), _mm_lfence(), and _mm_mfence(), to establish memory barriers and control memory ordering. Understanding when to utilize these functions is essential for effective and efficient code optimization.

_mm_sfence()/NT Stores

_mm_sfence() is commonly used in conjunction with non-temporal (NT) stores. NT stores are weakly ordered, meaning they guarantee only that data will be flushed to memory but not necessarily in a specific order. If you need to ensure that NT stores become globally visible to other threads, you must emit an _mm_sfence() instruction following the NT store.

_mm_lfence()

The _mm_lfence() instruction acts as a load fence, preventing subsequent loads from being executed before preceding loads retire. However, on x86 CPUs, it is typically unnecessary to use _mm_lfence() as the hardware ensures load ordering without explicit barriers.

_mm_mfence()

_mm_mfence() is the most comprehensive memory barrier and establishes sequential consistency. It guarantees that all prior loads and stores become globally visible before any subsequent memory operations can execute. _mm_mfence() is primarily useful in specific scenarios, such as rolling your own implementation of C11/C 11 std::atomic or controlling the order of data stored to persistent memory.

C 11 std::atomic

In most cases, it is recommended to use C 11 std::atomic instead of manually implementing memory barriers. C 11 std::atomic provides high-level functions that ensure memory ordering and coherence without the need for explicit assembly code.

NT Stores and Performance

It is important to note that NT stores are designed for specific use cases and can impact performance. Store operations in general do not affect visible execution speed, as they get buffered in the CPU. However, in cases where data coherency and ordering are critical, NT stores, in combination with _mm_sfence(), can be used to ensure correct program behavior.

NT Stores and acquire/release Semantics

When using NT stores, _mm_sfence() provides release semantics, ensuring that subsequent operations in other threads become visible only after the NT store. Similarly, if the consumer thread employs an acquire semantics approach (e.g., memory_order_acquire), the _mm_sfence() ensures that all preceding NT stores become globally visible before the acquired data is accessed.

Barriers and Out-of-Order Execution

Memory barriers, including _mm_sfence(), _mm_lfence(), and _mm_mfence(), can affect out-of-order execution in modern CPUs. These CPUs attempt to execute instructions in parallel for increased efficiency. However, when a memory barrier is encountered, the CPU must ensure that all prior memory operations are complete before allowing subsequent operations to proceed, potentially diminishing performance gains from out-of-order execution.

The above is the detailed content of When should you use memory barrier functions in multithreaded code?. For more information, please follow other related articles on the PHP Chinese website!