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/mc/checker/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   mc::ConditionWaitSimcall observer{issuer, pimpl_, lock->pimpl_};
  35   kernel::actor::simcall_blocking<void>(
  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   mc::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_};
  43   kernel::actor::simcall_blocking<void>(
  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   mc::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
  55   kernel::actor::simcall_blocking<void>(
  56       [&observer] { observer.get_cond()->wait(observer.get_mutex(), observer.get_timeout(), observer.get_issuer()); },
  57       &observer);
  58   bool timed_out = observer.get_result();
  59   if (timed_out) {
  60     // If we reached the timeout, we have to take the lock again:
  61     lock.mutex()->lock();
  62     return std::cv_status::timeout;
  63   } else {
  64     return std::cv_status::no_timeout;
  65   }
  66 }
  67
  68 std::cv_status ConditionVariable::wait_until(const std::unique_lock<Mutex>& lock, double timeout_time)
  69 {
  70   double now = SIMIX_get_clock();
  71   double timeout;
  72   if (timeout_time < now)
  73     timeout = 0.0;
  74   else
  75     timeout = timeout_time - now;
  76   return this->wait_for(lock, timeout);
  77 }
  78
  79 /**
  80  * Notify functions
  81  */
  82 void ConditionVariable::notify_one()
  83 {
  84   simgrid::kernel::actor::simcall([this]() { pimpl_->signal(); });
  85 }
  86
  87 void ConditionVariable::notify_all()
  88 {
  89   simgrid::kernel::actor::simcall([this]() { pimpl_->broadcast(); });
  90 }
  91
  92 void intrusive_ptr_add_ref(const ConditionVariable* cond)
  93 {
  94   intrusive_ptr_add_ref(cond->pimpl_);
  95 }
  96
  97 void intrusive_ptr_release(const ConditionVariable* cond)
  98 {
  99   intrusive_ptr_release(cond->pimpl_);
 100 }
 101
 102 } // namespace s4u
 103 } // namespace simgrid
 104
 105 /* **************************** Public C interface *************************** */
 106 sg_cond_t sg_cond_init()
 107 {
 108   return simgrid::s4u::ConditionVariable::create().detach();
 109 }
 110
 111 void sg_cond_wait(sg_cond_t cond, sg_mutex_t mutex)
 112 {
 113   cond->wait(mutex);
 114 }
 115
 116 int sg_cond_wait_for(sg_cond_t cond, sg_mutex_t mutex, double delay)
 117 {
 118   std::unique_lock<simgrid::s4u::Mutex> lock(*mutex);
 119   return cond->wait_for(lock, delay) == std::cv_status::timeout;
 120 }
 121
 122 void sg_cond_notify_one(sg_cond_t cond)
 123 {
 124   cond->notify_one();
 125 }
 126
 127 void sg_cond_notify_all(sg_cond_t cond)
 128 {
 129   cond->notify_all();
 130 }
 131
 132 void sg_cond_destroy(const_sg_cond_t cond)
 133 {
 134   intrusive_ptr_release(cond);
 135 }