What are some examples of memory ordering in C++?

Can you explain memory ordering in C++ with some examples?

Sure! Memory ordering in C++ refers to the rules that determine how operations on shared variables are seen by different threads. For example, using atomic operations can help ensure that changes made by one thread are visible to others.

What are some specific examples of memory ordering?

One example is using std::atomic with memory orderings like memory_order_relaxed, memory_order_acquire, and memory_order_release. These specify how operations are ordered with respect to other operations.

Can you give a code example using these memory orderings?

Certainly! Here's a simple example:

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter.load(std::memory_order_relaxed) << std::endl;
}

This code increments a counter from two threads using relaxed memory ordering.

What happens if I use a different memory order?

Using a stronger memory order, like memory_order_seq_cst, would ensure a total order of operations, which can prevent certain types of bugs but may also reduce performance due to increased synchronization.