/******************************* Host simcalls ********************************/
#ifdef __cplusplus
-XBT_PUBLIC e_smx_state_t simcall_execution_wait(simgrid::kernel::activity::ActivityImpl* execution, double timeout);
+XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Exec::wait_for()") XBT_PUBLIC e_smx_state_t
+ simcall_execution_wait(simgrid::kernel::activity::ActivityImpl* execution, double timeout);
+XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Exec::wait_for()") XBT_PUBLIC e_smx_state_t
+ simcall_execution_wait(const simgrid::kernel::activity::ActivityImplPtr& execution, double timeout);
XBT_PUBLIC unsigned int simcall_execution_waitany_for(simgrid::kernel::activity::ExecImpl* execs[], size_t count,
double timeout);
XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Exec::test()") XBT_PUBLIC
XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Exec::test()") XBT_PUBLIC
bool simcall_execution_test(const simgrid::kernel::activity::ActivityImplPtr& execution);
-XBT_ATTRIB_DEPRECATED_v330("Please use an ActivityImpl* for first parameter") inline e_smx_state_t
- simcall_execution_wait(const simgrid::kernel::activity::ActivityImplPtr& execution, double timeout)
-{
- return simcall_execution_wait(execution.get(), timeout);
-}
#endif
/**************************** Process simcalls ********************************/
/***************************** Io **************************************/
#ifdef __cplusplus
-XBT_PUBLIC e_smx_state_t simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io, double timeout);
+XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Io::wait_for()") XBT_PUBLIC e_smx_state_t
+ simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io, double timeout);
+XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Io::wait_for()") XBT_PUBLIC e_smx_state_t
+ simcall_io_wait(const simgrid::kernel::activity::ActivityImplPtr& io, double timeout);
XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Io::test()") XBT_PUBLIC
bool simcall_io_test(simgrid::kernel::activity::ActivityImpl* io);
XBT_ATTRIB_DEPRECATED_v330("Please use s4u::Io::test()") XBT_PUBLIC
bool simcall_io_test(const simgrid::kernel::activity::ActivityImplPtr& io);
-
-XBT_ATTRIB_DEPRECATED_v330("Please use an ActivityImpl* for first parameter") inline e_smx_state_t
- simcall_io_wait(const simgrid::kernel::activity::ActivityImplPtr& io, double timeout)
-{
- return simcall_io_wait(io.get(), timeout);
-}
-
#endif
/************************** MC simcalls **********************************/
SG_BEGIN_DECL
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_process);
-void simcall_HANDLER_execution_wait(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* synchro, double timeout)
-{
- synchro->wait_for(simcall->issuer_, timeout);
-}
-
void simcall_HANDLER_execution_waitany_for(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* execs[],
size_t count, double timeout)
{
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_io, simix, "Logging specific to SIMIX (io)");
-void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* synchro, double timeout)
-{
- synchro->wait_for(simcall->issuer_, timeout);
-}
-
namespace simgrid {
namespace kernel {
namespace activity {
{
if (state_ == State::INITED)
vetoable_start();
- simcall_execution_wait(get_impl(), timeout);
+
+ kernel::actor::ActorImpl* issuer = Actor::self()->get_impl();
+ kernel::actor::simcall_blocking<void>([this, issuer, timeout] { this->get_impl()->wait_for(issuer, timeout); });
state_ = State::FINISHED;
on_completion(*Actor::self(), *this);
this->release_dependencies();
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "simgrid/s4u/Actor.hpp"
#include "simgrid/s4u/Disk.hpp"
#include "simgrid/s4u/Io.hpp"
#include "simgrid/s4u/Storage.hpp"
{
if (state_ == State::INITED)
vetoable_start();
- simcall_io_wait(get_impl(), timeout);
+
+ kernel::actor::ActorImpl* issuer = Actor::self()->get_impl();
+ kernel::actor::simcall_blocking<void>([this, issuer, timeout] { this->get_impl()->wait_for(issuer, timeout); });
state_ = State::FINISHED;
this->release_dependencies();
return this;
*
* @param execution The execution synchro
*/
-e_smx_state_t simcall_execution_wait(simgrid::kernel::activity::ActivityImpl* execution, double timeout)
+e_smx_state_t simcall_execution_wait(simgrid::kernel::activity::ActivityImpl* execution,
+ double timeout) // XBT_ATTRIB_DEPRECATED_v330
{
- return (e_smx_state_t)simcall_BODY_execution_wait(static_cast<simgrid::kernel::activity::ExecImpl*>(execution),
- timeout);
+ simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
+ simgrid::kernel::actor::simcall_blocking<void>(
+ [execution, issuer, timeout] { execution->wait_for(issuer, timeout); });
+ return simgrid::kernel::activity::State::DONE;
+}
+
+e_smx_state_t simcall_execution_wait(const simgrid::kernel::activity::ActivityImplPtr& execution,
+ double timeout) // XBT_ATTRIB_DEPRECATED_v330
+{
+ simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
+ simgrid::kernel::actor::simcall_blocking<void>(
+ [execution, issuer, timeout] { execution->wait_for(issuer, timeout); });
+ return simgrid::kernel::activity::State::DONE;
}
bool simcall_execution_test(simgrid::kernel::activity::ActivityImpl* execution) // XBT_ATTRIB_DEPRECATED_v330
return simcall_BODY_sem_acquire_timeout(sem, timeout);
}
-e_smx_state_t simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io, double timeout)
+e_smx_state_t simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io, double timeout) // XBT_ATTRIB_DEPRECATED_v330
{
- return (e_smx_state_t)simcall_BODY_io_wait(static_cast<simgrid::kernel::activity::IoImpl*>(io), timeout);
+ simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
+ simgrid::kernel::actor::simcall_blocking<void>([io, issuer, timeout] { io->wait_for(issuer, timeout); });
+ return simgrid::kernel::activity::State::DONE;
+}
+
+e_smx_state_t simcall_io_wait(const simgrid::kernel::activity::ActivityImplPtr& io,
+ double timeout) // XBT_ATTRIB_DEPRECATED_v330
+{
+ simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
+ simgrid::kernel::actor::simcall_blocking<void>([io, issuer, timeout] { io->wait_for(issuer, timeout); });
+ return simgrid::kernel::activity::State::DONE;
}
bool simcall_io_test(simgrid::kernel::activity::ActivityImpl* io) // XBT_ATTRIB_DEPRECATED_v330
*/
#include "src/simix/popping_private.hpp"
-static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__get__execution(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0]);
-}
-static inline simgrid::kernel::activity::ExecImpl* simcall_execution_wait__getraw__execution(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0]);
-}
-static inline void simcall_execution_wait__set__execution(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* arg)
-{
- simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl*>(simcall->args_[0], arg);
-}
-static inline double simcall_execution_wait__get__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<double>(simcall->args_[1]);
-}
-static inline double simcall_execution_wait__getraw__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
-}
-static inline void simcall_execution_wait__set__timeout(smx_simcall_t simcall, double arg)
-{
- simgrid::simix::marshal<double>(simcall->args_[1], arg);
-}
-static inline int simcall_execution_wait__get__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<int>(simcall->result_);
-}
-static inline int simcall_execution_wait__getraw__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<int>(simcall->result_);
-}
-static inline void simcall_execution_wait__set__result(smx_simcall_t simcall, int result)
-{
- simgrid::simix::marshal<int>(simcall->result_, result);
-}
-
static inline simgrid::kernel::activity::ExecImpl** simcall_execution_waitany_for__get__execs(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl**>(simcall->args_[0]);
simgrid::simix::marshal<int>(simcall->result_, result);
}
-static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__get__io(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<simgrid::kernel::activity::IoImpl*>(simcall->args_[0]);
-}
-static inline simgrid::kernel::activity::IoImpl* simcall_io_wait__getraw__io(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<simgrid::kernel::activity::IoImpl*>(simcall->args_[0]);
-}
-static inline void simcall_io_wait__set__io(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* arg)
-{
- simgrid::simix::marshal<simgrid::kernel::activity::IoImpl*>(simcall->args_[0], arg);
-}
-static inline double simcall_io_wait__get__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<double>(simcall->args_[1]);
-}
-static inline double simcall_io_wait__getraw__timeout(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<double>(simcall->args_[1]);
-}
-static inline void simcall_io_wait__set__timeout(smx_simcall_t simcall, double arg)
-{
- simgrid::simix::marshal<double>(simcall->args_[1], arg);
-}
-static inline sg_size_t simcall_io_wait__get__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<sg_size_t>(simcall->result_);
-}
-static inline sg_size_t simcall_io_wait__getraw__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<sg_size_t>(simcall->result_);
-}
-static inline void simcall_io_wait__set__result(smx_simcall_t simcall, sg_size_t result)
-{
- simgrid::simix::marshal<sg_size_t>(simcall->result_, result);
-}
-
static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<int>(simcall->args_[0]);
/* The prototype of all simcall handlers, automatically generated for you */
-XBT_PRIVATE void simcall_HANDLER_execution_wait(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* execution, double timeout);
XBT_PRIVATE void simcall_HANDLER_execution_waitany_for(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl** execs, size_t count, double timeout);
XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout);
XBT_PRIVATE boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> simcall_HANDLER_comm_isend(smx_simcall_t simcall, smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, bool detached);
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(smx_simcall_t simcall, smx_sem_t sem);
XBT_PRIVATE void simcall_HANDLER_sem_acquire_timeout(smx_simcall_t simcall, smx_sem_t sem, double timeout);
-XBT_PRIVATE void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* io, double timeout);
XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);
return simgrid::simix::unmarshal<R>(self->simcall.result_);
}
-inline static int simcall_BODY_execution_wait(simgrid::kernel::activity::ExecImpl* execution, double timeout)
-{
- if (0) /* Go to that function to follow the code flow through the simcall barrier */
- simcall_HANDLER_execution_wait(&SIMIX_process_self()->simcall, execution, timeout);
- return simcall<int, simgrid::kernel::activity::ExecImpl*, double>(SIMCALL_EXECUTION_WAIT, execution, timeout);
-}
-
inline static int simcall_BODY_execution_waitany_for(simgrid::kernel::activity::ExecImpl** execs, size_t count, double timeout)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
return simcall<int, smx_sem_t, double>(SIMCALL_SEM_ACQUIRE_TIMEOUT, sem, timeout);
}
-inline static sg_size_t simcall_BODY_io_wait(simgrid::kernel::activity::IoImpl* io, double timeout)
-{
- if (0) /* Go to that function to follow the code flow through the simcall barrier */
- simcall_HANDLER_io_wait(&SIMIX_process_self()->simcall, io, timeout);
- return simcall<sg_size_t, simgrid::kernel::activity::IoImpl*, double>(SIMCALL_IO_WAIT, io, timeout);
-}
-
inline static int simcall_BODY_mc_random(int min, int max)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
*/
typedef enum {
SIMCALL_NONE,
- SIMCALL_EXECUTION_WAIT,
SIMCALL_EXECUTION_WAITANY_FOR,
SIMCALL_COMM_SEND,
SIMCALL_COMM_ISEND,
SIMCALL_COND_WAIT_TIMEOUT,
SIMCALL_SEM_ACQUIRE,
SIMCALL_SEM_ACQUIRE_TIMEOUT,
- SIMCALL_IO_WAIT,
SIMCALL_MC_RANDOM,
SIMCALL_RUN_KERNEL,
SIMCALL_RUN_BLOCKING,
/** @brief Simcalls' names (generated from src/simix/simcalls.in) */
const char* simcall_names[] = {
"SIMCALL_NONE",
- "SIMCALL_EXECUTION_WAIT",
"SIMCALL_EXECUTION_WAITANY_FOR",
"SIMCALL_COMM_SEND",
"SIMCALL_COMM_ISEND",
"SIMCALL_COND_WAIT_TIMEOUT",
"SIMCALL_SEM_ACQUIRE",
"SIMCALL_SEM_ACQUIRE_TIMEOUT",
- "SIMCALL_IO_WAIT",
"SIMCALL_MC_RANDOM",
"SIMCALL_RUN_KERNEL",
"SIMCALL_RUN_BLOCKING",
if (context_->wannadie())
return;
switch (simcall.call_) {
- case SIMCALL_EXECUTION_WAIT:
- simcall_HANDLER_execution_wait(&simcall, simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl*>(simcall.args_[0]), simgrid::simix::unmarshal<double>(simcall.args_[1]));
- break;
-
case SIMCALL_EXECUTION_WAITANY_FOR:
simcall_HANDLER_execution_waitany_for(&simcall, simgrid::simix::unmarshal<simgrid::kernel::activity::ExecImpl**>(simcall.args_[0]), simgrid::simix::unmarshal<size_t>(simcall.args_[1]), simgrid::simix::unmarshal<double>(simcall.args_[2]));
break;
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_IO_WAIT:
- simcall_HANDLER_io_wait(&simcall, simgrid::simix::unmarshal<simgrid::kernel::activity::IoImpl*>(simcall.args_[0]), simgrid::simix::unmarshal<double>(simcall.args_[1]));
- break;
-
case SIMCALL_MC_RANDOM:
simgrid::simix::marshal<int>(simcall.result_, simcall_HANDLER_mc_random(&simcall, simgrid::simix::unmarshal<int>(simcall.args_[0]), simgrid::simix::unmarshal<int>(simcall.args_[1])));
simcall_answer();
# Last but not the least, you should declare the new simix call in
# ./include/simgrid/simix.h (otherwise you will get a warning at compile time)
-int execution_wait(simgrid::kernel::activity::ExecImpl* execution, double timeout) [[block]];
int execution_waitany_for(simgrid::kernel::activity::ExecImpl** execs, size_t count, double timeout) [[block]];
void comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, unsigned char* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout) [[block]];
void sem_acquire(smx_sem_t sem) [[block]];
int sem_acquire_timeout(smx_sem_t sem, double timeout) [[block]];
-sg_size_t io_wait(simgrid::kernel::activity::IoImpl* io, double timeout) [[block]];
-
int mc_random(int min, int max);
void run_kernel(std::function<void()> const* code) [[nohandler]];