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