Note: we need a test for that.
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);
+XBT_ATTRIB_DEPRECATED_v331("Please use sg_sem_acquire_timeout()") XBT_PUBLIC
+ int simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
SG_END_DECL
/***************************** Io **************************************/
#include "src/kernel/activity/SemaphoreImpl.hpp"
#include "src/kernel/activity/SynchroRaw.hpp"
+#include <cmath> // std::isfinite
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_semaphore, simix_synchro, "Semaphore kernel-space implementation");
void SemaphoreImpl::acquire(actor::ActorImpl* issuer, double timeout)
{
XBT_DEBUG("Wait semaphore %p (timeout:%f)", this, timeout);
+ 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 (value_ <= 0) {
RawImplPtr synchro(new RawImpl([this, issuer]() {
this->remove_sleeping_actor(*issuer);
- if (issuer->simcall_.call_ == simix::Simcall::SEM_ACQUIRE_TIMEOUT)
- simcall_sem_acquire_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_);
} // namespace activity
} // namespace kernel
} // namespace simgrid
-
-// Simcall handlers:
-/**
- * @brief Handles a sem acquire simcall with timeout.
- */
-void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout)
-{
- simcall_sem_acquire_timeout__set__result(simcall, 0); // default result, will be set to 1 on timeout
- sem->acquire(simcall->issuer_, timeout);
-}
bool Semaphore::acquire_timeout(double timeout)
{
- return simcall_sem_acquire_timeout(pimpl_, timeout);
+ kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+ mc::SemAcquireSimcall observer{issuer, pimpl_};
+ kernel::actor::simcall_blocking<void>(
+ [&observer] { observer.get_sem()->acquire(observer.get_issuer(), observer.get_timeout()); }, &observer);
+ return simgrid::simix::unmarshal<bool>(issuer->simcall_.result_);
}
void Semaphore::release()
* @ingroup simix_synchro_management
*
*/
-int simcall_sem_acquire_timeout(smx_sem_t sem, double timeout)
+int simcall_sem_acquire_timeout(smx_sem_t sem, double timeout) // XBT_ATTRIB_DEPRECATD_v331
{
- xbt_assert(std::isfinite(timeout), "timeout is not finite!");
- return simcall_BODY_sem_acquire_timeout(sem, timeout);
+ return sem->sem().acquire_timeout(timeout);
}
simgrid::kernel::activity::State simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io,
simgrid::simix::marshal<double>(simcall->args_[1], arg);
}
-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]);
-}
-static inline smx_sem_t simcall_sem_acquire_timeout__getraw__sem(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<smx_sem_t>(simcall->args_[0]);
-}
-static inline void simcall_sem_acquire_timeout__set__sem(smx_simcall_t simcall, smx_sem_t arg)
-{
- simgrid::simix::marshal<smx_sem_t>(simcall->args_[0], arg);
-}
-static inline double simcall_sem_acquire_timeout__get__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<double>(simcall->args_[1]);
-}
-static inline double simcall_sem_acquire_timeout__getraw__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
-}
-static inline void simcall_sem_acquire_timeout__set__timeout(smx_simcall_t simcall, double arg)
-{
- simgrid::simix::marshal<double>(simcall->args_[1], arg);
-}
-static inline int simcall_sem_acquire_timeout__get__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<int>(simcall->result_);
-}
-static inline int simcall_sem_acquire_timeout__getraw__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<int>(simcall->result_);
-}
-static inline void simcall_sem_acquire_timeout__set__result(smx_simcall_t simcall, int result)
-{
- simgrid::simix::marshal<int>(simcall->result_, result);
-}
-
static inline std::function<void()> const* simcall_run_kernel__get__code(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<std::function<void()> const*>(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_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_sem_acquire_timeout(smx_sem_t sem, double timeout)
-{
- if (false) /* Go to that function to follow the code flow through the simcall barrier */
- simcall_HANDLER_sem_acquire_timeout(&SIMIX_process_self()->simcall_, sem, timeout);
- return simcall<int, smx_sem_t, double>(Simcall::SEM_ACQUIRE_TIMEOUT, sem, timeout);
-}
-
inline static void simcall_BODY_run_kernel(std::function<void()> const* code)
{
if (false) /* Go to that function to follow the code flow through the simcall barrier */
COMM_TESTANY,
COMM_WAITANY,
COMM_WAIT,
- SEM_ACQUIRE_TIMEOUT,
RUN_KERNEL,
RUN_BLOCKING,
};
-constexpr int NUM_SIMCALLS = 13;
+constexpr int NUM_SIMCALLS = 12;
} // namespace simix
} // namespace simgrid
"Simcall::COMM_TESTANY",
"Simcall::COMM_WAITANY",
"Simcall::COMM_WAIT",
- "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::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;
-
case Simcall::RUN_KERNEL:
SIMIX_run_kernel(simgrid::simix::unmarshal<std::function<void()> const*>(simcall_.args_[0]));
simcall_answer();
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 sem_acquire_timeout(smx_sem_t sem, double timeout) [[block]];
-
void run_kernel(std::function<void()> const* code) [[nohandler]];
void run_blocking(std::function<void()> const* code) [[block,nohandler]];