src/s4u/s4u_ConditionVariable.cpp

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