return XBT_LOG_ISENABLED(Api, xbt_log_priority_verbose) ? std::to_string(buff_size) : "(verbose only)";
}
-static void simcall_translate(smx_simcall_t req, Remote<kernel::activity::CommImpl>& buffered_comm);
-
/* Search an enabled transition for the given process.
*
* This can be seen as an iterator returning the next transition of the process.
// 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<simgrid::kernel::activity::CommImpl>& buffered_comm)
-{
- simgrid::kernel::activity::CommImpl* chosen_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:
- req->call_ = Simcall::COMM_WAIT;
- chosen_comm =
- mc_model_checker->get_remote_process().read(remote(simcall_comm_waitany__get__comms(req) + req->mc_value_));
-
- mc_model_checker->get_remote_process().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:
- req->call_ = Simcall::COMM_TEST;
- chosen_comm =
- mc_model_checker->get_remote_process().read(remote(simcall_comm_testany__get__comms(req) + req->mc_value_));
-
- mc_model_checker->get_remote_process().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__get__comm(req);
- mc_model_checker->get_remote_process().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__get__comm(req);
- mc_model_checker->get_remote_process().read(buffered_comm, remote(chosen_comm));
- simcall_comm_test__set__comm(req, buffered_comm.get_buffer());
- break;
-
- default:
- /* No translation needed */
- break;
- }
-}
-
kernel::activity::CommImpl* Api::get_comm_or_nullptr(smx_simcall_t const r) const
{
if (auto wait = dynamic_cast<kernel::actor::ActivityWaitSimcall*>(r->observer_))
return process_info;
}
-bool Api::simcall_check_dependency(smx_simcall_t req1, smx_simcall_t req2) const
+bool Api::requests_are_dependent(RemotePtr<kernel::actor::SimcallObserver> obs1,
+ RemotePtr<kernel::actor::SimcallObserver> obs2) const
{
- const auto IRECV = Simcall::COMM_IRECV;
- const auto ISEND = Simcall::COMM_ISEND;
- const auto TEST = Simcall::COMM_TEST;
- const auto WAIT = Simcall::COMM_WAIT;
-
- if (req1->issuer_ == req2->issuer_) // Done in observer for TEST and WAIT
- 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;
-
- /* Make sure that req1 and req2 are in alphabetic order */
- if (req1->call_ > req2->call_) {
- auto temp = req1;
- req1 = req2;
- req2 = temp;
- }
-
- auto comm2 = get_comm_or_nullptr(req2);
-
- /* First case: that's not the same kind of request (we also know that req1 < req2 alphabetically) */
- if (req1->call_ != req2->call_) {
- if (req1->call_ == IRECV && req2->call_ == ISEND)
- return false;
-
- if ((req1->call_ == IRECV || req1->call_ == ISEND) && req2->call_ == WAIT) {
- auto mbox1 = get_mbox_remote_addr(req1);
- auto mbox2 = remote(comm2->mbox_cpy);
-
- if (mbox1 != mbox2 && simcall_comm_wait__get__timeout(req2) <= 0)
- return false;
-
- if ((req1->issuer_ != comm2->src_actor_.get()) && (req1->issuer_ != comm2->dst_actor_.get()) &&
- simcall_comm_wait__get__timeout(req2) <= 0)
- return false;
-
- if ((req1->call_ == ISEND) && (comm2->type_ == kernel::activity::CommImpl::Type::SEND) &&
- (comm2->src_buff_ != simcall_comm_isend__get__src_buff(req1)) && simcall_comm_wait__get__timeout(req2) <= 0)
- return false;
-
- if ((req1->call_ == IRECV) && (comm2->type_ == kernel::activity::CommImpl::Type::RECEIVE) &&
- (comm2->dst_buff_ != simcall_comm_irecv__get__dst_buff(req1)) && simcall_comm_wait__get__timeout(req2) <= 0)
- return false;
- }
-
- /* FIXME: the following rule assumes that the result of the isend/irecv call is not stored in a buffer used in the
- * test call. */
-#if 0
- if((req1->call == ISEND || req1->call == IRECV)
- && req2->call == TEST)
- return false;
-#endif
-
- return true;
- }
+ xbt_assert(mc_model_checker != nullptr, "Must be called from MCer");
- /* Second case: req1 and req2 are of the same call type */
- switch (req1->call_) {
- case ISEND:
- return simcall_comm_isend__get__mbox(req1) == simcall_comm_isend__get__mbox(req2);
- case IRECV:
- return simcall_comm_irecv__get__mbox(req1) == simcall_comm_irecv__get__mbox(req2);
- default:
- return true;
- }
+ return mc_model_checker->requests_are_dependent(obs1, obs2);
}
xbt::string const& Api::get_actor_host_name(smx_actor_t actor) const
smx_simcall_t Api::mc_state_choose_request(simgrid::mc::State* state) const
{
RemoteProcess& process = mc_model_checker->get_remote_process();
+ XBT_DEBUG("Search for an actor to run. %zu actors to consider", process.actors().size());
for (auto& actor : process.actors()) {
/* Only consider the actors that were marked as interleaving by the checker algorithm */
if (not state->actor_states_[actor.copy.get_buffer()->get_pid()].is_todo())
continue;
smx_simcall_t res = MC_state_choose_request_for_process(process, state, actor.copy.get_buffer());
- if (res)
+ if (res) {
+ XBT_DEBUG("Let's run actor %ld, going for transition %s", actor.copy.get_buffer()->get_pid(),
+ SIMIX_simcall_name(*res));
return res;
+ }
}
return nullptr;
}
{
xbt_assert(mc_model_checker != nullptr, "Must be called from MCer");
- std::string type;
- std::string args;
-
smx_actor_t issuer = simcall_get_issuer(req);
if (issuer->simcall_.observer_ != nullptr)
return mc_model_checker->simcall_to_string(issuer->get_pid(), value);
-
- switch (req->call_) {
- case Simcall::COMM_ISEND:
- type = "iSend";
- args = "src=" + get_actor_string(issuer);
- args += ", buff=" + pointer_to_string(simcall_comm_isend__get__src_buff(req));
- args += ", size=" + buff_size_to_string(simcall_comm_isend__get__src_buff_size(req));
- break;
-
- case Simcall::COMM_IRECV: {
- size_t* remote_size = simcall_comm_irecv__get__dst_buff_size(req);
- size_t size = 0;
- if (remote_size)
- mc_model_checker->get_remote_process().read_bytes(&size, sizeof(size), remote(remote_size));
-
- type = "iRecv";
- args = "dst=" + get_actor_string(issuer);
- args += ", buff=" + pointer_to_string(simcall_comm_irecv__get__dst_buff(req));
- args += ", size=" + buff_size_to_string(size);
- break;
- }
-
- case Simcall::COMM_WAIT:
- // See ActivityWaitSimcall::to_string(int times_considered)
- case Simcall::COMM_TEST:
- // See ActivityTestSimcall::to_string(int times_considered)
- case Simcall::COMM_WAITANY:
- // See ActivityWaitanySimcall::to_string(int times_considered)
- case Simcall::COMM_TESTANY:
- // See ActivityTestanySimcall::to_string(int times_considered)
- break;
-
- default:
- type = SIMIX_simcall_name(*req);
- args = "??";
- break;
- }
-
- return "[" + get_actor_string(issuer) + "] " + type + "(" + args + ")";
+ else
+ return "[" + get_actor_string(issuer) + "] " + SIMIX_simcall_name(*req) + "(unknown?)";
}
std::string Api::request_get_dot_output(smx_simcall_t req, int value) const
{
- const smx_actor_t issuer = simcall_get_issuer(req);
- const char* color = get_color(issuer->get_pid() - 1);
-
- std::string label;
-
if (req->observer_ != nullptr) {
- label = mc_model_checker->simcall_dot_label(issuer->get_pid(), value);
+ const smx_actor_t issuer = simcall_get_issuer(req);
+ const char* color = get_color(issuer->get_pid() - 1);
+ return "label = \"" + mc_model_checker->simcall_dot_label(issuer->get_pid(), value) + "\", color = " + color +
+ ", fontcolor = " + color;
} else
- switch (req->call_) {
- case Simcall::COMM_ISEND:
- label = "[" + get_actor_dot_label(issuer) + "] iSend";
- break;
-
- case Simcall::COMM_IRECV:
- label = "[" + get_actor_dot_label(issuer) + "] iRecv";
- break;
-
- case Simcall::COMM_WAIT:
- // See ActivityWaitSimcall::dot_label(int times_considered)
- case Simcall::COMM_TEST:
- // See ActivityTestSimcall::dot_label(int times_considered)
- case Simcall::COMM_WAITANY:
- // See ActivityWaittanySimcall::dot_label(int times_considered)
- case Simcall::COMM_TESTANY:
- // See ActivityTestanySimcall::dot_label(int times_considered)
- break;
-
- default:
- THROW_UNIMPLEMENTED;
- }
-
- return "label = \"" + label + "\", color = " + color + ", fontcolor = " + color;
+ return "UNIMPLEMENTED";
}
#if HAVE_SMPI
session_singleton->close();
}
-void Api::execute(Transition& transition, smx_simcall_t simcall) const
+RemotePtr<simgrid::kernel::actor::SimcallObserver> Api::execute(Transition& transition, smx_simcall_t simcall) const
{
/* FIXME: once all simcalls have observers, kill the simcall parameter and use mc_model_checker->simcall_to_string() */
transition.textual = request_to_string(simcall, transition.times_considered_);
- session_singleton->execute(transition);
+ return session_singleton->execute(transition);
}
void Api::automaton_load(const char* file) const
