simplify capy result handlers with latch (#55)

Author: m-fila

examples/capy_reco.cpp

@@ -2,10 +2,9 @@
 #include <tbb/task_arena.h>
 
 #include <boost/capy.hpp>
-#include <condition_variable>
 #include <cstddef>
 #include <iostream>
-#include <mutex>
+#include <latch>
 #include <string_view>
 
 #include "capy_stream_await.hpp"         // StreamIoAwaitable
@@ -167,27 +166,17 @@ int main() {
         std::cout << "--- Single event, synchronous wait for completion ---\n";
         cudaStream_t stream;
         ERROR_CHECK_CUDA(cudaStreamCreate(&stream));
-        auto condition = std::condition_variable();
-        auto mutex = std::mutex();
         auto final_result = tools::StatusCode{};
-        auto result_handler = [&condition, &mutex,
-                               &final_result](tools::StatusCode code) {
-            {
-                std::lock_guard lock(mutex);
-                final_result = code;
-            }
-            condition.notify_one();
+        auto done = std::latch{1};
+        auto result_handler = [&done, &final_result](tools::StatusCode code) {
+            final_result = code;
+            done.count_down();
         };
 
         log() << "main Launching algorithm..." << std::endl;
         boost::capy::run_async(executor,
                                result_handler)(reconstruct(stream, "main"));
-        {
-            auto lock = std::unique_lock(mutex);
-            condition.wait(lock, [&final_result]() {
-                return final_result != tools::StatusCode::UNDEFINED;
-            });
-        }
+        done.wait();
         log() << "main Final status of algorithm " << final_result << ""
               << std::endl;
         ERROR_CHECK_CUDA(cudaStreamDestroy(stream));
@@ -202,31 +191,18 @@ int main() {
             ERROR_CHECK_CUDA(cudaStreamCreate(&stream));
         }
 
-        auto condition = std::condition_variable();
-        auto mutex = std::mutex();
-        auto counter = streams.size();
+        auto done = std::latch{static_cast<std::ptrdiff_t>(streams.size())};
         log() << "main Launching algorithms..." << std::endl;
 
         for (std::size_t i = 0; i < streams.size(); ++i) {
-            auto result_handler = [&condition, &mutex, &status, &counter,
-                                   i](tools::StatusCode code) {
-                auto done = false;
-                {
-                    std::lock_guard lock(mutex);
-                    status.at(i) = code;
-                    done = (--counter == 0);
-                }
-                if (done) {
-                    condition.notify_one();
-                }
+            auto result_handler = [&done, &status, i](tools::StatusCode code) {
+                status.at(i) = code;
+                done.count_down();
             };
             boost::capy::run_async(executor, result_handler)(
                 reconstruct(streams.at(i), "event" + std::to_string(i)));
         }
-        {
-            auto lock = std::unique_lock(mutex);
-            condition.wait(lock, [&counter]() { return counter == 0; });
-        }
+        done.wait();
         for (auto& stream : streams) {
             ERROR_CHECK_CUDA(cudaStreamDestroy(stream));
         }

examples/capy_task.cpp

@@ -1,9 +1,8 @@
 #include <boost/capy.hpp>
 #include <chrono>
-#include <condition_variable>
 #include <coroutine>
 #include <cstdlib>
-#include <mutex>
+#include <latch>
 #include <string_view>
 
 #include "capy_timer.hpp"     // TimerIoAwaitable
@@ -133,29 +132,19 @@ int main() {
     auto pool_executor = pool.get_executor();
     auto verbose_executor = VerboseExecutor(pool_executor);
 
-    auto condition = std::condition_variable();
-    auto mutex = std::mutex();
     auto final_result = algs::StatusCode{};
-    auto result_handler = [&condition, &mutex,
-                           &final_result](algs::StatusCode code) {
-        {
-            std::lock_guard lock(mutex);
-            final_result = code;
-        }
-        condition.notify_one();
+    auto done = std::latch{1};
+    auto result_handler = [&done, &final_result](algs::StatusCode code) {
+        final_result = code;
+        done.count_down();
     };
 
     log() << "main launching algorithm" << std::endl;
     boost::capy::run_async(verbose_executor,
                            result_handler)(algorithm_execute("main"));
 
-    {
-        log() << "main waiting for algorithm to finish..." << std::endl;
-        auto lock = std::unique_lock(mutex);
-        condition.wait(lock, [&final_result]() {
-            return final_result != algs::StatusCode::UNDEFINED;
-        });
-    }
+    log() << "main waiting for algorithm to finish..." << std::endl;
+    done.wait();
     log() << "Final status of algorithm " << final_result << std::endl;
 
     log() << "main Done" << std::endl;

examples/capy_tbb.cpp

@@ -2,12 +2,9 @@
 
 #include <boost/capy.hpp>
 #include <chrono>
-#include <condition_variable>
 #include <cstdlib>
-#include <mutex>
+#include <latch>
 #include <string_view>
-#include <thread>
-#include <utility>
 
 #include "capy_task_arena_executor.hpp"  // TaskArenaExecutor
 #include "capy_timer.hpp"                // TimerIoAwaitable
@@ -103,27 +100,17 @@ int main() {
     auto context = TaskArenaContext(arena);
     auto executor = TaskArenaExecutor(context);
 
-    auto condition = std::condition_variable();
-    auto mutex = std::mutex();
     auto final_result = algs::StatusCode{};
-    auto result_handler = [&condition, &mutex,
-                           &final_result](algs::StatusCode code) {
-        {
-            std::lock_guard lock(mutex);
-            final_result = code;
-        }
-        condition.notify_one();
+    auto done = std::latch{1};
+    auto result_handler = [&done, &final_result](algs::StatusCode code) {
+        final_result = code;
+        done.count_down();
     };
 
     boost::capy::run_async(executor, result_handler)(algorithm_execute("main"));
 
-    {
-        log() << "main waiting for algorithm to finish..." << std::endl;
-        auto lock = std::unique_lock(mutex);
-        condition.wait(lock, [&final_result]() {
-            return final_result != algs::StatusCode::UNDEFINED;
-        });
-    }
+    log() << "main waiting for algorithm to finish..." << std::endl;
+    done.wait();
 
     log() << "Final status of algorithm " << final_result << std::endl;
     // Block until all work items in the scope are done