Memory Model in C++ 11 - Coding

Memory Model is a specification that describes how the program interacts with the memory. In C++ 11, a standardized memory model is created to provide the solution to issues surrounding concurrency, ordering, and multithreading. This framework specifies how memory is accessed and arranged in a C++ program. In this article, we will discuss the C++ 11 memory model, its features, and advantages.

Need of Memory Model in C++

The main reason why the standardized memory model was introduced in C++ 11 was to provide consistent and predictable behavior in multithreading applications. It provides modern solutions to concurrency problems by providing features such as atomic operations, memory order, etc, and standardizes the memory handling for C++ abstract machine to improve cross-platform and compiler compatibility.

Features of C++ Memory Model

The main features of the C++ memory model are as follows:

Sequential Consistency
Atomic Operations
Memory Order

1. Atomic Operations

Atomic operations are the operations performed on the atomic object types. In C++, only atomic objects allows the concurrent read/write/access operation in multithreading application without causing any data races or undefined error. Atomics are defined inside <atomic> header.

Example

C++

// 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; 
}

Output

Counter value: 20000

2. Sequential Consistency

Sequential consistency is a high-level guarantee of the sequence of operations in several threads. It guarantees that the instructions in the program are executed in the same order as they are present in the source code.

Example

C++

// 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 
}

Output

res1: 0
res2: 1

3. Memory Ordering

Memory ordering refers to the order in which the read and write operations are preformed. We have five types of memory ordering in C++:

memory_order_relaxed
memory_order_consume
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_seq_cst

Example

C++

// 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; 
}

Output

x and y are both 1

Advantages of the Memory Model in C++

The standardized memory model provides the following advantages:

Cross Platform Compatibility: A defined set of guidelines for memory operations in a multithreaded context is provided by the C++11 memory model.Because of this standardization, C++ applications run consistently on many systems and with various compilers.
Concurrency: The memory model offers a clear set of guidelines for how memory is accessed and updated by various threads, which makes building proper and efficient concurrent programming easier.

Conclusion

Concurrent programming issues were resolved by the C++11 standard’s uniform memory model in C++. In a multithreaded environment, this model offers rules for allocating memory and coordinating memory operations. Its advantages include better concurrency support, more predictability, and greater portability.

Reffered: https://www.geeksforgeeks.org

C++

Related
Function Pointers and Callbacks in C++
Can We Access Local Variable's Memory Outside its Scope?
When to Use Virtual Destructors in C++?
How Do I Print a Double Value with Full Precision Using cout?
How to Sort User-Defined Types Using std::sort?

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	13