+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)
+ return actor->get_host()->get_name();
+
+ const simgrid::mc::RemoteSimulation* process = &mc_model_checker->get_remote_simulation();
+
+ // Read the simgrid::xbt::string in the MCed process:
+ simgrid::mc::ActorInformation* info = actor_info_cast(actor);
+ auto remote_string_address =
+ remote(reinterpret_cast<const simgrid::xbt::string_data*>(&actor->get_host()->get_name()));
+ simgrid::xbt::string_data remote_string = process->read(remote_string_address);
+ std::vector<char> hostname(remote_string.len + 1);
+ // no need to read the terminating null byte, and thus hostname[remote_string.len] is guaranteed to be '\0'
+ process->read_bytes(hostname.data(), remote_string.len, remote(remote_string.data));
+ info->hostname = &mc_model_checker->get_host_name(hostname.data());
+ return *info->hostname;
+}
+
+std::string Api::get_actor_name(smx_actor_t actor) const
+{
+ if (mc_model_checker == nullptr)
+ return actor->get_cname();
+
+ 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);
+ }
+ return info->name;
+}
+
+std::string Api::get_actor_string(smx_actor_t actor) const
+{
+ std::string res;
+ if (actor) {
+ res = "(" + std::to_string(actor->get_pid()) + ")";
+ if (actor->get_host())
+ res += std::string(get_actor_host_name(actor)) + " (" + get_actor_name(actor) + ")";
+ else
+ res += get_actor_name(actor);
+ } else
+ res = "(0) ()";
+ return res;
+}
+
+std::string Api::get_actor_dot_label(smx_actor_t actor) const
+{
+ std::string res = "(" + std::to_string(actor->get_pid()) + ")";
+ if (actor->get_host())
+ res += get_actor_host_name(actor);
+ return res;
+}
+