{"id":4942,"date":"2016-09-07T19:36:31","date_gmt":"2016-09-07T19:36:31","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/multithreaded-summation-with-minimal-synchronization\/"},"modified":"2023-06-26T12:43:40","modified_gmt":"2023-06-26T12:43:40","slug":"multithreaded-summation-with-minimal-synchronization","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/multithreaded-summation-with-minimal-synchronization\/","title":{"rendered":"Multithreaded: Summation with Minimal Synchronization"},"content":{"rendered":"

Until now, I’ve used two strategies to summate a std::vector. <\/span>First, I did the whole math in one thread (Single Threaded: Summation of a vector<\/a>); second multiple threads shared the same variable for the result (Multithreaded: Summation of a vector<\/a>). In particular, the second strategy was extremely naive. In this post, I will apply my knowledge of both posts. My goal is that the thread will perform their summation as independently from each other as possible and therefore reduce the synchronization overhead. <\/p>\n

<\/p>\n

 <\/p>\n

To let the threads work independently and therefore minimize the synchronization, I have a few ideas in my mind. Local variables, thread-local data <\/a>but also tasks<\/a> should work. Now I’m curious.<\/p>\n<\/p>\n

<\/span>My strategy<\/span><\/h2>\n

My strategy keeps the same. As in my last post, I use my desktop PC with four cores and GCC and my laptop with two cores and cl.exe. I provide the results without and with maximum optimization. For the details, look here: Thread-safe initialization of a singleton.<\/a> <\/p>\n

<\/span>Local variables<\/span><\/h2>\n

Since each thread has a local summation variable, it can do its job without synchronization. It’s only necessary to sum up the local summation variables. Adding the local results is a critical section that must be protected. This can be done in various ways. A quick remark before. Since only four addition takes place, it doesn’t matter so much from a performance perspective which synchronization I will use. But instead of my remark, I will use a std::lock_guard<\/span> and an atomic with sequential consistency and relaxed semantics.<\/p>\n

<\/span>std::lock_guard<\/span><\/h3>\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\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59<\/pre>\n<\/td>\n
\n
\/\/ localVariable.cpp<\/span>\r\n\r\n#include <mutex><\/span>\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long<\/span> long<\/span> size= 100000000;   \r\n\r\nconstexpr long<\/span> long<\/span> firBound=  25000000;\r\nconstexpr long<\/span> long<\/span> secBound=  50000000;\r\nconstexpr long<\/span> long<\/span> thiBound=  75000000;\r\nconstexpr long<\/span> long<\/span> fouBound= 100000000;\r\n\r\nstd::mutex myMutex;\r\n\r\nvoid<\/span> sumUp(unsigned<\/span> long<\/span> long<\/span>& sum, const<\/span> std::vector<int<\/span>>& val, unsigned<\/span> long<\/span> long<\/span> beg, unsigned<\/span> long<\/span> long<\/span> end){\r\n    unsigned<\/span> long<\/span> long<\/span> tmpSum{};\r\n    for<\/span> (auto<\/span> i= beg; i < end; ++i){\r\n        tmpSum += val[i];\r\n    }\r\n    std::lock_guard<std::mutex> lockGuard(myMutex);\r\n    sum+= tmpSum;\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::vector<int<\/span>> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::mt19937 engine;\r\n  std::uniform_int_distribution<> uniformDist(1,10);\r\n  for<\/span> ( long<\/span> long<\/span> i=0 ; i< size ; ++i) randValues.push_back(uniformDist(engine));\r\n \r\n  unsigned<\/span> long<\/span> long<\/span> sum{}; \r\n  auto<\/span> start = std::chrono::system_clock::now();\r\n  \r\n  std::thread<\/span> t1(sumUp,std::ref(sum),std::ref(randValues),0,firBound);\r\n  std::thread<\/span> t2(sumUp,std::ref(sum),std::ref(randValues),firBound,secBound);\r\n  std::thread<\/span> t3(sumUp,std::ref(sum),std::ref(randValues),secBound,thiBound);\r\n  std::thread<\/span> t4(sumUp,std::ref(sum),std::ref(randValues),thiBound,fouBound);   \r\n  \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n  \r\n  std::chrono::duration<double<\/span>> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"Time for addition \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n  std::cout << \"Result: \"<\/span> << sum << std::endl;\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
Lines 25 and 26 are critical lines. Here the local summation results tmpSum<\/span> will be added to the global sum.<\/span> What is the spot at which the examples with the local variables will vary?<\/p>\n
<\/span>Without optimization<\/span><\/h3>\n
\"localVariable\"\"localVariablewin\"<\/p>\n
<\/span>Maximum optimization<\/span><\/h3>\n
\"localVariableOpt\"\"localVariableOptwin\"<\/p>\n
<\/span>Atomic operations with sequential consistency<\/span><\/h2>\n
My first optimization is it to replace the by a std::lock_guard<\/span> protected global summation sum<\/span> variable with an atomic.<\/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\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56<\/pre>\n<\/td>\n
\n
\/\/ localVariableAtomic.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long<\/span> long<\/span> size= 100000000;   \r\n\r\nconstexpr long<\/span> long<\/span> firBound=  25000000;\r\nconstexpr long<\/span> long<\/span> secBound=  50000000;\r\nconstexpr long<\/span> long<\/span> thiBound=  75000000;\r\nconstexpr long<\/span> long<\/span> fouBound= 100000000;\r\n\r\nvoid<\/span> sumUp(std::atomic<unsigned<\/span> long<\/span> long<\/span>>& sum, const<\/span> std::vector<int<\/span>>& val, unsigned<\/span> long<\/span> long<\/span> beg, unsigned<\/span> long<\/span> long<\/span> end){\r\n    unsigned<\/span> int<\/span> long<\/span> long<\/span> tmpSum{};\r\n    for<\/span> (auto<\/span> i= beg; i < end; ++i){\r\n\t    tmpSum += val[i];\r\n    }\r\n    sum+= tmpSum;\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::vector<int<\/span>> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::mt19937 engine;\r\n  std::uniform_int_distribution<> uniformDist(1,10);\r\n  for<\/span> ( long<\/span> long<\/span> i=0 ; i< size ; ++i) randValues.push_back(uniformDist(engine));\r\n \r\n  std::atomic<unsigned<\/span> long<\/span> long<\/span>> sum{}; \r\n  auto<\/span> start = std::chrono::system_clock::now();\r\n  \r\n  std::thread<\/span> t1(sumUp,std::ref(sum),std::ref(randValues),0,firBound);\r\n  std::thread<\/span> t2(sumUp,std::ref(sum),std::ref(randValues),firBound,secBound);\r\n  std::thread<\/span> t3(sumUp,std::ref(sum),std::ref(randValues),secBound,thiBound);\r\n  std::thread<\/span> t4(sumUp,std::ref(sum),std::ref(randValues),thiBound,fouBound);   \r\n  \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n  \r\n  std::chrono::duration<double<\/span>> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"Time for addition \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n  std::cout << \"Result: \"<\/span> << sum << std::endl;\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
<\/span>Without optimization<\/span><\/h3>\n
\"localVariableAtomic\"\"localVariableAtomicwin\"<\/p>\n
<\/span>Maximum optimization<\/span><\/h3>\n
<\/span> \"localVariableAtomicOpt\"\"localVariableAtomicOptwin\"<\/span><\/h2>\n
<\/span>Atomic operations with relaxed semantic<\/span><\/h2>\n
We can do better. Instead of the default memory model of sequential consistency, I use relaxed semantics. That’s well-defined because it doesn’t matter in which order the additions in line 23 take place.<\/p>\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\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56<\/pre>\n<\/td>\n
\n
\/\/ localVariableAtomicRelaxed.cpp\r\n\r\n#include <atomic><\/span>\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long long size= 100000000;   \r\n\r\nconstexpr long long firBound=  25000000;\r\nconstexpr long long secBound=  50000000;\r\nconstexpr long long thiBound=  75000000;\r\nconstexpr long long fouBound= 100000000;\r\n\r\nvoid sumUp(std::atomic<unsigned long long>& sum, const std::vector<int>& val, unsigned long long beg, unsigned long long end){\r\n    unsigned int long long tmpSum{};\r\n    for<\/span> (auto i= beg; i < end; ++i){\r\n\t    tmpSum += val[i];\r\n    }\r\n    sum.fetch_add(tmpSum,std::memory_order_relaxed);\r\n}\r\n\r\nint main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::vector<int> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::mt19937 engine;\r\n  std::uniform_int_distribution<> uniformDist(1,10);\r\n  for<\/span> ( long long i=0 ; i< size ; ++i) randValues.push_back(uniformDist(engine));\r\n \r\n  std::atomic<unsigned long long> sum{}; \r\n  auto start = std::chrono::system_clock::now();\r\n  \r\n  std::thread t1(sumUp,std::ref(sum),std::ref(randValues),0,firBound);\r\n  std::thread t2(sumUp,std::ref(sum),std::ref(randValues),firBound,secBound);\r\n  std::thread t3(sumUp,std::ref(sum),std::ref(randValues),secBound,thiBound);\r\n  std::thread t4(sumUp,std::ref(sum),std::ref(randValues),thiBound,fouBound);   \r\n  \r\n \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n  std::chrono::duration<double> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"Time for addition \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n  std::cout << \"Result: \"<\/span> << sum << std::endl;\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
<\/span>Without optimization<\/span><\/h3>\n
\"localVariableAtomicRelaxed\"\"localVariableAtomicRelaxedwin\"<\/p>\n
<\/span>Maximum optimization<\/span><\/h3>\n
\"localVariableAtomicRelaxedOpt\"\"localVariableAtomicRelaxedOptwin\"<\/p>\n
The following strategy is similar. But now I use thread local data.<\/p>\n
<\/span>Thread local data<\/span><\/h2>\n
Thread local data<\/a> is data that each thread exclusively owns. They will be created when needed. Therefore, thread local data perfectly fit the local summation variable tmpSum<\/span>.<\/p>\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\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57<\/pre>\n<\/td>\n
\n
\/\/ threadLocal.cpp\r\n\r\n#include <atomic><\/span>\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long long size= 100000000;   \r\n\r\nconstexpr long long firBound=  25000000;\r\nconstexpr long long secBound=  50000000;\r\nconstexpr long long thiBound=  75000000;\r\nconstexpr long long fouBound= 100000000;\r\n\r\nthread_local unsigned long long tmpSum= 0;\r\n\r\nvoid sumUp(std::atomic<unsigned long long>& sum, const std::vector<int>& val, unsigned long long beg, unsigned long long end){\r\n    for<\/span> (auto i= beg; i < end; ++i){\r\n        tmpSum += val[i];\r\n    }\r\n    sum.fetch_add(tmpSum,std::memory_order_relaxed);\r\n}\r\n\r\nint main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::vector<int> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::mt19937 engine;\r\n  std::uniform_int_distribution<> uniformDist(1,10);\r\n  for<\/span> ( long long i=0 ; i< size ; ++i) randValues.push_back(uniformDist(engine));\r\n \r\n  std::atomic<unsigned long long> sum{}; \r\n  auto start = std::chrono::system_clock::now();\r\n  \r\n  std::thread t1(sumUp,std::ref(sum),std::ref(randValues),0,firBound);\r\n  std::thread t2(sumUp,std::ref(sum),std::ref(randValues),firBound,secBound);\r\n  std::thread t3(sumUp,std::ref(sum),std::ref(randValues),secBound,thiBound);\r\n  std::thread t4(sumUp,std::ref(sum),std::ref(randValues),thiBound,fouBound);   \r\n  \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n  \r\n  std::chrono::duration<double> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"Time for addition \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n  std::cout << \"Result: \"<\/span> << sum << std::endl;\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
I declare in line 18 the thread-local variable tmpSum<\/span> and use it for the addition in lines 22 and 24. The small difference between the thread-local variable and the local variable in the previous programs is that the thread-local variable’s lifetime is bound to its thread’s lifetime. The lifetime of the local variable depends on its scope.<\/p>\n
<\/span>Without optimization<\/span><\/h3>\n
\"threadLocal\"\"threadLocalwin\"<\/h3>\n
<\/span>Maximum optimization<\/span><\/h3>\n
\"threadLocalOpt\"\"threadLocalOptwin\"<\/p>\n
The question is. Is it possible to calculate the sum in a fast way without synchronization? Yes.<\/p>\n
<\/span>Tasks<\/span><\/h2>\n
With task, <\/a>we can do the whole job without synchronization. Each summation is performed in a separate thread and the final summation is in a single thread. Here are the details of tasks.<\/a> I will use promise and future in the following program.<\/p>\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\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67\r\n68<\/pre>\n<\/td>\n
\n
\/\/ tasks.cpp\r\n\r\n#include <chrono><\/span>\r\n#include <future><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long long size= 100000000;   \r\n\r\nconstexpr long long firBound=  25000000;\r\nconstexpr long long secBound=  50000000;\r\nconstexpr long long thiBound=  75000000;\r\nconstexpr long long fouBound= 100000000;\r\n\r\nvoid sumUp(std::promise<unsigned long long>&& prom, const std::vector<int>& val, unsigned long long beg, unsigned long long end){\r\n\tunsigned long long sum={};\r\n\tfor<\/span> (auto i= beg; i < end; ++i){\r\n\t    sum += val[i];\r\n    }\r\n    prom.set_value(sum);\r\n}\r\n\r\nint main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::vector<int> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::mt19937 engine;\r\n  std::uniform_int_distribution<> uniformDist(1,10);\r\n  for<\/span> ( long long i=0 ; i< size ; ++i) randValues.push_back(uniformDist(engine));\r\n \r\n  std::promise<unsigned long long> prom1;\r\n  std::promise<unsigned long long> prom2;\r\n  std::promise<unsigned long long> prom3;\r\n  std::promise<unsigned long long> prom4;\r\n  \r\n  auto fut1= prom1.get_future();\r\n  auto fut2= prom2.get_future();\r\n  auto fut3= prom3.get_future();\r\n  auto fut4= prom4.get_future();\r\n  \r\n  \r\n  auto start = std::chrono::system_clock::now();\r\n\r\n  std::thread t1(sumUp,std::move(prom1),std::ref(randValues),0,firBound);\r\n  std::thread t2(sumUp,std::move(prom2),std::ref(randValues),firBound,secBound);\r\n  std::thread t3(sumUp,std::move(prom3),std::ref(randValues),secBound,thiBound);\r\n  std::thread t4(sumUp,std::move(prom4),std::ref(randValues),thiBound,fouBound);\r\n  \r\n  auto sum= fut1.get() + fut2.get() + fut3.get() + fut4.get();\r\n \r\n  std::chrono::duration<double> dur= std::chrono::system_clock::now() - start;\r\n  std::cout << \"Time for addition \"<\/span> << dur.count() << \" seconds\"<\/span> << std::endl;\r\n  std::cout << \"Result: \"<\/span> << sum << std::endl;\r\n  \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.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
I define in lines 37 – 45 the four promises and create from them the associated futures. Each promise is moved in lines 50 – 52 in a separate thread. A promise can only be moved; therefore, I use std::move<\/span>. The work package of the thread is the function sumUp (lines 18 – 24). sumUp takes as the first argument a promise by rvalue reference. The futures ask in line 55 for the results. The get<\/span> call is blocking. <\/p>\n
<\/span>Without optimization<\/span><\/h3>\n
\"tasks\"\"taskswin\"<\/p>\n
<\/span>Maximum optimization<\/span><\/h3>\n
\"tasksOpt\"\"tasksOptwin\"<\/p>\n
All numbers in the overview<\/p>\n
<\/span>The overview<\/span><\/h2>\n
As previously mentioned, the numbers are quite similar for Linux. That’s no surprise because I always use the same strategy: Calculate the partial sum locally without synchronization and add the local sums. The addition of the partial sums has to be synchronized. What astonished me was that maximum optimization makes no significant difference. <\/p>\n
On Windows, the story is different. First, it makes a big difference if I compile the program with maximum or without optimization; second, Windows is much slower than Linux. I’m unsure if that is since Windows has only two cores but Linux 4.<\/p>\n
 \"MultipleThreadsEng\"<\/p>\n
<\/span>What’s next?<\/span><\/h2>\n
I will reason in the next post <\/a>about the numbers for summing up a vector and the results that can be derived from it.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Until now, I’ve used two strategies to summate a std::vector. First, I did the whole math in one thread (Single Threaded: Summation of a vector); second multiple threads shared the same variable for the result (Multithreaded: Summation of a vector). In particular, the second strategy was extremely naive. In this post, I will apply my […]<\/p>\n","protected":false},"author":21,"featured_media":4922,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[369],"tags":[434,470,504,519,446,487],"class_list":["post-4942","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-application","tag-atomics","tag-performance","tag-relaxed-semantics","tag-sequential-consistency","tag-tasks","tag-thread_local"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4942","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=4942"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4942\/revisions"}],"predecessor-version":[{"id":6949,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4942\/revisions\/6949"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4922"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4942"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4942"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4942"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}