XBT_ATTRIB_DEPRECATED_v330("Please use sg_cond_init()") XBT_PUBLIC smx_cond_t simcall_cond_init();
XBT_ATTRIB_DEPRECATED_v331("Please use sg_cond_wait()") XBT_PUBLIC
void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex);
-XBT_PUBLIC int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
+XBT_ATTRIB_DEPRECATED_v331("Please use sg_cond_wait_for()") XBT_PUBLIC
+ int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
XBT_ATTRIB_DEPRECATED_v331("Please use sg_sem_acquire()") XBT_PUBLIC void simcall_sem_acquire(smx_sem_t sem);
XBT_PUBLIC int simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
#include "src/kernel/activity/MutexImpl.hpp"
#include "src/kernel/activity/SynchroRaw.hpp"
#include "src/mc/checker/SimcallObserver.hpp"
+#include <cmath> // std::isfinite
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_condition, simix_synchro, "Condition variables");
/********************************* Condition **********************************/
-/** @brief Handle a condition waiting simcall with timeouts */
-void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout)
-{
- simcall_cond_wait_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout
- cond->wait(mutex, timeout, simcall->issuer_);
-}
-
namespace simgrid {
namespace kernel {
namespace activity {
/* Now transform the cond wait simcall into a mutex lock one */
smx_simcall_t simcall = &proc.simcall_;
- MutexImpl* simcall_mutex;
- if (simcall->call_ == simix::Simcall::COND_WAIT_TIMEOUT)
- simcall_mutex = simcall_cond_wait_timeout__get__mutex(simcall);
- else {
- // FIXME? using here the MC observer to solve a problem not related to MC
- const auto* observer = dynamic_cast<mc::ConditionWaitSimcall*>(simcall->observer_);
- xbt_assert(observer != nullptr);
- simcall_mutex = observer->get_mutex();
- }
- simcall->call_ = simix::Simcall::RUN_BLOCKING;
-
- simcall_mutex->lock(simcall->issuer_);
+ // FIXME? using here the MC observer to solve a problem not related to MC
+ const auto* observer = dynamic_cast<mc::ConditionWaitSimcall*>(simcall->observer_);
+ xbt_assert(observer != nullptr);
+ observer->get_mutex()->lock(simcall->issuer_);
}
XBT_OUT();
}
void ConditionVariableImpl::wait(smx_mutex_t mutex, double timeout, actor::ActorImpl* issuer)
{
XBT_DEBUG("Wait condition %p", this);
+ xbt_assert(std::isfinite(timeout), "timeout is not finite!");
+ simix::marshal<bool>(issuer->simcall_.result_, false); // default result, will be set to 'true' on timeout
/* If there is a mutex unlock it */
if (mutex != nullptr) {
RawImplPtr synchro(new RawImpl([this, issuer]() {
this->remove_sleeping_actor(*issuer);
- if (issuer->simcall_.call_ == simix::Simcall::COND_WAIT_TIMEOUT)
- simcall_cond_wait_timeout__set__result(&issuer->simcall_, 1);
+ simix::marshal<bool>(issuer->simcall_.result_, true);
}));
synchro->set_host(issuer->get_host()).set_timeout(timeout).start();
synchro->register_simcall(&issuer->simcall_);
#include "simgrid/s4u/ConditionVariable.hpp"
#include "simgrid/simix.h"
#include "src/kernel/activity/ConditionVariableImpl.hpp"
+#include "src/kernel/activity/MutexImpl.hpp"
#include "src/mc/checker/SimcallObserver.hpp"
#include "xbt/log.hpp"
if (timeout < 0)
timeout = 0.0;
- if (simcall_cond_wait_timeout(pimpl_, lock.mutex()->pimpl_, timeout)) {
+ kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+ mc::ConditionWaitSimcall observer{issuer, pimpl_, lock.mutex()->pimpl_, timeout};
+ kernel::actor::simcall_blocking<void>(
+ [&observer] { observer.get_cond()->wait(observer.get_mutex(), observer.get_timeout(), observer.get_issuer()); },
+ &observer);
+ bool timed_out = simgrid::simix::unmarshal<bool>(issuer->simcall_.result_);
+ if (timed_out) {
// If we reached the timeout, we have to take the lock again:
lock.mutex()->lock();
return std::cv_status::timeout;
int sg_cond_wait_for(sg_cond_t cond, sg_mutex_t mutex, double delay)
{
std::unique_lock<simgrid::s4u::Mutex> lock(*mutex);
- return cond->wait_for(lock, delay) == std::cv_status::timeout ? 1 : 0;
+ return cond->wait_for(lock, delay) == std::cv_status::timeout;
}
void sg_cond_notify_one(sg_cond_t cond)
* @ingroup simix_synchro_management
*
*/
-int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
+int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) // XBT_ATTRIB_DEPRECATD_v331
{
- xbt_assert(std::isfinite(timeout), "timeout is not finite!");
- return simcall_BODY_cond_wait_timeout(cond, mutex, timeout);
+ return cond->get_iface()->wait_for(std::unique_lock<simgrid::s4u::Mutex>(mutex->mutex()), timeout) ==
+ std::cv_status::timeout;
}
/**
simgrid::simix::marshal<double>(simcall->args_[1], arg);
}
-static inline smx_cond_t simcall_cond_wait_timeout__get__cond(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<smx_cond_t>(simcall->args_[0]);
-}
-static inline smx_cond_t simcall_cond_wait_timeout__getraw__cond(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<smx_cond_t>(simcall->args_[0]);
-}
-static inline void simcall_cond_wait_timeout__set__cond(smx_simcall_t simcall, smx_cond_t arg)
-{
- simgrid::simix::marshal<smx_cond_t>(simcall->args_[0], arg);
-}
-static inline smx_mutex_t simcall_cond_wait_timeout__get__mutex(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<smx_mutex_t>(simcall->args_[1]);
-}
-static inline smx_mutex_t simcall_cond_wait_timeout__getraw__mutex(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<smx_mutex_t>(simcall->args_[1]);
-}
-static inline void simcall_cond_wait_timeout__set__mutex(smx_simcall_t simcall, smx_mutex_t arg)
-{
- simgrid::simix::marshal<smx_mutex_t>(simcall->args_[1], arg);
-}
-static inline double simcall_cond_wait_timeout__get__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<double>(simcall->args_[2]);
-}
-static inline double simcall_cond_wait_timeout__getraw__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<double>(simcall->args_[2]);
-}
-static inline void simcall_cond_wait_timeout__set__timeout(smx_simcall_t simcall, double arg)
-{
- simgrid::simix::marshal<double>(simcall->args_[2], arg);
-}
-static inline int simcall_cond_wait_timeout__get__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<int>(simcall->result_);
-}
-static inline int simcall_cond_wait_timeout__getraw__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<int>(simcall->result_);
-}
-static inline void simcall_cond_wait_timeout__set__result(smx_simcall_t simcall, int result)
-{
- simgrid::simix::marshal<int>(simcall->result_, result);
-}
-
static inline smx_sem_t simcall_sem_acquire_timeout__get__sem(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<smx_sem_t>(simcall->args_[0]);
XBT_PRIVATE void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count);
XBT_PRIVATE void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout);
XBT_PRIVATE void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm, double timeout);
-XBT_PRIVATE void simcall_HANDLER_cond_wait_timeout(smx_simcall_t simcall, smx_cond_t cond, smx_mutex_t mutex, double timeout);
XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
return simcall<void, simgrid::kernel::activity::CommImpl*, double>(Simcall::COMM_WAIT, comm, timeout);
}
-inline static int simcall_BODY_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout)
-{
- if (false) /* Go to that function to follow the code flow through the simcall barrier */
- simcall_HANDLER_cond_wait_timeout(&SIMIX_process_self()->simcall_, cond, mutex, timeout);
- return simcall<int, smx_cond_t, smx_mutex_t, double>(Simcall::COND_WAIT_TIMEOUT, cond, mutex, timeout);
-}
-
inline static int simcall_BODY_sem_acquire_timeout(smx_sem_t sem, double timeout)
{
if (false) /* Go to that function to follow the code flow through the simcall barrier */
COMM_TESTANY,
COMM_WAITANY,
COMM_WAIT,
- COND_WAIT_TIMEOUT,
SEM_ACQUIRE_TIMEOUT,
RUN_KERNEL,
RUN_BLOCKING,
};
-constexpr int NUM_SIMCALLS = 14;
+constexpr int NUM_SIMCALLS = 13;
} // namespace simix
} // namespace simgrid
"Simcall::COMM_TESTANY",
"Simcall::COMM_WAITANY",
"Simcall::COMM_WAIT",
- "Simcall::COND_WAIT_TIMEOUT",
"Simcall::SEM_ACQUIRE_TIMEOUT",
"Simcall::RUN_KERNEL",
"Simcall::RUN_BLOCKING",
simcall_HANDLER_comm_wait(&simcall_, simgrid::simix::unmarshal<simgrid::kernel::activity::CommImpl*>(simcall_.args_[0]), simgrid::simix::unmarshal<double>(simcall_.args_[1]));
break;
- case Simcall::COND_WAIT_TIMEOUT:
- simcall_HANDLER_cond_wait_timeout(&simcall_, simgrid::simix::unmarshal<smx_cond_t>(simcall_.args_[0]), simgrid::simix::unmarshal<smx_mutex_t>(simcall_.args_[1]), simgrid::simix::unmarshal<double>(simcall_.args_[2]));
- break;
-
case Simcall::SEM_ACQUIRE_TIMEOUT:
simcall_HANDLER_sem_acquire_timeout(&simcall_, simgrid::simix::unmarshal<smx_sem_t>(simcall_.args_[0]), simgrid::simix::unmarshal<double>(simcall_.args_[1]));
break;
int comm_waitany(simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout) [[block]];
void comm_wait(simgrid::kernel::activity::CommImpl* comm, double timeout) [[block]];
-int cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) [[block]];
-
int sem_acquire_timeout(smx_sem_t sem, double timeout) [[block]];
void run_kernel(std::function<void()> const* code) [[nohandler]];