{"id":6050,"date":"2020-12-08T19:56:33","date_gmt":"2020-12-08T19:56:33","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/atomic-ref\/"},"modified":"2023-06-26T09:36:07","modified_gmt":"2023-06-26T09:36:07","slug":"atomic-ref","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/atomic-ref\/","title":{"rendered":"Atomic References with C++20"},"content":{"rendered":"

Atomics receives a few essential extensions in C++20. Today, I start with the new data type std::atomic_ref.<\/code><\/p>\n

<\/p>\n

 \"TimelineCpp20CoreLanguage\"<\/p>\n

The type std::atomic_ref<\/code> applies atomic operations to its referenced object.<\/p>\n

<\/span>std::atomic_ref<\/code><\/span><\/h2>\n

Concurrent writing and reading using a std::atomic_ref<\/code> is no data race. The lifetime of the referenced object must exceed the lifetime of the std::atomic_ref<\/code>. Accessing a subobject of the referenced object with a std::atomic_ref<\/code> is not well-defined.<\/p>\n

<\/span>Motivation<\/span><\/h3>\n

You may think using a reference inside an atomic would do the job. Unfortunately not.<\/p>\n

In the following program, I have a class ExpensiveToCopy<\/code>, which includes a counter<\/code>. The counter<\/code> is concurrently incremented by a few threads. Consequently, counter<\/code> has to be protected.<\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/ atomicReference.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <vector><\/span>\r\n\r\nstruct<\/span> ExpensiveToCopy {\r\n    int<\/span> counter{};\r\n};\r\n \r\nint<\/span> getRandom<\/span>(int<\/span> begin, int<\/span> end) {            \/\/ (6)<\/span>\r\n\r\n    std::<\/span>random_device seed;        \/\/ initial seed<\/span>\r\n    std::<\/span>mt19937 engine(seed());    \/\/ generator<\/span>\r\n    std::<\/span>uniform_int_distribution<><\/span> uniformDist(begin, end);\r\n\r\n    return<\/span> uniformDist(engine);\r\n}\r\n \r\nvoid<\/span> count<\/span>(ExpensiveToCopy&<\/span> exp) {                      \/\/ (2)<\/span>\r\n    \r\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> v;\r\n    std::<\/span>atomic<<\/span>int<\/span>><\/span> counter{exp.counter};              \/\/ (3)<\/span>\r\n    \r\n    for<\/span> (int<\/span> n =<\/span> 0<\/span>; n <<\/span> 10<\/span>; ++<\/span>n) {                      \/\/ (4)<\/span>\r\n        v.emplace_back([&<\/span>counter] {\r\n            auto<\/span> randomNumber =<\/span> getRandom(100<\/span>, 200<\/span>);    \/\/ (5)<\/span>\r\n            for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> randomNumber; ++<\/span>i) { ++<\/span>counter; }\r\n        });\r\n    }\r\n    \r\n    for<\/span> (auto<\/span>&<\/span> t :<\/span> v) t.join();\r\n\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    ExpensiveToCopy exp;              \/\/ (1)<\/span>\r\n    count(exp);\r\n    std::<\/span>cout <<<\/span> \"exp.counter: \"<\/span> <<<\/span> exp.counter <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
exp<\/code> (1) is the expensive-to-copy object. For performance reasons, the function count<\/code> (2) takes exp<\/code> by reference. count<\/code> initializes the std::atomic<int><\/code> with exp.counter (<\/code>3). The following lines create ten threads (4), each performing the lambda expression, which takes counter<\/code> by reference. The lambda expression gets a random number between 100 and 200 (5) and increments the counter exactly as often. The function getRandom<\/code> (6) start with an initial seed and create a uniformly distributed number via the random number generator Mersenne Twister.<\/p>\n
In the end, the exp.counter<\/code> (7) should have an approximate value of 1500 because the ten threads increment on average 150 times. Executing the program on the Wandbox <\/a>online compiler gave me a surprising result.<\/p>\n
 <\/p>\n
\"atomicReference\"<\/p>\n
The counter is 0. What is happening? The issue is in line (3). The initialization in the expression std::atomic<int> counter{exp.counter}<\/code> creates a copy. The following small program exemplifies the issue.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ atomicRefCopy.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    int<\/span> val{5<\/span>};\r\n    int<\/span>&<\/span> ref =<\/span> val;                     \/\/ (2)<\/span>\r\n    std::<\/span>atomic<<\/span>int<\/span>><\/span> atomicRef(ref);\r\n    ++<\/span>atomicRef;                        \/\/ (1)<\/span>\r\n    std::<\/span>cout <<<\/span> \"ref: \"<\/span> <<<\/span> ref <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"atomicRef.load(): \"<\/span> <<<\/span> atomicRef.load() <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The increment operation (1) does not address the reference ref<\/code> (2). The value of ref<\/code> is not changed.<\/p>\n
\"atomicRefCopy\"<\/p>\n
 <\/p>\n
Replacing the std::atomic<int> counter{exp.counter}<\/code> with std::atomic_ref<int> counter{exp.counter<\/code>} solves the issue:<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ atomicReference.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <vector><\/span>\r\n\r\nstruct<\/span> ExpensiveToCopy {\r\n    int<\/span> counter{};\r\n};\r\n \r\nint<\/span> getRandom<\/span>(int<\/span> begin, int<\/span> end) {\r\n\r\n    std::<\/span>random_device seed;        \/\/ initial randomness<\/span>\r\n    std::<\/span>mt19937 engine(seed());    \/\/ generator<\/span>\r\n    std::<\/span>uniform_int_distribution<><\/span> uniformDist(begin, end);\r\n\r\n    return<\/span> uniformDist(engine);\r\n}\r\n \r\nvoid<\/span> count<\/span>(ExpensiveToCopy&<\/span> exp) {\r\n    \r\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> v;\r\n    std::<\/span>atomic_ref<<\/span>int<\/span>><\/span> counter{exp.counter};\r\n    \r\n    for<\/span> (int<\/span> n =<\/span> 0<\/span>; n <<\/span> 10<\/span>; ++<\/span>n) {\r\n        v.emplace_back([&<\/span>counter] {\r\n            auto<\/span> randomNumber =<\/span> getRandom(100<\/span>, 200<\/span>);\r\n            for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> randomNumber; ++<\/span>i) { ++<\/span>counter; }\r\n        });\r\n    }\r\n    \r\n    for<\/span> (auto<\/span>&<\/span> t :<\/span> v) t.join();\r\n\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    ExpensiveToCopy exp;\r\n    count(exp);\r\n    std::<\/span>cout <<<\/span> \"exp.counter: \"<\/span> <<<\/span> exp.counter <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, the value of counter<\/code> is as expected:<\/p>\n
\"atomicRef\"<\/p>\n
<\/span>To be Atomic or Not to be Atomic<\/span><\/h3>\n
You may ask me why I didn’t make the counter atomic in the first place:<\/p>\n
 <\/p>\n
<\/p>\n
\n
struct<\/span> ExpensiveToCopy {\r\n    std::<\/span>atomic<<\/span>int<\/span>><\/span> counter{};\r\n};\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Of course, this is a valid approach, but this approach has a significant downside. Each access to the counter is synchronized, and synchronization is not for free. On the contrary, using a std::atomic_ref<int> counter<\/code> lets you explicitly control when you need atomic access to the counter. Most of the time, you may only want to read the value of the counter. Consequently, defining it as an atomic is pessimization.<\/p>\n
Let me conclude my post with a few more details about the class template std::atomic_ref<\/code>.<\/p>\n<\/p>\n
<\/span>Specializations of std::atomic_ref<\/code><\/span><\/h2>\n
You can specialize std::atomic_ref<\/code> for user-defined types, use partial specializations for pointer types or full specializations for arithmetic types such as integral or floating-point types.<\/p>\n
<\/span>Primary Template<\/span><\/h3>\n
The primary template std::atomic_ref<\/code> can be instantiated with a trivially copyable<\/a> type T. Trivially copyable types are either scalar types (arithmetic types, enum'<\/code>s, pointers, member pointers, or std::nullptr_t<\/code>‘s), or trivially copyable classes and arrays of scalar types<\/p>\n
<\/span>Partial Specializations for Pointer Types<\/span><\/h3>\n
The standard provides partial specializations for a pointer type: std::atomic_ref<t*><\/code>.<\/p>\n
<\/span>Specializations for Arithmetic Types<\/span><\/h3>\n
The standard provides specialization for the integral and floating-point types: std::atomic_ref<arithmetic type><\/code>.<\/p>\n