{"id":4810,"date":"2016-07-09T20:59:28","date_gmt":"2016-07-09T20:59:28","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/memory-order-consume\/"},"modified":"2023-06-26T12:50:33","modified_gmt":"2023-06-26T12:50:33","slug":"memory-order-consume","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/memory-order-consume\/","title":{"rendered":"memory_order_consume"},"content":{"rendered":"

std::memory_order_consume<\/span> is the most legendary of the six memory models<\/a>. That’s for two reasons. On the one hand, std::memory_order_consume<\/span> is extremely hard to get. On the other hand – that may change in the future – no compiler supports it.<\/p>\n

<\/p>\n

 <\/p>\n

How can it happen that a compiler supports the C++11 standard but doesn’t support the memory model std::memory_order_consume<\/span>? The answer is that compiler maps std::memory_order_consume<\/span> to std::memory_order_acquire<\/span>. That is fine because both are load or acquire operations. std::memory_order_consume<\/span> requires weaker synchronization and ordering constraints<\/a>. So the release-acquire ordering is potentially slower than the release-consume ordering, but the crucial point is well-defined. <\/p>\n

To understand the release-consume ordering, it’s a good idea to compare it with the release-acquire ordering. I speak in the post explicitly from the release-acquire ordering and not from the acquire-release semantic<\/a> to emphasize the strong relationship of std::memory_order_consume<\/span> and std::memory_order_acquire<\/span>.<\/p>\n<\/p>\n

Release-acquire ordering<\/h2>\n

As a starting point, I use a program with two threads t1<\/span> and t2. t1<\/span> plays the role of the producer, t2<\/span> the role of the consumer. The atomic variable ptr<\/span> helps to synchronize the producer and consumer.<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39<\/pre>\n<\/td>\n
\n
\/\/ acquireRelease.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <thread><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n \r\nstd::atomic<std::string*> ptr;\r\nint<\/span> data;\r\nstd::atomic<int<\/span>> atoData;\r\n \r\nvoid<\/span> producer(){\r\n    std::string* p  = new<\/span> std::string(\"C++11\"<\/span>);\r\n    data = 2011;\r\n    atoData.store(2014,std::memory_order_relaxed);\r\n    ptr.store(p, std::memory_order_release);\r\n}\r\n \r\nvoid<\/span> consumer(){\r\n    std::string* p2;\r\n    while<\/span> (!(p2 = ptr.load(std::memory_order_acquire)));\r\n    std::cout << \"*p2: \"<\/span> << *p2 << std::endl;\r\n    std::cout << \"data: \"<\/span> << data << std::endl;\r\n    std::cout << \"atoData: \"<\/span> << atoData.load(std::memory_order_relaxed) << std::endl;\r\n}\r\n \r\nint<\/span> main(){\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    std::thread<\/span> t1(producer);\r\n    std::thread<\/span> t2(consumer);\r\n    \r\n    t1.join();\r\n    t2.join();\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
Before I analyze the program, I want to introduce a small variation. I replace in line 21 the memory model std::memory_order_acquire<\/span> with std::memory_order_consume<\/span>.<\/p>\n
Release-consume ordering<\/h2>\n
 <\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39<\/pre>\n<\/td>\n
\n
\/\/ acquireConsume.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <thread><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n \r\nstd::atomic<std::string*> ptr;\r\nint<\/span> data;\r\nstd::atomic<int<\/span>> atoData;\r\n \r\nvoid<\/span> producer(){\r\n    std::string* p  = new<\/span> std::string(\"C++11\"<\/span>);\r\n    data = 2011;\r\n    atoData.store(2014,std::memory_order_relaxed);\r\n    ptr.store(p, std::memory_order_release);\r\n}\r\n \r\nvoid<\/span> consumer(){\r\n    std::string* p2;\r\n    while<\/span> (!(p2 = ptr.load(std::memory_order_consume)));\r\n    std::cout << \"*p2: \"<\/span> << *p2 << std::endl;\r\n    std::cout << \"data: \"<\/span> << data << std::endl;\r\n    std::cout << \"atoData: \"<\/span> << atoData.load(std::memory_order_relaxed) << std::endl;\r\n}\r\n \r\nint<\/span> main(){\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    std::thread<\/span> t1(producer);\r\n    std::thread<\/span> t2(consumer);\r\n    \r\n    t1.join();\r\n    t2.join();\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
That was easy. But now, the program has undefined behavior. That statement is very hypothetical because my compiler implements std::memory_order_consume<\/span> by std::memory_order_acquire.<\/span> So under the hood, both program does the same.<\/p>\n
Release-acquire versus Release-consume ordering<\/h2>\n
The output of the programs is identical.<\/p>\n
 \"acquireReleaseConsume\"<\/p>\n
Although I repeat myself, I want to sketch in a few words why the first program acquireRelease.cpp<\/span> is well defined.<\/p>\n
The store operation in line 16 synchronizes-with the load operation in line 21. The reason is, that the store operation uses std::memory_order_release<\/span>, and the load operation uses std::memory_order_acquire<\/span>. That was the synchronization. What about the ordering constraints of the release-acquire ordering? The release-acquire ordering guarantees that all operations before the store operation (line 16) are available after the load operation (line 21). So the release-acquire operation orders, in addition to the access on the non-atomic variable data<\/span> (line 14) and the atomic variable atoData<\/span> (line 15). That holds, although atoData<\/span> uses the std::memory_order_relaxed memory model.<\/p>\n
The key question is. What happens if I replace the program std::memory_order_acquire<\/span> with std::memory_order_consume<\/span>?<\/p>\n
Data dependencies with std::memory_order_consume<\/h3>\n
The std::memory_order_consume<\/span> is about data dependencies on atomics. Data dependencies exist in two ways, at first carries-a-dependency-to<\/em> in a thread and dependency-ordered_before<\/em> between two threads. Both dependencies introduce a happens-before<\/em> relation. That is the kind of relation a well-defined program needs.  But what means carries-a-dependency-to<\/em> and dependency-order-before<\/em>?<\/p>\n