include/simgrid/s4u/ConditionVariable.hpp

   1 /* Copyright (c) 2006-2021. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #ifndef SIMGRID_S4U_COND_VARIABLE_HPP
   7 #define SIMGRID_S4U_COND_VARIABLE_HPP
   8
   9 #include <simgrid/forward.h>
  10
  11 #include <simgrid/chrono.hpp>
  12 #include <simgrid/s4u/Engine.hpp>
  13 #include <simgrid/s4u/Mutex.hpp>
  14
  15 #include <future>
  16
  17 namespace simgrid {
  18 namespace s4u {
  19
  20 /**
  21  * @beginrst
  22  * SimGrid's condition variables are meant to be drop-in replacements of ``std::condition_variable``.
  23  * Please refer to the `documentation of standard C++ <https://en.cppreference.com/w/cpp/thread/condition_variable>`_
  24  * for more information on condition variables. A SimGrid example is available in Section :ref:`s4u_ex_IPC`.
  25  * @endrst
  26  */
  27 class XBT_PUBLIC ConditionVariable {
  28 private:
  29   friend kernel::activity::ConditionVariableImpl;
  30   friend void kernel::activity::intrusive_ptr_release(kernel::activity::ConditionVariableImpl* cond);
  31
  32   kernel::activity::ConditionVariableImpl* const pimpl_;
  33
  34   explicit ConditionVariable(kernel::activity::ConditionVariableImpl* cond) : pimpl_(cond) {}
  35   ~ConditionVariable() = default;
  36 #ifndef DOXYGEN
  37   ConditionVariable(ConditionVariable const&) = delete;
  38   ConditionVariable& operator=(ConditionVariable const&) = delete;
  39
  40   friend XBT_PUBLIC void intrusive_ptr_add_ref(const ConditionVariable* cond);
  41   friend XBT_PUBLIC void intrusive_ptr_release(const ConditionVariable* cond);
  42 #endif
  43
  44 public:
  45   /** Create a new condition variable and return a smart pointer
  46    *
  47    * @beginrst
  48    * You should only manipulate :cpp:type:`simgrid::s4u::ConditionVariablePtr`, as created by this function (see also :ref:`s4u_raii`).
  49    * @endrst
  50    */
  51   static ConditionVariablePtr create();
  52
  53   ///  Wait until notification, with no timeout
  54   void wait(s4u::MutexPtr lock);
  55   ///  Wait until notification, with no timeout
  56   void wait(const std::unique_lock<s4u::Mutex>& lock);
  57   template <class P> void wait(const std::unique_lock<Mutex>& lock, P pred)
  58   {
  59     while (not pred())
  60       wait(lock);
  61   }
  62
  63   /// Wait until the given instant (specified as a plain double)
  64   std::cv_status wait_until(const std::unique_lock<s4u::Mutex>& lock, double timeout_time);
  65   /// Wait for the given amount of seconds (specified as a plain double)
  66   std::cv_status wait_for(const std::unique_lock<s4u::Mutex>& lock, double duration);
  67   /// Wait until predicate is true, or the given instant (specified as a plain double)
  68   template <class P> bool wait_until(const std::unique_lock<s4u::Mutex>& lock, double timeout_time, P pred)
  69   {
  70     while (not pred())
  71       if (this->wait_until(lock, timeout_time) == std::cv_status::timeout)
  72         return pred();
  73     return true;
  74   }
  75   /// As long as the predicate is false, wait for the given amount of seconds (specified as a plain double)
  76   template <class P> bool wait_for(const std::unique_lock<s4u::Mutex>& lock, double duration, P pred)
  77   {
  78     return this->wait_until(lock, Engine::get_clock() + duration, std::move(pred));
  79   }
  80
  81   // Wait function taking a C++ style time:
  82
  83   /// As long as the predicate is false, wait for the given amount of seconds (specified in C++ style)
  84   template <class Rep, class Period, class P>
  85   bool wait_for(const std::unique_lock<s4u::Mutex>& lock, std::chrono::duration<Rep, Period> duration, P pred)
  86   {
  87     auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
  88     return this->wait_for(lock, seconds.count(), pred);
  89   }
  90   /// Wait for the given amount of seconds (specified in C++ style)
  91   template <class Rep, class Period>
  92   std::cv_status wait_for(const std::unique_lock<s4u::Mutex>& lock, std::chrono::duration<Rep, Period> duration)
  93   {
  94     auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
  95     return this->wait_for(lock, seconds.count());
  96   }
  97   /** Wait until the given instant (specified in C++ style) */
  98   template <class Duration>
  99   std::cv_status wait_until(const std::unique_lock<s4u::Mutex>& lock, const SimulationTimePoint<Duration>& timeout_time)
 100   {
 101     auto timeout_native = std::chrono::time_point_cast<SimulationClockDuration>(timeout_time);
 102     return this->wait_until(lock, timeout_native.time_since_epoch().count());
 103   }
 104   /** Wait until predicate is true, or the given instant (specified in C++ style) */
 105   template <class Duration, class P>
 106   bool wait_until(const std::unique_lock<s4u::Mutex>& lock, const SimulationTimePoint<Duration>& timeout_time, P pred)
 107   {
 108     auto timeout_native = std::chrono::time_point_cast<SimulationClockDuration>(timeout_time);
 109     return this->wait_until(lock, timeout_native.time_since_epoch().count(), std::move(pred));
 110   }
 111
 112   /** Unblock one actor blocked on that condition variable. If none was blocked, nothing happens. */
 113   void notify_one();
 114   /** Unblock all actors blocked on that condition variable. If none was blocked, nothing happens. */
 115   void notify_all();
 116 };
 117
 118 } // namespace s4u
 119 } // namespace simgrid
 120
 121 #endif