1 /* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved. */
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. */
6 #include "src/kernel/activity/ConditionVariableImpl.hpp"
7 #include "simgrid/Exception.hpp"
8 #include "src/kernel/activity/MutexImpl.hpp"
9 #include "src/kernel/activity/SynchroRaw.hpp"
10 #include "src/simix/smx_synchro_private.hpp"
12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ConditionVariable, simix_synchro, "Condition variables");
14 /********************************* Condition **********************************/
16 static void _SIMIX_cond_wait(smx_cond_t cond, smx_mutex_t mutex, double timeout, smx_actor_t issuer,
17 smx_simcall_t simcall)
19 XBT_IN("(%p, %p, %f, %p,%p)", cond, mutex, timeout, issuer, simcall);
20 smx_activity_t synchro = nullptr;
22 XBT_DEBUG("Wait condition %p", cond);
24 /* If there is a mutex unlock it */
25 /* FIXME: what happens if the issuer is not the owner of the mutex? */
26 if (mutex != nullptr) {
28 mutex->unlock(issuer);
31 synchro = SIMIX_synchro_wait(issuer->host_, timeout);
32 synchro->simcalls_.push_front(simcall);
33 issuer->waiting_synchro = synchro;
34 cond->sleeping.push_back(*simcall->issuer);
39 * @brief Handle a condition waiting simcall without timeouts
41 void simcall_HANDLER_cond_wait(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex)
43 XBT_IN("(%p)", simcall);
44 smx_actor_t issuer = simcall->issuer;
46 _SIMIX_cond_wait(cond, mutex, -1, issuer, simcall);
51 * @brief Handle a condition waiting simcall with timeouts
53 void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout)
55 XBT_IN("(%p)", simcall);
56 smx_actor_t issuer = simcall->issuer;
57 simcall_cond_wait_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout
58 _SIMIX_cond_wait(cond, mutex, timeout, issuer, simcall);
66 ConditionVariableImpl::ConditionVariableImpl() : cond_(this) {}
67 ConditionVariableImpl::~ConditionVariableImpl() = default;
70 * @brief Signalizes a condition.
72 * Signalizes a condition and wakes up a sleeping process.
73 * If there are no process sleeping, no action is done.
75 void ConditionVariableImpl::signal()
77 XBT_DEBUG("Signal condition %p", this);
79 /* If there are processes waiting for the condition choose one and try
80 to make it acquire the mutex */
81 if (not sleeping.empty()) {
82 auto& proc = sleeping.front();
85 /* Destroy waiter's synchronization */
86 proc.waiting_synchro = nullptr;
88 /* Now transform the cond wait simcall into a mutex lock one */
89 smx_simcall_t simcall = &proc.simcall;
90 smx_mutex_t simcall_mutex;
91 if (simcall->call == SIMCALL_COND_WAIT)
92 simcall_mutex = simcall_cond_wait__get__mutex(simcall);
94 simcall_mutex = simcall_cond_wait_timeout__get__mutex(simcall);
95 simcall->call = SIMCALL_MUTEX_LOCK;
97 simcall_HANDLER_mutex_lock(simcall, simcall_mutex);
103 * @brief Broadcasts a condition.
105 * Signal ALL processes waiting on a condition.
106 * If there are no process waiting, no action is done.
108 void ConditionVariableImpl::broadcast()
110 XBT_DEBUG("Broadcast condition %p", this);
112 /* Signal the condition until nobody is waiting on it */
113 while (not sleeping.empty())
117 // boost::intrusive_ptr<ConditionVariableImpl> support:
118 void intrusive_ptr_add_ref(simgrid::kernel::activity::ConditionVariableImpl* cond)
120 cond->refcount_.fetch_add(1, std::memory_order_relaxed);
123 void intrusive_ptr_release(simgrid::kernel::activity::ConditionVariableImpl* cond)
125 if (cond->refcount_.fetch_sub(1, std::memory_order_release) == 1) {
126 std::atomic_thread_fence(std::memory_order_acquire);
127 xbt_assert(cond->sleeping.empty(), "Cannot destroy conditional since someone is still using it");
131 } // namespace activity
132 } // namespace kernel