X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fc646b32904fce0465f564d149a830c8e7aeffe4..b3c5228a75b22dd22b4db7b2774603347c0396d2:/src/mc/api.cpp diff --git a/src/mc/api.cpp b/src/mc/api.cpp index cee3dcca77..9c0d0e8557 100644 --- a/src/mc/api.cpp +++ b/src/mc/api.cpp @@ -43,6 +43,9 @@ static std::string buff_size_to_string(size_t buff_size) return XBT_LOG_ISENABLED(Api, xbt_log_priority_verbose) ? std::to_string(buff_size) : "(verbose only)"; } +static void simcall_translate(smx_simcall_t req, + simgrid::mc::Remote& buffered_comm); + /* Search an enabled transition for the given process. * * This can be seen as an iterator returning the next transition of the process. @@ -139,64 +142,68 @@ static inline smx_simcall_t MC_state_choose_request_for_process(simgrid::mc::Sta state->transition_.pid_ = actor->get_pid(); state->executed_req_ = *req; + // Fetch the data of the request and translate it: state->internal_req_ = *req; + state->internal_req_.mc_value_ = state->transition_.times_considered_; + simcall_translate(&state->internal_req_, state->internal_comm_); + + return req; +} + +static void simcall_translate(smx_simcall_t req, + simgrid::mc::Remote& buffered_comm) +{ simgrid::kernel::activity::CommImpl* chosen_comm; - simgrid::mc::Remote remote_comm; /* The waitany and testany request are transformed into a wait or test request over the corresponding communication * action so it can be treated later by the dependence function. */ switch (req->call_) { case Simcall::COMM_WAITANY: - state->internal_req_.call_ = Simcall::COMM_WAIT; - chosen_comm = mc_model_checker->get_remote_simulation().read( - remote(simcall_comm_waitany__get__comms(req) + state->transition_.times_considered_)); + req->call_ = Simcall::COMM_WAIT; + chosen_comm = mc_model_checker->get_remote_simulation().read( + remote(simcall_comm_waitany__get__comms(req) + req->mc_value_)); - mc_model_checker->get_remote_simulation().read(remote_comm, remote(chosen_comm)); - simcall_comm_wait__set__comm(&state->internal_req_, remote_comm.get_buffer()); - simcall_comm_wait__set__timeout(&state->internal_req_, 0); + mc_model_checker->get_remote_simulation().read(buffered_comm, remote(chosen_comm)); + simcall_comm_wait__set__comm(req, buffered_comm.get_buffer()); + simcall_comm_wait__set__timeout(req, 0); break; case Simcall::COMM_TESTANY: - state->internal_req_.call_ = Simcall::COMM_TEST; - chosen_comm = mc_model_checker->get_remote_simulation().read( - remote(simcall_comm_testany__get__comms(req) + state->transition_.times_considered_)); + req->call_ = Simcall::COMM_TEST; + chosen_comm = mc_model_checker->get_remote_simulation().read( + remote(simcall_comm_testany__get__comms(req) + req->mc_value_)); - mc_model_checker->get_remote_simulation().read(remote_comm, remote(chosen_comm)); - simcall_comm_test__set__comm(&state->internal_req_, remote_comm.get_buffer()); - simcall_comm_test__set__result(&state->internal_req_, state->transition_.times_considered_); + mc_model_checker->get_remote_simulation().read(buffered_comm, remote(chosen_comm)); + simcall_comm_test__set__comm(req, buffered_comm.get_buffer()); + simcall_comm_test__set__result(req, req->mc_value_); break; case Simcall::COMM_WAIT: chosen_comm = simcall_comm_wait__getraw__comm(req); - mc_model_checker->get_remote_simulation().read(state->internal_comm_, remote(chosen_comm)); - simcall_comm_wait__set__comm(&state->internal_req_, state->internal_comm_.get_buffer()); + mc_model_checker->get_remote_simulation().read(buffered_comm, remote(chosen_comm)); + simcall_comm_wait__set__comm(req, buffered_comm.get_buffer()); break; case Simcall::COMM_TEST: chosen_comm = simcall_comm_test__getraw__comm(req); - mc_model_checker->get_remote_simulation().read(remote_comm, remote(chosen_comm)); - simcall_comm_test__set__comm(&state->internal_req_, remote_comm.get_buffer()); + mc_model_checker->get_remote_simulation().read(buffered_comm, remote(chosen_comm)); + simcall_comm_test__set__comm(req, buffered_comm.get_buffer()); break; default: /* No translation needed */ break; } - - return req; } -simgrid::kernel::activity::CommImpl* Api::get_comm(smx_simcall_t const r) const +simgrid::kernel::activity::CommImpl* Api::get_comm_or_nullptr(smx_simcall_t const r) const { - switch (r->call_) { - case Simcall::COMM_WAIT: - return simcall_comm_wait__getraw__comm(r); - case Simcall::COMM_TEST: - return simcall_comm_test__getraw__comm(r); - default: - return nullptr; - } + if (r->call_ == Simcall::COMM_WAIT) + return simcall_comm_wait__getraw__comm(r); + if (r->call_ == Simcall::COMM_TEST) + return simcall_comm_test__getraw__comm(r); + return nullptr; } /** Statically "upcast" a s_smx_actor_t into an ActorInformation @@ -224,26 +231,26 @@ bool Api::request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) const return false; // Those are internal requests, we do not need indirection because those objects are copies: - const kernel::activity::CommImpl* synchro1 = get_comm(r1); - const kernel::activity::CommImpl* synchro2 = get_comm(r2); + auto comm1 = get_comm_or_nullptr(r1); + auto comm2 = get_comm_or_nullptr(r2); if ((r1->call_ == Simcall::COMM_ISEND || r1->call_ == Simcall::COMM_IRECV) && r2->call_ == Simcall::COMM_WAIT) { - auto mbox = get_mbox_remote_addr(r1); - RemotePtr synchro2_mbox_cpy = remote(synchro2->mbox_cpy); + auto mbox1 = get_mbox_remote_addr(r1); + auto mbox2 = remote(comm2->mbox_cpy); - if (mbox != synchro2_mbox_cpy && simcall_comm_wait__get__timeout(r2) <= 0) + if (mbox1 != mbox2 && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->issuer_ != synchro2->src_actor_.get()) && (r1->issuer_ != synchro2->dst_actor_.get()) && + if ((r1->issuer_ != comm2->src_actor_.get()) && (r1->issuer_ != comm2->dst_actor_.get()) && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->call_ == Simcall::COMM_ISEND) && (synchro2->type_ == kernel::activity::CommImpl::Type::SEND) && - (synchro2->src_buff_ != simcall_comm_isend__get__src_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) + if ((r1->call_ == Simcall::COMM_ISEND) && (comm2->type_ == kernel::activity::CommImpl::Type::SEND) && + (comm2->src_buff_ != simcall_comm_isend__get__src_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) return false; - if ((r1->call_ == Simcall::COMM_IRECV) && (synchro2->type_ == kernel::activity::CommImpl::Type::RECEIVE) && - (synchro2->dst_buff_ != simcall_comm_irecv__get__dst_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) + if ((r1->call_ == Simcall::COMM_IRECV) && (comm2->type_ == kernel::activity::CommImpl::Type::RECEIVE) && + (comm2->dst_buff_ != simcall_comm_irecv__get__dst_buff(r1)) && simcall_comm_wait__get__timeout(r2) <= 0) return false; } @@ -255,27 +262,73 @@ bool Api::request_depend_asymmetric(smx_simcall_t r1, smx_simcall_t r2) const return false; #endif - if (r1->call_ == Simcall::COMM_WAIT && (r2->call_ == Simcall::COMM_WAIT || r2->call_ == Simcall::COMM_TEST) && - (synchro1->src_actor_.get() == nullptr || synchro1->dst_actor_.get() == nullptr)) + if (r1->call_ == Simcall::COMM_WAIT && r2->call_ == Simcall::COMM_TEST && + (comm1->src_actor_.get() == nullptr || comm1->dst_actor_.get() == nullptr)) return false; if (r1->call_ == Simcall::COMM_TEST && - (simcall_comm_test__get__comm(r1) == nullptr || synchro1->src_buff_ == nullptr || synchro1->dst_buff_ == nullptr)) + (simcall_comm_test__get__comm(r1) == nullptr || comm1->src_buff_ == nullptr || comm1->dst_buff_ == nullptr)) return false; - if (r1->call_ == Simcall::COMM_TEST && r2->call_ == Simcall::COMM_WAIT && - synchro1->src_buff_ == synchro2->src_buff_ && synchro1->dst_buff_ == synchro2->dst_buff_) + if (r1->call_ == Simcall::COMM_TEST && r2->call_ == Simcall::COMM_WAIT && comm1->src_buff_ == comm2->src_buff_ && + comm1->dst_buff_ == comm2->dst_buff_) return false; - if (r1->call_ == Simcall::COMM_WAIT && r2->call_ == Simcall::COMM_TEST && synchro1->src_buff_ != nullptr && - synchro1->dst_buff_ != nullptr && synchro2->src_buff_ != nullptr && synchro2->dst_buff_ != nullptr && - synchro1->dst_buff_ != synchro2->src_buff_ && synchro1->dst_buff_ != synchro2->dst_buff_ && - synchro2->dst_buff_ != synchro1->src_buff_) + if (r1->call_ == Simcall::COMM_WAIT && r2->call_ == Simcall::COMM_TEST && comm1->src_buff_ != nullptr && + comm1->dst_buff_ != nullptr && comm2->src_buff_ != nullptr && comm2->dst_buff_ != nullptr && + comm1->dst_buff_ != comm2->src_buff_ && comm1->dst_buff_ != comm2->dst_buff_ && + comm2->dst_buff_ != comm1->src_buff_) return false; return true; } +bool Api::simcall_check_dependency(smx_simcall_t const req1, smx_simcall_t const req2) const +{ + const auto ISEND = Simcall::COMM_ISEND; + const auto IRECV = Simcall::COMM_IRECV; + const auto TEST = Simcall::COMM_TEST; + const auto WAIT = Simcall::COMM_WAIT; + + if (req1->issuer_ == req2->issuer_) + return false; + + /* The independence theorem only consider 4 simcalls. All others are dependent with anything. */ + if (req1->call_ != ISEND && req1->call_ != IRECV && req1->call_ != TEST && req1->call_ != WAIT) + return true; + if (req2->call_ != ISEND && req2->call_ != IRECV && req2->call_ != TEST && req2->call_ != WAIT) + return true; + + /* Timeouts in wait transitions are not considered by the independence theorem, thus assumed dependent */ + if ((req1->call_ == WAIT && simcall_comm_wait__get__timeout(req1) > 0) || + (req2->call_ == WAIT && simcall_comm_wait__get__timeout(req2) > 0)) + return true; + + if (req1->call_ != req2->call_) + return request_depend_asymmetric(req1, req2) && request_depend_asymmetric(req2, req1); + + // Those are internal requests, we do not need indirection because those objects are copies: + const auto comm1 = get_comm_or_nullptr(req1); + const auto comm2 = get_comm_or_nullptr(req2); + + switch (req1->call_) { + case Simcall::COMM_ISEND: + return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2); + case Simcall::COMM_IRECV: + return simcall_comm_irecv__get__mbox(req1) == simcall_comm_irecv__get__mbox(req2); + case Simcall::COMM_WAIT: + if (comm1->src_buff_ == comm2->src_buff_ && comm1->dst_buff_ == comm2->dst_buff_) + return false; + if (comm1->src_buff_ != nullptr && comm1->dst_buff_ != nullptr && comm2->src_buff_ != nullptr && + comm2->dst_buff_ != nullptr && comm1->dst_buff_ != comm2->src_buff_ && comm1->dst_buff_ != comm2->dst_buff_ && + comm2->dst_buff_ != comm1->src_buff_) + return false; + return true; + default: + return true; + } +} + xbt::string const& Api::get_actor_host_name(smx_actor_t actor) const { if (mc_model_checker == nullptr) @@ -300,10 +353,10 @@ std::string Api::get_actor_name(smx_actor_t actor) const if (mc_model_checker == nullptr) return actor->get_cname(); - const simgrid::mc::RemoteSimulation* process = &mc_model_checker->get_remote_simulation(); - simgrid::mc::ActorInformation* info = actor_info_cast(actor); if (info->name.empty()) { + const simgrid::mc::RemoteSimulation* process = &mc_model_checker->get_remote_simulation(); + simgrid::xbt::string_data string_data = simgrid::xbt::string::to_string_data(actor->name_); info->name = process->read_string(remote(string_data.data), string_data.len); } @@ -375,58 +428,50 @@ int Api::get_actors_size() const RemotePtr Api::get_comm_isend_raw_addr(smx_simcall_t request) const { - auto comm_addr = simgrid::simix::unmarshal_raw(request->result_); - return RemotePtr(static_cast(comm_addr)); -} - -RemotePtr Api::get_comm_irecv_raw_addr(smx_simcall_t request) const -{ - auto comm_addr = simgrid::simix::unmarshal_raw(request->result_); - return RemotePtr(static_cast(comm_addr)); + return remote(static_cast(simcall_comm_isend__getraw__result(request))); } RemotePtr Api::get_comm_wait_raw_addr(smx_simcall_t request) const { - auto comm_addr = simgrid::simix::unmarshal_raw(request->args_[0]); - return RemotePtr(comm_addr); + return remote(simcall_comm_wait__getraw__comm(request)); } RemotePtr Api::get_comm_waitany_raw_addr(smx_simcall_t request, int value) const { - auto addr = simgrid::simix::unmarshal_raw(request->args_[0]) + value; + auto addr = simcall_comm_waitany__getraw__comms(request) + value; auto comm_addr = mc_model_checker->get_remote_simulation().read(remote(addr)); return RemotePtr(static_cast(comm_addr)); } std::string Api::get_pattern_comm_rdv(RemotePtr const& addr) const { - Remote temp_synchro; - mc_model_checker->get_remote_simulation().read(temp_synchro, addr); - const kernel::activity::CommImpl* synchro = temp_synchro.get_buffer(); + Remote temp_activity; + mc_model_checker->get_remote_simulation().read(temp_activity, addr); + const kernel::activity::CommImpl* activity = temp_activity.get_buffer(); char* remote_name = mc_model_checker->get_remote_simulation().read(RemotePtr( - (uint64_t)(synchro->get_mailbox() ? &synchro->get_mailbox()->get_name() : &synchro->mbox_cpy->get_name()))); + (uint64_t)(activity->get_mailbox() ? &activity->get_mailbox()->get_name() : &activity->mbox_cpy->get_name()))); auto rdv = mc_model_checker->get_remote_simulation().read_string(RemotePtr(remote_name)); return rdv; } unsigned long Api::get_pattern_comm_src_proc(RemotePtr const& addr) const { - Remote temp_synchro; - mc_model_checker->get_remote_simulation().read(temp_synchro, addr); - const kernel::activity::CommImpl* synchro = temp_synchro.get_buffer(); + Remote temp_activity; + mc_model_checker->get_remote_simulation().read(temp_activity, addr); + const kernel::activity::CommImpl* activity = temp_activity.get_buffer(); auto src_proc = - mc_model_checker->get_remote_simulation().resolve_actor(mc::remote(synchro->src_actor_.get()))->get_pid(); + mc_model_checker->get_remote_simulation().resolve_actor(mc::remote(activity->src_actor_.get()))->get_pid(); return src_proc; } unsigned long Api::get_pattern_comm_dst_proc(RemotePtr const& addr) const { - Remote temp_synchro; - mc_model_checker->get_remote_simulation().read(temp_synchro, addr); - const kernel::activity::CommImpl* synchro = temp_synchro.get_buffer(); + Remote temp_activity; + mc_model_checker->get_remote_simulation().read(temp_activity, addr); + const kernel::activity::CommImpl* activity = temp_activity.get_buffer(); auto src_proc = - mc_model_checker->get_remote_simulation().resolve_actor(mc::remote(synchro->dst_actor_.get()))->get_pid(); + mc_model_checker->get_remote_simulation().resolve_actor(mc::remote(activity->dst_actor_.get()))->get_pid(); return src_proc; } @@ -548,32 +593,20 @@ long Api::simcall_get_actor_id(s_smx_simcall const* req) const RemotePtr Api::get_mbox_remote_addr(smx_simcall_t const req) const { - RemotePtr mbox_addr; - switch (req->call_) { - case Simcall::COMM_ISEND: - case Simcall::COMM_IRECV: - mbox_addr = remote(simix::unmarshal(req->args_[1])); - break; - default: - mbox_addr = RemotePtr(); - break; - } - return mbox_addr; + if (req->call_ == Simcall::COMM_ISEND) + return remote(simcall_comm_isend__get__mbox(req)); + if (req->call_ == Simcall::COMM_IRECV) + return remote(simcall_comm_irecv__get__mbox(req)); + THROW_IMPOSSIBLE; } RemotePtr Api::get_comm_remote_addr(smx_simcall_t const req) const { - RemotePtr comm_addr; - switch (req->call_) { - case Simcall::COMM_ISEND: - case Simcall::COMM_IRECV: - comm_addr = remote(simgrid::simix::unmarshal_raw(req->result_)); - break; - default: - comm_addr = RemotePtr(); - break; - } - return comm_addr; + if (req->call_ == Simcall::COMM_ISEND) + return remote(simcall_comm_isend__getraw__result(req)); + if (req->call_ == Simcall::COMM_IRECV) + return remote(simcall_comm_irecv__getraw__result(req)); + THROW_IMPOSSIBLE; } bool Api::mc_is_null() const @@ -663,42 +696,6 @@ std::list Api::get_enabled_transitions(simgrid::mc::State* return tr_list; } -bool Api::simcall_check_dependency(smx_simcall_t const req1, smx_simcall_t const req2) const -{ - if (req1->issuer_ == req2->issuer_) - return false; - - /* Wait with timeout transitions are not considered by the independence theorem, thus we consider them as dependent - * with all other transitions */ - if ((req1->call_ == Simcall::COMM_WAIT && simcall_comm_wait__get__timeout(req1) > 0) || - (req2->call_ == Simcall::COMM_WAIT && simcall_comm_wait__get__timeout(req2) > 0)) - return true; - - if (req1->call_ != req2->call_) - return request_depend_asymmetric(req1, req2) && request_depend_asymmetric(req2, req1); - - // Those are internal requests, we do not need indirection because those objects are copies: - const kernel::activity::CommImpl* synchro1 = get_comm(req1); - const kernel::activity::CommImpl* synchro2 = get_comm(req2); - - switch (req1->call_) { - case Simcall::COMM_ISEND: - return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2); - case Simcall::COMM_IRECV: - return simcall_comm_irecv__get__mbox(req1) == simcall_comm_irecv__get__mbox(req2); - case Simcall::COMM_WAIT: - if (synchro1->src_buff_ == synchro2->src_buff_ && synchro1->dst_buff_ == synchro2->dst_buff_) - return false; - if (synchro1->src_buff_ != nullptr && synchro1->dst_buff_ != nullptr && synchro2->src_buff_ != nullptr && - synchro2->dst_buff_ != nullptr && synchro1->dst_buff_ != synchro2->src_buff_ && - synchro1->dst_buff_ != synchro2->dst_buff_ && synchro2->dst_buff_ != synchro1->src_buff_) - return false; - return true; - default: - return true; - } -} - std::string Api::request_to_string(smx_simcall_t req, int value) const { xbt_assert(mc_model_checker != nullptr, "Must be called from MCer"); @@ -740,10 +737,10 @@ std::string Api::request_to_string(smx_simcall_t req, int value) const } else { type = "Wait"; - simgrid::mc::Remote temp_synchro; + simgrid::mc::Remote temp_activity; const simgrid::kernel::activity::CommImpl* act; - mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act)); - act = temp_synchro.get_buffer(); + mc_model_checker->get_remote_simulation().read(temp_activity, remote(remote_act)); + act = temp_activity.get_buffer(); smx_actor_t src_proc = mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(act->src_actor_.get())); @@ -757,10 +754,10 @@ std::string Api::request_to_string(smx_simcall_t req, int value) const case Simcall::COMM_TEST: { simgrid::kernel::activity::CommImpl* remote_act = simcall_comm_test__getraw__comm(req); - simgrid::mc::Remote temp_synchro; + simgrid::mc::Remote temp_activity; const simgrid::kernel::activity::CommImpl* act; - mc_model_checker->get_remote_simulation().read(temp_synchro, remote(remote_act)); - act = temp_synchro.get_buffer(); + mc_model_checker->get_remote_simulation().read(temp_activity, remote(remote_act)); + act = temp_activity.get_buffer(); if (act->src_actor_.get() == nullptr || act->dst_actor_.get() == nullptr) { type = "Test FALSE"; @@ -801,22 +798,6 @@ std::string Api::request_to_string(smx_simcall_t req, int value) const } break; - case Simcall::MUTEX_LOCK: { - type = "Mutex LOCK"; - simgrid::mc::Remote mutex; - mc_model_checker->get_remote_simulation().read_bytes(mutex.get_buffer(), sizeof(mutex), - remote(simcall_mutex_lock__get__mutex(req))); - args = "locked = " + std::to_string(mutex.get_buffer()->is_locked()) + ", owner = "; - if (mutex.get_buffer()->get_owner() != nullptr) - args += std::to_string(mc_model_checker->get_remote_simulation() - .resolve_actor(simgrid::mc::remote(mutex.get_buffer()->get_owner())) - ->get_pid()); - else - args += "-1"; - args += ", sleeping = n/a"; - break; - } - default: type = SIMIX_simcall_name(req->call_); args = "??"; @@ -893,10 +874,6 @@ std::string Api::request_get_dot_output(smx_simcall_t req, int value) const } break; - case Simcall::MUTEX_LOCK: - label = "[" + get_actor_dot_label(issuer) + "] Mutex LOCK"; - break; - default: THROW_UNIMPLEMENTED; }