\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<\/pre>\n<\/td>\n\n\/\/ spinLock.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <thread><\/span>\r\n\r\nclass<\/span> Spinlock<\/span>{\r\n std::atomic_flag flag;\r\npublic:\r\n Spinlock(): flag(ATOMIC_FLAG_INIT) {}\r\n\r\n void<\/span> lock(){\r\n while<\/span>( flag.test_and_set() );\r\n }\r\n\r\n void<\/span> unlock(){\r\n flag.clear();\r\n }\r\n};\r\n\r\nSpinlock spin;\r\n\r\nvoid<\/span> workOnResource(){\r\n spin.lock();\r\n \/\/ shared resource<\/span>\r\n spin.unlock();\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n\r\n std::thread<\/span> t(workOnResource);\r\n std::thread<\/span> t2(workOnResource);\r\n\r\n t.join();\r\n t2.join();\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n <\/p>\n Threads t and t2 (lines 31 and 32) fight for the critical section. For simplicity reasons, the critical section in line 24 consists only of a comment. How does it work? The class Spinlock<\/span> has – similar to a mutex – the two methods lock<\/span> and unlock.<\/span> In addition, Spinlock’s constructor initializes in line 9 the std::atomic_flag<\/span> to false.<\/span> Two scenarios can happen if thread t wants to execute the function workOnResource.<\/p>\nFirst,<\/strong> the thread t gets the lock. So the lock invocation was successful. The lock invocation is successful if the initial value of the flag in line 12 is false.<\/span> In this case, thread t sets it in an atomic operation to true.<\/span> That value true<\/span> is the value the while loop returns to the other thread t2 if it tries to get the lock. So thread t2 is caught in the rat race. Thread t2 cannot set the value of the flag to false.<\/span> So t2 must eagerly wait until thread t1 executes the unlock<\/span> method and sets the flag to false<\/span> (lines 15 – 17).<\/p>\nSecond,<\/strong> the thread t don’t get the lock. So we are in scenario 1 with changed roles.<\/p>\nIt’s very interesting to compare a spinlock’s active waiting with a mutex’s passive waiting.<\/p>\n Spinlock versus Mutex<\/h2>\nWhat happens to the CPU load if the function workOnRessoucre<\/span> locks the spinlock for 2 seconds (lines 23 – 25)?<\/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<\/pre>\n<\/td>\n\n\/\/ spinLockSleep.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <thread><\/span>\r\n\r\nclass<\/span> Spinlock<\/span>{\r\n std::atomic_flag flag;\r\npublic:\r\n Spinlock(): flag(ATOMIC_FLAG_INIT) {}\r\n\r\n void<\/span> lock(){\r\n while<\/span>( flag.test_and_set() );\r\n }\r\n\r\n void<\/span> unlock(){\r\n flag.clear();\r\n }\r\n};\r\n\r\nSpinlock spin;\r\n\r\nvoid<\/span> workOnResource(){\r\n spin.lock();\r\n std::this_thread::sleep_for(std::chrono::milliseconds(2000));\r\n spin.unlock();\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n\r\n std::thread<\/span> t(workOnResource);\r\n std::thread<\/span> t2(workOnResource);\r\n\r\n t.join();\r\n t2.join();\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n <\/p>\n If the theory is right, one of the four cores of my PC must be fully utilized, precisely what you can see in the screenshot.<\/p>\n ![\"spinLockSleep\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/06\/spinLockSleep.png\") <\/p>\n <\/p>\n The screenshot shows nicely that the load of one core gets 100%. But my PC is fair. Each time a different core has to perform the busy waiting.<\/p>\n I use in the next concise program a mutex instead of a spinlock.<\/p>\n \n #include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nstd::mutex mut;\r\n\r\nvoid<\/span> workOnResource(){\r\n mut.lock();\r\n std::this_thread::sleep_for(std::chrono::milliseconds(5000));\r\n mut.unlock();\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n std::thread<\/span> t(workOnResource);\r\n std::thread<\/span> t2(workOnResource);\r\n\r\n t.join();\r\n t2.join();\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n Although I execute the program several times, I cannot observe a higher load of the cores.<\/p>\n <\/p>\n ![\"mutex\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/06\/mutex.png\") <\/p>\n
<\/p>\n What’s next?<\/h2>\nThe next post<\/a> will be about the class template std::atomic<\/span>. The various specializations for bools, integral types, and pointers provide a more powerful interface than std::atomic_flag.<\/span>(Proofreader Alexey Elymanov<\/strong>)<\/p>\n <\/p>\n <\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" Atomics guarantee two characteristics. On the one hand, they are atomic, on the other, they provide synchronization and order constraints on the program execution.<\/p>\n","protected":false},"author":21,"featured_media":4788,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[368],"tags":[434,519],"class_list":["post-4790","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-memory-model","tag-atomics","tag-sequential-consistency"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4790","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=4790"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4790\/revisions"}],"predecessor-version":[{"id":6970,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4790\/revisions\/6970"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4788"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4790"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4790"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4790"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}} | | | |