{"id":5200,"date":"2017-02-25T05:47:28","date_gmt":"2017-02-25T05:47:28","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/latches-and-barriers\/"},"modified":"2023-06-26T12:21:29","modified_gmt":"2023-06-26T12:21:29","slug":"latches-and-barriers","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/latches-and-barriers\/","title":{"rendered":"Latches And Barriers"},"content":{"rendered":"

Latches and barriers are simple thread synchronization mechanisms, enabling some threads to wait until a counter becomes zero. We will, presumably in C++20, get latches and barriers in three variations: std::latch,<\/span> std::barrier<\/span>, and std::flex_barrier.<\/span><\/p>\n

<\/p>\n

 <\/p>\n

\"TimelineCpp20\"<\/p>\n

First, there are two questions:<\/p>\n

    \n
  1. What are the differences between these three mechanisms to synchronize threads? You can use a std::latch <\/span>only once, but you can use a std::barrier<\/span> and a std::flex_barrier<\/span> more than once. Additionally,  a std::flex_barrier<\/span> enables you to execute a function when the counter becomes zero.<\/li>\n
  2. What use cases do latches and barriers support that can not be done in C++11 and C++14 with futures, threads, or condition variables in combinations with locks? Latches and barriers provide no new use cases, but they are much easier to use. They are also more performant because they often use a lock-free mechanism internally.<\/li>\n<\/ol>\n

    Now, I will have a closer look at the three coordination mechanisms. <\/em>
    <\/em><\/p>\n<\/p>\n

    std::latch<\/h2>\n

    std::latch<\/span> is a counter that counts down. Its value is set in the constructor. A thread can decrement the counter by using the method<\/span> thread.count_down_and_wait<\/strong><\/span> and wait until the counter becomes zero. In addition, the method thread.count_down<\/strong><\/span> only decreases the counter by one without waiting. std::latch<\/span> has further the method <\/span>thread.is_ready<\/strong><\/span> to test if the counter is zero, and it has the method thread.wait<\/span> <\/strong>to wait until the counter becomes zero. <\/span>You cannot increment or reset the counter of a std::latch. Hence<\/span> you can not reuse it. <\/p>\n

    For further details to std::latch<\/span> read the documentation on <\/span>cppreference.com<\/a>.<\/p>\n

    <\/span>Here is a short code snippet from proposal n4204<\/a>.<\/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<\/pre>\n<\/td>\n
    		\n
    void<\/span> DoWork(threadpool* pool) {\r\n    latch completion_latch(NTASKS);\r\n    for<\/span> (int<\/span> i = 0; i < NTASKS; ++i) {\r\n      pool->add_task([&] {\r\n        \/\/ perform work<\/span>\r\n        ...\r\n        completion_latch.count_down();\r\n      }));\r\n    }\r\n    \/\/ Block until work is done<\/span>\r\n    completion_latch.wait();\r\n  }\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    I set the std::latch completion_latch<\/span> in its constructor to NTASKS<\/span> (line 2). The thread pool executes NTASKS<\/span> (lines 4 – 8).  The counter will be decreased at the end of each task (line 7). Line 11 is the barrier for the thread running the function DoWork<\/span> and, hence, for the small workflow. This thread has to wait until all tasks have been done.<\/p>\n
     <\/p>\n
    The proposal uses a vector<thread*><\/span> and pushes the dynamically allocated threads onto the vector workers.push_back(new thread([&]<\/span> {. That is a memory leak. <\/em>Instead, you should put the threads into a std::unique_ptr<\/span> or directly create them in the vector: workers.emplace_back[&]{<\/span> . This observation holds for the example to the std::barrier<\/span> and the std::flex_barrier.<\/span>
    <\/em><\/p>\n
    std::barrier<\/h2>\n
    A std::barrier<\/span> is quite similar to a std::latch<\/span>. The subtle difference is that you can use a  std::barrier<\/span> more than once because the counter will be reset to its previous value. Immediately after the counter becomes zero, the so-called completion phase starts. This completion phase is in the case of a std::barrier<\/span> empty. That changes with a  std::flex_barrier.<\/span> std::barrier<\/span> has two exciting methods: std::arrive_and_wait <\/span>and std::arrive_and_drop. <\/span>While std::arrive_and_wait<\/span><\/strong> waits at the synchronization point, std::arrive_and_drop<\/strong><\/span> removes itself from the synchronization mechanism.<\/p>\n
    Before I look at the std::flex_barrier and the completion phase, I will give a short example of the <\/span>std::barrier.<\/span><\/span><\/span><\/span><\/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<\/pre>\n<\/td>\n
    		\n
    void<\/span> DoWork() {\r\n    Tasks& tasks;\r\n    int<\/span> n_threads;\r\n    vector<thread<\/span>*> workers;\r\n\r\n    barrier task_barrier(n_threads);\r\n\r\n    for<\/span> (int<\/span> i = 0; i < n_threads; ++i) {\r\n      workers.push_back(new<\/span> thread<\/span>([&] {\r\n        bool<\/span> active = true;\r\n        while<\/span>(active) {\r\n          Task task = tasks.get();\r\n          \/\/ perform task<\/span>\r\n          ...\r\n          task_barrier.arrive_and_wait();\r\n         }\r\n       });\r\n    }\r\n    \/\/ Read each stage of the task until all stages are complete.<\/span>\r\n    while<\/span> (!finished()) {\r\n      GetNextStage(tasks);\r\n    }\r\n  }\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    The std::barrier barrier<\/span> in line 6 coordinates several threads that perform their tasks a few times. The number of threads is n_threads <\/span>(line 3). Each thread takes its task (line 12) via task.get(), <\/span><\/span>performs it, and waits – as far as it is done with its task(line 15) – until all threads have done their task. After that, it takes a new task in line 12 as far as active <\/span>returns true <\/span>in line 12. <\/span><\/p>\n
    std::flex_barrier<\/h2>\n
    From my perspective, the names in the example of the std::flex_barrier<\/span> are slightly confusing. For example, the std::flex_barrier<\/span> is called notifying_barrier<\/span>. Therefore I used the name std::flex_barrier<\/span>.<\/em><\/p>\n
    The std::flex_barrier<\/span> has, in contrast to the std::barrier<\/span> an additional constructor. This constructor can be parametrized by a callable unit that will be invoked in the completion phase. The callable unit has to return a number. This number sets the value of the counter in the completion phase. A number of -1 means that the counter keeps the same in the next iteration. Smaller numbers than -1 are not allowed. <\/p>\n
    What is happening in the completion phase?<\/p>\n
      \n
    1. All threads are blocked.<\/li>\n
    2. A thread is unblocked and executes the callable unit.<\/li>\n
    3. If the completion phase is done, all threads will be unblocked.<\/li>\n<\/ol>\n
      The code snippet shows the usage of a std::flex_barrier.<\/span><\/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<\/pre>\n<\/td>\n
      		\n
       void<\/span> DoWork() {\r\n    Tasks& tasks;\r\n    int<\/span> initial_threads;\r\n    atomic<int<\/span>> current_threads(initial_threads);\r\n    vector<thread<\/span>*> workers;\r\n\r\n    \/\/ Create a flex_barrier, and set a lambda that will be<\/span>\r\n    \/\/ invoked every time the barrier counts down. If one or more<\/span>\r\n    \/\/ active threads have completed, reduce the number of threads.<\/span>\r\n    std::function rf = [&] { return<\/span> current_threads;};\r\n    flex_barrier task_barrier(n_threads, rf);\r\n\r\n    for<\/span> (int<\/span> i = 0; i < n_threads; ++i) {\r\n      workers.push_back(new<\/span> thread<\/span>([&] {\r\n        bool<\/span> active = true;\r\n        while<\/span>(active) {\r\n          Task task = tasks.get();\r\n          \/\/ perform task<\/span>\r\n          ...\r\n          if<\/span> (finished(task)) {\r\n            current_threads--;\r\n            active = false;\r\n          }\r\n          task_barrier.arrive_and_wait();\r\n         }\r\n       });\r\n    }\r\n\r\n    \/\/ Read each stage of the task until all stages are complete.<\/span>\r\n    while<\/span> (!finished()) {\r\n      GetNextStage(tasks);\r\n    }\r\n  }\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
       <\/p>\n
      The example follows a similar strategy as the example to std::barrier. <\/span>The difference is that this time the counter of the std::flex_barrier<\/span> is adjusted during run time; therefore, the std::flex_barrier task_barrier<\/span> in line 11 gets a lambda function. This lambda function captures its variable current_thread<\/span> by reference. The variable will be decremented in line 21, and active <\/span>will be set to false <\/span>if the thread has done its task; therefore, the counter is decreased in the completion phase.
       <\/span><\/p>\n
      A std::flex_barrier<\/span> has one specialty in contrast to a std::barrier<\/span> and a std::latch.<\/span> This is the only one for which you can increase the counter.<\/p>\n
       <\/p>\n
      Read the details to std::latch<\/span><\/a>, <\/span>std::barrier<\/a><\/span> , and std::flex_barrier<\/a> <\/span>at cppreference.com.
       <\/em><\/p>\n
      What’s next?<\/h2>\n
      Coroutines are generalized functions that can be suspended and resumed while keeping their state. They are often used to implement cooperative tasks in operating systems, event loops in event systems, infinite lists, or pipelines. You can read the details about coroutines in the next post<\/a>.<\/p>\n
       <\/p>\n
       <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
      Latches and barriers are simple thread synchronization mechanisms, enabling some threads to wait until a counter becomes zero. We will, presumably in C++20, get latches and barriers in three variations: std::latch, std::barrier, and std::flex_barrier.<\/p>\n","protected":false},"author":21,"featured_media":5199,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[367],"tags":[449,450],"class_list":["post-5200","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-c-17-and-c-20","tag-barriers","tag-latches"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5200","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=5200"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5200\/revisions"}],"predecessor-version":[{"id":6883,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5200\/revisions\/6883"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5199"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5200"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5200"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5200"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}