src/s4u/s4u_ConditionVariable.cpp

   1 /* Copyright (c) 2006-2022. 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 #include <simgrid/cond.h>
   7 #include <simgrid/s4u/ConditionVariable.hpp>
   8 #include <xbt/log.h>
   9
  10 #include "src/kernel/activity/ActivityImpl.hpp"
  11 #include "src/kernel/activity/ConditionVariableImpl.hpp"
  12 #include "src/kernel/actor/SimcallObserver.hpp"
  13
  14 #include <mutex>
  15
  16 namespace simgrid::s4u {
  17
  18 ConditionVariablePtr ConditionVariable::create()
  19 {
  20   kernel::activity::ConditionVariableImpl* cond =
  21       kernel::actor::simcall_answered([] { return new kernel::activity::ConditionVariableImpl(); });
  22   return ConditionVariablePtr(cond->get_iface(), false);
  23 }
  24
  25 /**
  26  * Wait functions
  27  */
  28 void ConditionVariable::wait(MutexPtr lock)
  29 {
  30   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
  31   kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock->pimpl_};
  32   kernel::actor::simcall_blocking(
  33       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
  34 }
  35
  36 void ConditionVariable::wait(const std::unique_lock<Mutex>& lock)
  37 {
  38   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
  39   kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_};
  40   kernel::actor::simcall_blocking(
  41       [&observer] { observer.get_cond()->wait(observer.get_mutex(), -1.0, observer.get_issuer()); }, &observer);
  42 }
  43
  44 std::cv_status s4u::ConditionVariable::wait_for(const std::unique_lock<Mutex>& lock, double timeout)
  45 {
  46   // The simcall uses -1 for "any timeout" but we don't want this:
  47   if (timeout < 0)
  48     timeout = 0.0;
  49
  50   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
  51   kernel::actor::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
  52   bool timed_out = kernel::actor::simcall_blocking(
  53       [&observer] { observer.get_cond()->wait(observer.get_mutex(), observer.get_timeout(), observer.get_issuer()); },
  54       &observer);
  55   if (timed_out) {
  56     // If we reached the timeout, we have to take the lock again:
  57     lock.mutex()->lock();
  58     return std::cv_status::timeout;
  59   } else {
  60     return std::cv_status::no_timeout;
  61   }
  62 }
  63
  64 std::cv_status ConditionVariable::wait_until(const std::unique_lock<Mutex>& lock, double timeout_time)
  65 {
  66   double now = Engine::get_clock();
  67   double timeout;
  68   if (timeout_time < now)
  69     timeout = 0.0;
  70   else
  71     timeout = timeout_time - now;
  72   return this->wait_for(lock, timeout);
  73 }
  74
  75 /**
  76  * Notify functions
  77  */
  78 void ConditionVariable::notify_one()
  79 {
  80   simgrid::kernel::actor::simcall_answered([this]() { pimpl_->signal(); });
  81 }
  82
  83 void ConditionVariable::notify_all()
  84 {
  85   simgrid::kernel::actor::simcall_answered([this]() { pimpl_->broadcast(); });
  86 }
  87
  88 void intrusive_ptr_add_ref(const ConditionVariable* cond)
  89 {
  90   intrusive_ptr_add_ref(cond->pimpl_);
  91 }
  92
  93 void intrusive_ptr_release(const ConditionVariable* cond)
  94 {
  95   intrusive_ptr_release(cond->pimpl_);
  96 }
  97
  98 } // namespace simgrid::s4u
  99
 100 /* **************************** Public C interface *************************** */
 101 sg_cond_t sg_cond_init()
 102 {
 103   return simgrid::s4u::ConditionVariable::create().detach();
 104 }
 105
 106 void sg_cond_wait(sg_cond_t cond, sg_mutex_t mutex)
 107 {
 108   cond->wait(mutex);
 109 }
 110
 111 int sg_cond_wait_for(sg_cond_t cond, sg_mutex_t mutex, double delay)
 112 {
 113   std::unique_lock lock(*mutex);
 114   return cond->wait_for(lock, delay) == std::cv_status::timeout;
 115 }
 116
 117 void sg_cond_notify_one(sg_cond_t cond)
 118 {
 119   cond->notify_one();
 120 }
 121
 122 void sg_cond_notify_all(sg_cond_t cond)
 123 {
 124   cond->notify_all();
 125 }
 126
 127 void sg_cond_destroy(const_sg_cond_t cond)
 128 {
 129   intrusive_ptr_release(cond);
 130 }