Why Don't Compilers Merge Consecutive Atomic Writes?

Redundant Atomic Writes Optimization

Why do compilers refrain from merging consecutive writes of the same value to a single atomic variable? Let's delve into this issue and uncover the underlying reasons.

The "As-If" Rule

According to the C standards, compilers are permitted to coalesce multiple atomic writes into a single operation. Even when these writes involve different values, the resulting behavior is still allowed to adhere to the "as-if" rule. This rule implies that the execution of the optimized code has the same observable effects as the original sequence of writes.

Compiler Behavior vs. Hardware Constraints

Despite being theoretically possible, compilers generally do not perform this optimization in practice. The primary reason for this is to avoid undesirable effects on performance and behavior when targeting real hardware.

Progress Bars and Other Examples

Consider the example of a progress bar. Optimizing multiple atomic writes to a single operation could lead to a situation where the progress bar stays at 0 and then abruptly jumps to 100%, potentially misleading users. Other scenarios where such optimization would be problematic include avoiding useless shared_ptr ref count increments and decrements in a loop.

Principle of Least Surprise

Programmers expect atomic writes to manifest in memory for every source store operation. Coalescing multiple writes violates this expectation, leading to potential confusion and incorrect behavior.

Quality-of-Implementation Issues

Compilers have difficulty determining when it is safe to optimize atomic writes without violating ordering rules and affecting other aspects of the program.

Future Optimizations and API Extensions

Discussions are ongoing within the C working group to extend the std::atomic API and provide programmers with finer control over optimization. This will enable compilers to perform optimizations where appropriate while ensuring the integrity and clarity of program behavior.

In the meantime, using volatile atomic<> or considering alternative implementations, such as shared_ptr_unsynchronized<>, can help avoid undesired optimization effects.

The above is the detailed content of Why Don't Compilers Merge Consecutive Atomic Writes?. For more information, please follow other related articles on the PHP Chinese website!