X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/778ef0bf09f58678e4cd2bad3e57cdfeb716dd45..2143d8fb56b12f02f6123087bafa5d0d32ffa944:/src/kernel/activity/CommImpl.cpp diff --git a/src/kernel/activity/CommImpl.cpp b/src/kernel/activity/CommImpl.cpp index 59c9f69a52..5fbd6b33c9 100644 --- a/src/kernel/activity/CommImpl.cpp +++ b/src/kernel/activity/CommImpl.cpp @@ -27,7 +27,7 @@ XBT_PRIVATE void simcall_HANDLER_comm_send(smx_simcall_t simcall, smx_actor_t sr smx_activity_t comm = simcall_HANDLER_comm_isend(simcall, src, mbox, task_size, rate, src_buff, src_buff_size, match_fun, nullptr, copy_data_fun, data, 0); SIMCALL_SET_MC_VALUE(simcall, 0); - simcall_HANDLER_comm_wait(simcall, comm, timeout); + simcall_HANDLER_comm_wait(simcall, static_cast(comm.get()), timeout); } XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_isend( @@ -109,7 +109,7 @@ XBT_PRIVATE void simcall_HANDLER_comm_recv(smx_simcall_t simcall, smx_actor_t re smx_activity_t comm = simcall_HANDLER_comm_irecv(simcall, receiver, mbox, dst_buff, dst_buff_size, match_fun, copy_data_fun, data, rate); SIMCALL_SET_MC_VALUE(simcall, 0); - simcall_HANDLER_comm_wait(simcall, comm, timeout); + simcall_HANDLER_comm_wait(simcall, static_cast(comm.get()), timeout); } XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv( @@ -188,46 +188,42 @@ XBT_PRIVATE smx_activity_t simcall_HANDLER_comm_irecv( return other_comm; } -void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, double timeout) +void simcall_HANDLER_comm_wait(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm, double timeout) { /* Associate this simcall to the wait synchro */ - XBT_DEBUG("simcall_HANDLER_comm_wait, %p", synchro.get()); + XBT_DEBUG("simcall_HANDLER_comm_wait, %p", comm); - synchro->simcalls_.push_back(simcall); - simcall->issuer->waiting_synchro = synchro; + comm->simcalls_.push_back(simcall); + simcall->issuer->waiting_synchro = comm; if (MC_is_active() || MC_record_replay_is_active()) { int idx = SIMCALL_GET_MC_VALUE(simcall); if (idx == 0) { - synchro->state_ = SIMIX_DONE; + comm->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::CommImplPtr comm = - boost::static_pointer_cast(synchro); if (comm->src_actor_ == simcall->issuer) comm->state_ = SIMIX_SRC_TIMEOUT; else comm->state_ = SIMIX_DST_TIMEOUT; } - boost::static_pointer_cast(synchro)->finish(); + comm->finish(); 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) { - boost::static_pointer_cast(synchro)->finish(); + if (comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING) { + comm->finish(); } else { /* we need a sleep action (even when there is no timeout) to be notified of host failures */ simgrid::kernel::resource::Action* sleep = simcall->issuer->get_host()->pimpl_cpu->sleep(timeout); - sleep->set_data(synchro.get()); + sleep->set_data(comm); - simgrid::kernel::activity::CommImplPtr comm = - boost::static_pointer_cast(synchro); if (simcall->issuer == comm->src_actor_) comm->src_timeout_ = sleep; else @@ -235,32 +231,28 @@ void simcall_HANDLER_comm_wait(smx_simcall_t simcall, smx_activity_t synchro, do } } -void simcall_HANDLER_comm_test(smx_simcall_t simcall, smx_activity_t synchro) +void simcall_HANDLER_comm_test(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm) { - simgrid::kernel::activity::CommImplPtr comm = - boost::static_pointer_cast(synchro); - int res; if (MC_is_active() || MC_record_replay_is_active()) { res = comm->src_actor_ && comm->dst_actor_; if (res) - synchro->state_ = SIMIX_DONE; + comm->state_ = SIMIX_DONE; } else { - res = synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING; + res = comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING; } simcall_comm_test__set__result(simcall, res); if (simcall_comm_test__get__result(simcall)) { - synchro->simcalls_.push_back(simcall); - boost::static_pointer_cast(synchro)->finish(); + comm->simcalls_.push_back(simcall); + comm->finish(); } else { SIMIX_simcall_answer(simcall); } } -void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activity::ActivityImplPtr comms[], - size_t count) +void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comms[], size_t count) { // The default result is -1 -- this means, "nothing is ready". // It can be changed below, but only if something matches. @@ -271,21 +263,21 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi if (idx == -1) { SIMIX_simcall_answer(simcall); } else { - simgrid::kernel::activity::ActivityImplPtr synchro = comms[idx]; + simgrid::kernel::activity::CommImpl* comm = comms[idx]; simcall_comm_testany__set__result(simcall, idx); - synchro->simcalls_.push_back(simcall); - synchro->state_ = SIMIX_DONE; - boost::static_pointer_cast(synchro)->finish(); + comm->simcalls_.push_back(simcall); + comm->state_ = SIMIX_DONE; + comm->finish(); } return; } for (std::size_t i = 0; i != count; ++i) { - simgrid::kernel::activity::ActivityImplPtr synchro = comms[i]; - if (synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING) { + simgrid::kernel::activity::CommImpl* comm = comms[i]; + if (comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING) { simcall_comm_testany__set__result(simcall, i); - synchro->simcalls_.push_back(simcall); - boost::static_pointer_cast(synchro)->finish(); + comm->simcalls_.push_back(simcall); + comm->finish(); return; } } @@ -294,28 +286,29 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall) { - smx_activity_t* synchros = simcall_comm_waitany__get__comms(simcall); - size_t count = simcall_comm_waitany__get__count(simcall); + simgrid::kernel::activity::CommImpl** comms = simcall_comm_waitany__get__comms(simcall); + size_t count = simcall_comm_waitany__get__count(simcall); for (size_t i = 0; i < count; i++) { // Remove the first occurence of simcall: - smx_activity_t& synchro = synchros[i]; - auto j = boost::range::find(synchro->simcalls_, simcall); - if (j != synchro->simcalls_.end()) - synchro->simcalls_.erase(j); + auto* comm = comms[i]; + auto j = boost::range::find(comm->simcalls_, simcall); + if (j != comm->simcalls_.end()) + comm->simcalls_.erase(j); } } -void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, smx_activity_t* synchros, size_t count, double timeout) +void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comms[], size_t count, + double timeout) { 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); - smx_activity_t& synchro = synchros[idx]; - synchro->simcalls_.push_back(simcall); + auto* comm = comms[idx]; + comm->simcalls_.push_back(simcall); simcall_comm_waitany__set__result(simcall, idx); - synchro->state_ = SIMIX_DONE; - synchro->finish(); + comm->state_ = SIMIX_DONE; + comm->finish(); return; } @@ -331,12 +324,12 @@ void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, smx_activity_t* synchro for (size_t i = 0; i < count; i++) { /* associate this simcall to the the synchro */ - smx_activity_t& synchro = synchros[i]; - synchro->simcalls_.push_back(simcall); + auto* comm = comms[i]; + comm->simcalls_.push_back(simcall); /* see if the synchro is already finished */ - if (synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING) { - synchro->finish(); + if (comm->state_ != SIMIX_WAITING && comm->state_ != SIMIX_RUNNING) { + comm->finish(); break; } } @@ -384,7 +377,8 @@ CommImpl::CommImpl(CommImpl::Type type) : type(type) CommImpl::~CommImpl() { - XBT_DEBUG("Really free communication %p", this); + XBT_DEBUG("Really free communication %p in state %d (detached = %d)", this, static_cast(state_), + static_cast(detached)); cleanupSurf(); @@ -394,10 +388,9 @@ CommImpl::~CommImpl() if (clean_fun) clean_fun(src_buff_); src_buff_ = nullptr; - } - - if (mbox) + } else if (mbox) { mbox->remove(this); + } } /** @brief Starts the simulation of a communication synchro. */ @@ -492,8 +485,10 @@ void CommImpl::cancel() { /* if the synchro is a waiting state means that it is still in a mbox so remove from it and delete it */ if (state_ == SIMIX_WAITING) { - mbox->remove(this); - state_ = SIMIX_CANCELED; + if (not detached) { + mbox->remove(this); + state_ = SIMIX_CANCELED; + } } else if (not MC_is_active() /* when running the MC there are no surf actions */ && not MC_record_replay_is_active() && (state_ == SIMIX_READY || state_ == SIMIX_RUNNING)) { surf_action_->cancel();