Memory Model in C++ 11

// C++ program to illustrate the concept of an atomic
// operation using std::atomic.
#include <atomic>
#include <iostream>
#include <thread>

using namespace std;

// Atomic variable to ensure atomic operations
atomic<int> counter(0);

// Function to increment the counter in a loop
void incrementCounter()
{
    for (int i = 0; i < 10000; ++i) {
        counter.fetch_add(1, memory_order_relaxed);
        // Increment the counter atomically using fetch_add
        // memory_order_relaxed is used for minimal
        // synchronization overhead
    }
}

// driver code
int main()
{
    // Create a thread for incrementing the counter
    thread t1(incrementCounter);
    // Create another thread for incrementing the counter
    thread t2(incrementCounter);

    t1.join(); // Wait for the first thread to finish
    t2.join(); // Wait for the second thread to finish

    // Print the final value of the counter after both
    // threads have finished
    cout << "Counter value: "
         << counter.load(memory_order_relaxed) << endl;

    return 0;
}

// C++ program to illustrate the sequential consistency
#include <atomic>
#include <iostream>
#include <thread>
using namespace std;

// Declare atomic integers x and y, initialize them to 0
atomic<int> x(0), y(0);

// Declare integers res1 and res2 to store results
int res1, res2;

// first thread callable
void thread1()
{
    // Store 1 in x with sequential consistency
    x.store(1, memory_order_seq_cst);
    // Load the value of y into res1 with sequential
    // consistency
    res1 = y.load(memory_order_seq_cst);
}

// Define the function for the second thread
void thread2()
{
    // Store 1 in y with sequential consistency
    y.store(1, memory_order_seq_cst);
    // Load the value of x into res2 with sequential
    // consistency
    res2 = x.load(memory_order_seq_cst);
}

// Main function
int main()
{
    // Create two threads t1 and t2
    thread t1(thread1);
    thread t2(thread2);

    // Wait for both threads to finish
    t1.join();
    t2.join();

    cout << "res1: " << res1 << endl;
    cout << "res2: " << res2 << endl;
    // Possible outcomes: res1 == 1 && res2 == 1, res1 == 0
    // && res2 == 1, res1 == 1 && res2 == 0 It is not
    // possible for both res1 and res2 to be 0, as this
    // would violate the sequential consistency
}

// C++ program to illustrate the concept of memory ordering.
#include <atomic>
#include <iostream>
#include <thread>
using namespace std;

atomic<int> x(0);
atomic<int> y(0);

// Function to write values to x and y with relaxed memory
// ordering
void wr()
{
    x.store(1, memory_order_relaxed);
    y.store(1, memory_order_relaxed);
}

// Function to read values from x and y with relaxed memory
// ordering
void rd()
{
    while (y.load(memory_order_relaxed) != 1) {
        // Spin until y is written by the other thread
        // Memory_order_relaxed is used for minimal
        // synchronization overhead
    }
    if (x.load(memory_order_relaxed) == 1) {
        // Check if both x and y are 1
        cout << "x and y are both 1" << endl;
    }
}

int main()
{
    thread t1(wr); // Create a thread for writing values
    thread t2(rd); // Create a thread for reading values

    t1.join(); // Wait for the writing thread to finish
    t2.join(); // Wait for the reading thread to finish

    return 0;
}