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); } }