void simcall_HANDLER_comm_testany(
smx_simcall_t simcall, simgrid::kernel::activity::ActivityImpl* comms[], size_t count)
{
// The default result is -1 -- this means, "nothing is ready".
// It can be changed below, but only if something matches.
simcall_comm_testany__set__result(simcall, -1);
if (MC_is_active() || MC_record_replay_is_active()){
int idx = SIMCALL_GET_MC_VALUE(simcall);
if(idx == -1){
SIMIX_simcall_answer(simcall);
}else{
simgrid::kernel::activity::ActivityImpl* synchro = comms[idx];
simcall_comm_testany__set__result(simcall, idx);
synchro->simcalls.push_back(simcall);
synchro->state = SIMIX_DONE;
SIMIX_comm_finish(synchro);
}
return;
}
for (std::size_t i = 0; i != count; ++i) {
simgrid::kernel::activity::ActivityImpl* synchro = comms[i];
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
simcall_comm_testany__set__result(simcall, i);
synchro->simcalls.push_back(simcall);
SIMIX_comm_finish(synchro);
return;
}
}
SIMIX_simcall_answer(simcall);
}
void simgrid::kernel::activity::CommImpl::post()
{
/* Update synchro state */
if (src_timeout && src_timeout->get_state() == simgrid::kernel::resource::Action::State::FINISHED)
state_ = SIMIX_SRC_TIMEOUT;
else if (dst_timeout && dst_timeout->get_state() == simgrid::kernel::resource::Action::State::FINISHED)
state_ = SIMIX_DST_TIMEOUT;
else if (src_timeout && src_timeout->get_state() == simgrid::kernel::resource::Action::State::FAILED)
state_ = SIMIX_SRC_HOST_FAILURE;
else if (dst_timeout && dst_timeout->get_state() == simgrid::kernel::resource::Action::State::FAILED)
state_ = SIMIX_DST_HOST_FAILURE;
else if (surfAction_ && surfAction_->get_state() == simgrid::kernel::resource::Action::State::FAILED) {
state_ = SIMIX_LINK_FAILURE;
} else
state_ = SIMIX_DONE;
XBT_DEBUG("SIMIX_post_comm: comm %p, state %d, src_proc %p, dst_proc %p, detached: %d", this, (int)state_, src_proc,
dst_proc, detached);
/* destroy the surf actions associated with the Simix communication */
cleanupSurf();
/* if there are simcalls associated with the synchro, then answer them */
if (not simcalls_.empty()) {
SIMIX_comm_finish(this);
}
}
void simgrid::kernel::activity::Comm::post()
{
/* Update synchro state */
if (src_timeout && src_timeout->getState() == simgrid::surf::Action::State::done)
state = SIMIX_SRC_TIMEOUT;
else if (dst_timeout && dst_timeout->getState() == simgrid::surf::Action::State::done)
state = SIMIX_DST_TIMEOUT;
else if (src_timeout && src_timeout->getState() == simgrid::surf::Action::State::failed)
state = SIMIX_SRC_HOST_FAILURE;
else if (dst_timeout && dst_timeout->getState() == simgrid::surf::Action::State::failed)
state = SIMIX_DST_HOST_FAILURE;
else if (surf_comm && surf_comm->getState() == simgrid::surf::Action::State::failed) {
state = SIMIX_LINK_FAILURE;
} else
state = SIMIX_DONE;
XBT_DEBUG("SIMIX_post_comm: comm %p, state %d, src_proc %p, dst_proc %p, detached: %d",
this, (int)state, src_proc, dst_proc, detached);
/* destroy the surf actions associated with the Simix communication */
cleanupSurf();
/* if there are simcalls associated with the synchro, then answer them */
if (!simcalls.empty())
SIMIX_comm_finish(this);
}
void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, double timeout)
{
/* Associate this simcall to the wait synchro */
XBT_DEBUG("simcall_HANDLER_comm_wait, %p", synchro);
synchro->simcalls.push_back(simcall);
simcall->issuer->waiting_synchro = synchro;
if (MC_is_active() || MC_record_replay_is_active()) {
int idx = SIMCALL_GET_MC_VALUE(simcall);
if (idx == 0) {
synchro->state = SIMIX_DONE;
} else {
/* If we reached this point, the wait simcall must have a timeout */
/* Otherwise it shouldn't be enabled and executed by the MC */
if (timeout < 0.0)
THROW_IMPOSSIBLE;
simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (comm->src_proc == simcall->issuer)
comm->state = SIMIX_SRC_TIMEOUT;
else
comm->state = SIMIX_DST_TIMEOUT;
}
SIMIX_comm_finish(synchro);
return;
}
/* If the synchro has already finish perform the error handling, */
/* otherwise set up a waiting timeout on the right side */
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
SIMIX_comm_finish(synchro);
} else { /* if (timeout >= 0) { we need a surf sleep action even when there is no timeout, otherwise surf won't tell us when the host fails */
surf_action_t sleep = simcall->issuer->host->pimpl_cpu->sleep(timeout);
sleep->setData(synchro);
simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (simcall->issuer == comm->src_proc)
comm->src_timeout = sleep;
else
comm->dst_timeout = sleep;
}
}
void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, double timeout)
{
smx_activity_t synchro;
unsigned int cursor = 0;
if (MC_is_active() || MC_record_replay_is_active()){
if (timeout > 0.0)
xbt_die("Timeout not implemented for waitany in the model-checker");
int idx = SIMCALL_GET_MC_VALUE(simcall);
synchro = xbt_dynar_get_as(synchros, idx, smx_activity_t);
synchro->simcalls.push_back(simcall);
simcall_comm_waitany__set__result(simcall, idx);
synchro->state = SIMIX_DONE;
SIMIX_comm_finish(synchro);
return;
}
if (timeout < 0.0){
simcall->timer = NULL;
} else {
simcall->timer = SIMIX_timer_set(SIMIX_get_clock() + timeout, [simcall]() {
SIMIX_waitany_remove_simcall_from_actions(simcall);
simcall_comm_waitany__set__result(simcall, -1);
SIMIX_simcall_answer(simcall);
});
}
xbt_dynar_foreach(synchros, cursor, synchro){
/* associate this simcall to the the synchro */
synchro->simcalls.push_back(simcall);
/* see if the synchro is already finished */
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING){
SIMIX_comm_finish(synchro);
break;
}
}
void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_activity_t synchro)
{
simgrid::kernel::activity::Comm *comm = static_cast<simgrid::kernel::activity::Comm*>(synchro);
if (MC_is_active() || MC_record_replay_is_active()){
simcall_comm_test__set__result(simcall, comm->src_proc && comm->dst_proc);
if (simcall_comm_test__get__result(simcall)){
synchro->state = SIMIX_DONE;
synchro->simcalls.push_back(simcall);
SIMIX_comm_finish(synchro);
} else {
SIMIX_simcall_answer(simcall);
}
return;
}
simcall_comm_test__set__result(simcall, (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING));
if (simcall_comm_test__get__result(simcall)) {
synchro->simcalls.push_back(simcall);
SIMIX_comm_finish(synchro);
} else {
SIMIX_simcall_answer(simcall);
}
}
