Why Don't Compilers Optimize Consecutive Redundant `std::atomic` Writes?

Why Compilers Don't Merge Consecutive Redundant std::atomic Writes

Question:

Why do compilers refrain from merging consecutive writes of the same value to a single atomic variable?

Answer:

While the C 11 / C 14 standards permit the folding of multiple stores into a single one, compilers do not implement this optimization due to:

Quality-of-Implementation Concerns

1. Progress Bar Issues:

Sinking and folding loop stores may result in a progress bar appearing stuck at zero until it jumps to 100% at the end, instead of displaying the progress incrementally.

2. Principle of Least Surprise:

Programmers expect each atomic store statement to have a separate memory operation, rather than being optimized away. This avoids unexpected behavior.

3. Limited Use Cases:

Compilers have determined that scenarios where this optimization would be beneficial, such as reducing unnecessary shared_ptr ref count operations, are rare.

Restrictions Imposed by the Standard

1. As-If Rule:

The as-if rule permits compilers to determine the ordering of memory operations, even if the source code indicates otherwise. This allows for internal optimizations that may alter the behavior of the program.

Future Developments

1. API Extensions:

Discussions within C working groups are underway to extend the std::atomic API to provide control over optimization behaviors, allowing compilers to optimize when appropriate.

2. Volatile Atomic Variables:

Using volatile atomic<int> ensures that stores to the variable cannot be optimized away, as accesses to volatile objects are not allowed to be removed from the code. However, this approach has its own limitations, as discussed in the provided answer.

The above is the detailed content of Why Don't Compilers Optimize Consecutive Redundant `std::atomic` Writes?. For more information, please follow other related articles on the PHP Chinese website!