include/simgrid/s4u/ConditionVariable.hpp

   1 /* Copyright (c) 2006-2017. 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 <chrono>
  10 #include <condition_variable>
  11 #include <future>
  12 #include <mutex>
  13 #include <utility> // std::swap
  14
  15 #include <boost/intrusive_ptr.hpp>
  16
  17 #include <xbt/base.h>
  18
  19 #include <simgrid/chrono.hpp>
  20 #include <simgrid/s4u/Mutex.hpp>
  21 #include <simgrid/simix.h>
  22
  23 namespace simgrid {
  24 namespace s4u {
  25
  26 /** @brief A condition variable
  27  *  @ingroup s4u_api
  28  *
  29  *  This is a drop-in replacement of `std::condition_variable` and should respect the same
  30  *  semantic. But we currently use (only) double for both durations and
  31  *  timestamp timeouts.
  32  */
  33 XBT_PUBLIC_CLASS ConditionVariable
  34 {
  35 private:
  36   friend s_smx_cond_t;
  37   smx_cond_t cond_;
  38   explicit ConditionVariable(smx_cond_t cond) : cond_(cond) {}
  39 public:
  40   ConditionVariable(ConditionVariable const&) = delete;
  41   ConditionVariable& operator=(ConditionVariable const&) = delete;
  42
  43   friend XBT_PUBLIC(void) intrusive_ptr_add_ref(ConditionVariable * cond);
  44   friend XBT_PUBLIC(void) intrusive_ptr_release(ConditionVariable * cond);
  45   using Ptr = boost::intrusive_ptr<ConditionVariable>;
  46
  47   static Ptr createConditionVariable();
  48
  49   //  Wait functions without time:
  50
  51   void wait(MutexPtr lock);
  52   void wait(std::unique_lock<Mutex> & lock);
  53   template <class P> void wait(std::unique_lock<Mutex> & lock, P pred)
  54   {
  55     while (not pred())
  56       wait(lock);
  57   }
  58
  59   // Wait function taking a plain double as time:
  60
  61   std::cv_status wait_until(std::unique_lock<Mutex> & lock, double timeout_time);
  62   std::cv_status wait_for(std::unique_lock<Mutex> & lock, double duration);
  63   template <class P> bool wait_until(std::unique_lock<Mutex> & lock, double timeout_time, P pred)
  64   {
  65     while (not pred())
  66       if (this->wait_until(lock, timeout_time) == std::cv_status::timeout)
  67         return pred();
  68     return true;
  69   }
  70   template <class P> bool wait_for(std::unique_lock<Mutex> & lock, double duration, P pred)
  71   {
  72     return this->wait_until(lock, SIMIX_get_clock() + duration, std::move(pred));
  73   }
  74
  75   // Wait function taking a C++ style time:
  76
  77   template <class Rep, class Period, class P>
  78   bool wait_for(std::unique_lock<Mutex> & lock, std::chrono::duration<Rep, Period> duration, P pred)
  79   {
  80     auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
  81     return this->wait_for(lock, seconds.count(), pred);
  82   }
  83   template <class Rep, class Period>
  84   std::cv_status wait_for(std::unique_lock<Mutex> & lock, std::chrono::duration<Rep, Period> duration)
  85   {
  86     auto seconds = std::chrono::duration_cast<SimulationClockDuration>(duration);
  87     return this->wait_for(lock, seconds.count());
  88   }
  89   template <class Duration>
  90   std::cv_status wait_until(std::unique_lock<Mutex> & lock, const SimulationTimePoint<Duration>& timeout_time)
  91   {
  92     auto timeout_native = std::chrono::time_point_cast<SimulationClockDuration>(timeout_time);
  93     return this->wait_until(lock, timeout_native.time_since_epoch().count());
  94   }
  95   template <class Duration, class P>
  96   bool wait_until(std::unique_lock<Mutex> & lock, const SimulationTimePoint<Duration>& timeout_time, P pred)
  97   {
  98     auto timeout_native = std::chrono::time_point_cast<SimulationClockDuration>(timeout_time);
  99     return this->wait_until(lock, timeout_native.time_since_epoch().count(), std::move(pred));
 100   }
 101
 102   // Notify functions
 103
 104   void notify_one();
 105   void notify_all();
 106
 107   XBT_ATTRIB_DEPRECATED_v319("Use notify_one(): v3.19 will change this warning into an error.") void notify()
 108   {
 109     notify_one();
 110   }
 111 };
 112
 113 using ConditionVariablePtr = ConditionVariable::Ptr;
 114 }
 115 } // namespace simgrid::s4u
 116
 117 #endif