X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/54465b4758320eff6148483c24a55bdeabd95f15..22c1ae042f53e501bf25fc7eb53f3be1bc4d861e:/src/kernel/activity/CommImpl.cpp?ds=sidebyside diff --git a/src/kernel/activity/CommImpl.cpp b/src/kernel/activity/CommImpl.cpp index 796f8135d0..deb61c1baf 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::ActivityImplPtr 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,24 +286,24 @@ void simcall_HANDLER_comm_testany(smx_simcall_t simcall, simgrid::kernel::activi static void SIMIX_waitany_remove_simcall_from_actions(smx_simcall_t simcall) { - unsigned int cursor = 0; - xbt_dynar_t synchros = simcall_comm_waitany__get__comms(simcall); + smx_activity_t* synchros = simcall_comm_waitany__get__comms(simcall); + size_t count = simcall_comm_waitany__get__count(simcall); - simgrid::kernel::activity::ActivityImpl* synchro; - xbt_dynar_foreach (synchros, cursor, synchro) { + for (size_t i = 0; i < count; i++) { // Remove the first occurence of simcall: - auto i = boost::range::find(synchro->simcalls_, simcall); - if (i != synchro->simcalls_.end()) - synchro->simcalls_.erase(i); + smx_activity_t& synchro = synchros[i]; + auto j = boost::range::find(synchro->simcalls_, simcall); + if (j != synchro->simcalls_.end()) + synchro->simcalls_.erase(j); } } -void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, double timeout) +void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, smx_activity_t* synchros, 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); - auto* synchro = xbt_dynar_get_as(synchros, idx, simgrid::kernel::activity::ActivityImpl*); + int idx = SIMCALL_GET_MC_VALUE(simcall); + smx_activity_t& synchro = synchros[idx]; synchro->simcalls_.push_back(simcall); simcall_comm_waitany__set__result(simcall, idx); synchro->state_ = SIMIX_DONE; @@ -329,10 +321,9 @@ void simcall_HANDLER_comm_waitany(smx_simcall_t simcall, xbt_dynar_t synchros, d }); } - unsigned int cursor; - simgrid::kernel::activity::ActivityImpl* synchro; - xbt_dynar_foreach (synchros, cursor, 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); /* see if the synchro is already finished */ @@ -561,7 +552,7 @@ void CommImpl::finish() simcalls_.pop_front(); /* If a waitany simcall is waiting for this synchro to finish, then remove it from the other synchros in the waitany - * list. Afterwards, get the position of the actual synchro in the waitany dynar and return it as the result of the + * list. Afterwards, get the position of the actual synchro in the waitany list and return it as the result of the * simcall */ if (simcall->call == SIMCALL_NONE) // FIXME: maybe a better way to handle this case @@ -573,9 +564,11 @@ void CommImpl::finish() simcall->timer = nullptr; } if (not MC_is_active() && not MC_record_replay_is_active()) { - ActivityImpl* synchro = this; - simcall_comm_waitany__set__result(simcall, - xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro)); + CommImpl** comms = simcall_comm_waitany__get__comms(simcall); + size_t count = simcall_comm_waitany__get__count(simcall); + CommImpl** element = std::find(comms, comms + count, this); + int rank = (element != comms + count) ? element - comms : -1; + simcall_comm_waitany__set__result(simcall, rank); } } @@ -655,25 +648,22 @@ void CommImpl::finish() xbt_die("Unexpected synchro state in CommImpl::finish: %d", static_cast(state_)); } } - /* if there is an exception during a waitany or a testany, indicate the position of the failed communication */ if (simcall->issuer->exception_ && (simcall->call == SIMCALL_COMM_WAITANY || simcall->call == SIMCALL_COMM_TESTANY)) { // First retrieve the rank of our failing synchro - int rank = -1; + CommImpl** comms; + size_t count; if (simcall->call == SIMCALL_COMM_WAITANY) { - ActivityImpl* synchro = this; - rank = xbt_dynar_search(simcall_comm_waitany__get__comms(simcall), &synchro); - } else if (simcall->call == SIMCALL_COMM_TESTANY) { - rank = -1; - auto* comms = simcall_comm_testany__get__comms(simcall); - auto count = simcall_comm_testany__get__count(simcall); - auto element = std::find(comms, comms + count, this); - if (element == comms + count) - rank = -1; - else - rank = element - comms; + comms = simcall_comm_waitany__get__comms(simcall); + count = simcall_comm_waitany__get__count(simcall); + } else { + /* simcall->call == SIMCALL_COMM_TESTANY */ + comms = simcall_comm_testany__get__comms(simcall); + count = simcall_comm_testany__get__count(simcall); } + CommImpl** element = std::find(comms, comms + count, this); + int rank = (element != comms + count) ? element - comms : -1; // In order to modify the exception we have to rethrow it: try {