Add sw::WaitGroup to System/Synchronization.hpp
A synchronization primitive borrowed from golang:
https://golang.org/pkg/sync/#WaitGroup
Bug: b/133127573
Change-Id: Id3ec093c0de478cfe16fad4d064cf2c26288acf7
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/31680
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
Tested-by: Ben Clayton <bclayton@google.com>
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
diff --git a/src/System/Synchronization.hpp b/src/System/Synchronization.hpp
index 0015442..a6d0df2 100644
--- a/src/System/Synchronization.hpp
+++ b/src/System/Synchronization.hpp
@@ -15,6 +15,7 @@
#ifndef sw_Synchronization_hpp
#define sw_Synchronization_hpp
+#include <assert.h>
#include <chrono>
#include <condition_variable>
#include <mutex>
@@ -23,6 +24,70 @@
namespace sw
{
+// WaitGroup is a synchronization primitive that allows you to wait for
+// collection of asynchronous tasks to finish executing.
+// Call add() before each task begins, and then call done() when after each task
+// is finished.
+// At the same time, wait() can be used to block until all tasks have finished.
+// WaitGroup takes its name after Golang's sync.WaitGroup.
+class WaitGroup
+{
+public:
+ // add() begins a new task.
+ void add()
+ {
+ std::unique_lock<std::mutex> lock(mutex);
+ ++count_;
+ }
+
+ // done() is called when a task of the WaitGroup has been completed.
+ // Returns true if there are no more tasks currently running in the
+ // WaitGroup.
+ bool done()
+ {
+ std::unique_lock<std::mutex> lock(mutex);
+ assert(count_ > 0);
+ --count_;
+ if(count_ == 0)
+ {
+ condition.notify_all();
+ }
+ return count_ == 0;
+ }
+
+ // wait() blocks until all the tasks have been finished.
+ void wait()
+ {
+ std::unique_lock<std::mutex> lock(mutex);
+ condition.wait(lock, [this] { return count_ == 0; });
+ }
+
+ // wait() blocks until all the tasks have been finished or the timeout
+ // has been reached, returning true if all tasks have been completed, or
+ // false if the timeout has been reached.
+ template <class CLOCK, class DURATION>
+ bool wait(const std::chrono::time_point<CLOCK, DURATION>& timeout)
+ {
+ std::unique_lock<std::mutex> lock(mutex);
+ return condition.wait_until(lock, timeout, [this] { return count_ == 0; });
+ }
+
+ // count() returns the number of times add() has been called without a call
+ // to done().
+ // Note: No lock is held after count() returns, so the count may immediately
+ // change after returning.
+ int32_t count()
+ {
+ std::unique_lock<std::mutex> lock(mutex);
+ return count_;
+ }
+
+private:
+ int32_t count_ = 0; // guarded by mutex
+ std::mutex mutex;
+ std::condition_variable condition;
+};
+
// Event is a synchronization mechanism used to indicate to waiting threads
// when a boolean condition has become true.
class Event
