include/marl/event.h - SwiftShader - Git at Google

 // Copyright 2019 The Marl Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #ifndef marl_event_h
 #define marl_event_h

 #include "conditionvariable.h"
 #include "containers.h"
 #include "export.h"
 #include "memory.h"

 #include <chrono>

 namespace marl {

 // Event is a synchronization primitive used to block until a signal is raised.
 class Event {
  public:
   enum class Mode : uint8_t {
     // The event signal will be automatically reset when a call to wait()
     // returns.
     // A single call to signal() will only unblock a single (possibly
     // future) call to wait().
     Auto,

     // While the event is in the signaled state, any calls to wait() will
     // unblock without automatically reseting the signaled state.
     // The signaled state can be reset with a call to clear().
     Manual
   };

   MARL_NO_EXPORT inline Event(Mode mode = Mode::Auto,
                               bool initialState = false,
                               Allocator* allocator = Allocator::Default);

   // signal() signals the event, possibly unblocking a call to wait().
   MARL_NO_EXPORT inline void signal() const;

   // clear() clears the signaled state.
   MARL_NO_EXPORT inline void clear() const;

   // wait() blocks until the event is signaled.
   // If the event was constructed with the Auto Mode, then only one
   // call to wait() will unblock before returning, upon which the signalled
   // state will be automatically cleared.
   MARL_NO_EXPORT inline void wait() const;

   // wait_for() blocks until the event is signaled, or the timeout has been
   // reached.
   // If the timeout was reached, then wait_for() return false.
   // If the event is signalled and event was constructed with the Auto Mode,
   // then only one call to wait() will unblock before returning, upon which the
   // signalled state will be automatically cleared.
   template <typename Rep, typename Period>
   MARL_NO_EXPORT inline bool wait_for(
       const std::chrono::duration<Rep, Period>& duration) const;

   // wait_until() blocks until the event is signaled, or the timeout has been
   // reached.
   // If the timeout was reached, then wait_for() return false.
   // If the event is signalled and event was constructed with the Auto Mode,
   // then only one call to wait() will unblock before returning, upon which the
   // signalled state will be automatically cleared.
   template <typename Clock, typename Duration>
   MARL_NO_EXPORT inline bool wait_until(
       const std::chrono::time_point<Clock, Duration>& timeout) const;

   // test() returns true if the event is signaled, otherwise false.
   // If the event is signalled and was constructed with the Auto Mode
   // then the signalled state will be automatically cleared upon returning.
   MARL_NO_EXPORT inline bool test() const;

   // isSignalled() returns true if the event is signaled, otherwise false.
   // Unlike test() the signal is not automatically cleared when the event was
   // constructed with the Auto Mode.
   // Note: No lock is held after bool() returns, so the event state may
   // immediately change after returning. Use with caution.
   MARL_NO_EXPORT inline bool isSignalled() const;

   // any returns an event that is automatically signalled whenever any of the
   // events in the list are signalled.
   template <typename Iterator>
   MARL_NO_EXPORT inline static Event any(Mode mode,
                                          const Iterator& begin,
                                          const Iterator& end);

   // any returns an event that is automatically signalled whenever any of the
   // events in the list are signalled.
   // This overload defaults to using the Auto mode.
   template <typename Iterator>
   MARL_NO_EXPORT inline static Event any(const Iterator& begin,
                                          const Iterator& end);

  private:
   struct Shared {
     MARL_NO_EXPORT inline Shared(Allocator* allocator,
                                  Mode mode,
                                  bool initialState);
     MARL_NO_EXPORT inline void signal();
     MARL_NO_EXPORT inline void wait();

     template <typename Rep, typename Period>
     MARL_NO_EXPORT inline bool wait_for(
         const std::chrono::duration<Rep, Period>& duration);

     template <typename Clock, typename Duration>
     MARL_NO_EXPORT inline bool wait_until(
         const std::chrono::time_point<Clock, Duration>& timeout);

     marl::mutex mutex;
     ConditionVariable cv;
     containers::vector<std::shared_ptr<Shared>, 1> deps;
     const Mode mode;
     bool signalled;
   };

   const std::shared_ptr<Shared> shared;
 };

 Event::Shared::Shared(Allocator* allocator, Mode mode, bool initialState)
     : cv(allocator), mode(mode), signalled(initialState) {}

 void Event::Shared::signal() {
   marl::lock lock(mutex);
   if (signalled) {
     return;
   }
   signalled = true;
   if (mode == Mode::Auto) {
     cv.notify_one();
   } else {
     cv.notify_all();
   }
   for (auto dep : deps) {
     dep->signal();
   }
 }

 void Event::Shared::wait() {
   marl::lock lock(mutex);
   cv.wait(lock, [&] { return signalled; });
   if (mode == Mode::Auto) {
     signalled = false;
   }
 }

 template <typename Rep, typename Period>
 bool Event::Shared::wait_for(
     const std::chrono::duration<Rep, Period>& duration) {
   marl::lock lock(mutex);
   if (!cv.wait_for(lock, duration, [&] { return signalled; })) {
     return false;
   }
   if (mode == Mode::Auto) {
     signalled = false;
   }
   return true;
 }

 template <typename Clock, typename Duration>
 bool Event::Shared::wait_until(
     const std::chrono::time_point<Clock, Duration>& timeout) {
   marl::lock lock(mutex);
   if (!cv.wait_until(lock, timeout, [&] { return signalled; })) {
     return false;
   }
   if (mode == Mode::Auto) {
     signalled = false;
   }
   return true;
 }

 Event::Event(Mode mode /* = Mode::Auto */,
              bool initialState /* = false */,
              Allocator* allocator /* = Allocator::Default */)
     : shared(allocator->make_shared<Shared>(allocator, mode, initialState)) {}

 void Event::signal() const {
   shared->signal();
 }

 void Event::clear() const {
   marl::lock lock(shared->mutex);
   shared->signalled = false;
 }

 void Event::wait() const {
   shared->wait();
 }

 template <typename Rep, typename Period>
 bool Event::wait_for(const std::chrono::duration<Rep, Period>& duration) const {
   return shared->wait_for(duration);
 }

 template <typename Clock, typename Duration>
 bool Event::wait_until(
     const std::chrono::time_point<Clock, Duration>& timeout) const {
   return shared->wait_until(timeout);
 }

 bool Event::test() const {
   marl::lock lock(shared->mutex);
   if (!shared->signalled) {
     return false;
   }
   if (shared->mode == Mode::Auto) {
     shared->signalled = false;
   }
   return true;
 }

 bool Event::isSignalled() const {
   marl::lock lock(shared->mutex);
   return shared->signalled;
 }

 template <typename Iterator>
 Event Event::any(Mode mode, const Iterator& begin, const Iterator& end) {
   Event any(mode, false);
   for (auto it = begin; it != end; it++) {
     auto s = it->shared;
     marl::lock lock(s->mutex);
     if (s->signalled) {
       any.signal();
     }
     s->deps.push_back(any.shared);
   }
   return any;
 }

 template <typename Iterator>
 Event Event::any(const Iterator& begin, const Iterator& end) {
   return any(Mode::Auto, begin, end);
 }

 }  // namespace marl

 #endif  // marl_event_h
	// Copyright 2019 The Marl Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#ifndef marl_event_h
	#define marl_event_h

	#include "conditionvariable.h"
	#include "containers.h"
	#include "export.h"
	#include "memory.h"

	#include <chrono>

	namespace marl {

	// Event is a synchronization primitive used to block until a signal is raised.
	class Event {
	public:
	enum class Mode : uint8_t {
	// The event signal will be automatically reset when a call to wait()
	// returns.
	// A single call to signal() will only unblock a single (possibly
	// future) call to wait().
	Auto,

	// While the event is in the signaled state, any calls to wait() will
	// unblock without automatically reseting the signaled state.
	// The signaled state can be reset with a call to clear().
	Manual
	};

	MARL_NO_EXPORT inline Event(Mode mode = Mode::Auto,
	bool initialState = false,
	Allocator* allocator = Allocator::Default);

	// signal() signals the event, possibly unblocking a call to wait().
	MARL_NO_EXPORT inline void signal() const;

	// clear() clears the signaled state.
	MARL_NO_EXPORT inline void clear() const;

	// wait() blocks until the event is signaled.
	// If the event was constructed with the Auto Mode, then only one
	// call to wait() will unblock before returning, upon which the signalled
	// state will be automatically cleared.
	MARL_NO_EXPORT inline void wait() const;

	// wait_for() blocks until the event is signaled, or the timeout has been
	// reached.
	// If the timeout was reached, then wait_for() return false.
	// If the event is signalled and event was constructed with the Auto Mode,
	// then only one call to wait() will unblock before returning, upon which the
	// signalled state will be automatically cleared.
	template <typename Rep, typename Period>
	MARL_NO_EXPORT inline bool wait_for(
	const std::chrono::duration<Rep, Period>& duration) const;

	// wait_until() blocks until the event is signaled, or the timeout has been
	// reached.
	// If the timeout was reached, then wait_for() return false.
	// If the event is signalled and event was constructed with the Auto Mode,
	// then only one call to wait() will unblock before returning, upon which the
	// signalled state will be automatically cleared.
	template <typename Clock, typename Duration>
	MARL_NO_EXPORT inline bool wait_until(
	const std::chrono::time_point<Clock, Duration>& timeout) const;

	// test() returns true if the event is signaled, otherwise false.
	// If the event is signalled and was constructed with the Auto Mode
	// then the signalled state will be automatically cleared upon returning.
	MARL_NO_EXPORT inline bool test() const;

	// isSignalled() returns true if the event is signaled, otherwise false.
	// Unlike test() the signal is not automatically cleared when the event was
	// constructed with the Auto Mode.
	// Note: No lock is held after bool() returns, so the event state may
	// immediately change after returning. Use with caution.
	MARL_NO_EXPORT inline bool isSignalled() const;

	// any returns an event that is automatically signalled whenever any of the
	// events in the list are signalled.
	template <typename Iterator>
	MARL_NO_EXPORT inline static Event any(Mode mode,
	const Iterator& begin,
	const Iterator& end);

	// any returns an event that is automatically signalled whenever any of the
	// events in the list are signalled.
	// This overload defaults to using the Auto mode.
	template <typename Iterator>
	MARL_NO_EXPORT inline static Event any(const Iterator& begin,
	const Iterator& end);

	private:
	struct Shared {
	MARL_NO_EXPORT inline Shared(Allocator* allocator,
	Mode mode,
	bool initialState);
	MARL_NO_EXPORT inline void signal();
	MARL_NO_EXPORT inline void wait();

	template <typename Rep, typename Period>
	MARL_NO_EXPORT inline bool wait_for(
	const std::chrono::duration<Rep, Period>& duration);

	template <typename Clock, typename Duration>
	MARL_NO_EXPORT inline bool wait_until(
	const std::chrono::time_point<Clock, Duration>& timeout);

	marl::mutex mutex;
	ConditionVariable cv;
	containers::vector<std::shared_ptr<Shared>, 1> deps;
	const Mode mode;
	bool signalled;
	};

	const std::shared_ptr<Shared> shared;
	};

	Event::Shared::Shared(Allocator* allocator, Mode mode, bool initialState)
	: cv(allocator), mode(mode), signalled(initialState) {}

	void Event::Shared::signal() {
	marl::lock lock(mutex);
	if (signalled) {
	return;
	}
	signalled = true;
	if (mode == Mode::Auto) {
	cv.notify_one();
	} else {
	cv.notify_all();
	}
	for (auto dep : deps) {
	dep->signal();
	}
	}

	void Event::Shared::wait() {
	marl::lock lock(mutex);
	cv.wait(lock, [&] { return signalled; });
	if (mode == Mode::Auto) {
	signalled = false;
	}
	}

	template <typename Rep, typename Period>
	bool Event::Shared::wait_for(
	const std::chrono::duration<Rep, Period>& duration) {
	marl::lock lock(mutex);
	if (!cv.wait_for(lock, duration, [&] { return signalled; })) {
	return false;
	}
	if (mode == Mode::Auto) {
	signalled = false;
	}
	return true;
	}

	template <typename Clock, typename Duration>
	bool Event::Shared::wait_until(
	const std::chrono::time_point<Clock, Duration>& timeout) {
	marl::lock lock(mutex);
	if (!cv.wait_until(lock, timeout, [&] { return signalled; })) {
	return false;
	}
	if (mode == Mode::Auto) {
	signalled = false;
	}
	return true;
	}

	Event::Event(Mode mode /* = Mode::Auto */,
	bool initialState /* = false */,
	Allocator* allocator /* = Allocator::Default */)
	: shared(allocator->make_shared<Shared>(allocator, mode, initialState)) {}

	void Event::signal() const {
	shared->signal();
	}

	void Event::clear() const {
	marl::lock lock(shared->mutex);
	shared->signalled = false;
	}

	void Event::wait() const {
	shared->wait();
	}

	template <typename Rep, typename Period>
	bool Event::wait_for(const std::chrono::duration<Rep, Period>& duration) const {
	return shared->wait_for(duration);
	}

	template <typename Clock, typename Duration>
	bool Event::wait_until(
	const std::chrono::time_point<Clock, Duration>& timeout) const {
	return shared->wait_until(timeout);
	}

	bool Event::test() const {
	marl::lock lock(shared->mutex);
	if (!shared->signalled) {
	return false;
	}
	if (shared->mode == Mode::Auto) {
	shared->signalled = false;
	}
	return true;
	}

	bool Event::isSignalled() const {
	marl::lock lock(shared->mutex);
	return shared->signalled;
	}

	template <typename Iterator>
	Event Event::any(Mode mode, const Iterator& begin, const Iterator& end) {
	Event any(mode, false);
	for (auto it = begin; it != end; it++) {
	auto s = it->shared;
	marl::lock lock(s->mutex);
	if (s->signalled) {
	any.signal();
	}
	s->deps.push_back(any.shared);
	}
	return any;
	}

	template <typename Iterator>
	Event Event::any(const Iterator& begin, const Iterator& end) {
	return any(Mode::Auto, begin, end);
	}

	} // namespace marl

	#endif // marl_event_h