return MC_smx_get_maxpid();
}
+int mc_api::get_actors_size() const
+{
+ return mc_model_checker->get_remote_simulation().actors().size();
+}
+
void mc_api::copy_incomplete_comm_pattern(const simgrid::mc::State* state) const
{
MC_state_copy_incomplete_communications_pattern((simgrid::mc::State*)state);
}
-void mc_api::copy_index_comm_pattern(const simgrid::mc::State* state) const
+void mc_api::copy_index_comm_pattern(simgrid::mc::State* state) const
{
- MC_state_copy_index_communications_pattern((simgrid::mc::State*)state);
+ state->communication_indices_.clear();
+ for (auto const& list_process_comm : initial_communications_pattern)
+ state->communication_indices_.push_back(list_process_comm.index_comm);
}
kernel::activity::CommImpl* mc_api::get_pattern_comm_addr(smx_simcall_t request) const
return buffer;
}
+std::vector<char> mc_api::get_pattern_comm_data(mc::RemotePtr<kernel::activity::CommImpl> const& comm_addr) const
+{
+ simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+ mc_model_checker->get_remote_simulation().read(temp_comm, comm_addr);
+ const simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer();
+
+ std::vector<char> buffer {};
+ if (comm->src_buff_ != nullptr) {
+ buffer.resize(comm->src_buff_size_);
+ mc_model_checker->get_remote_simulation().read_bytes(buffer.data(), buffer.size(),
+ remote(comm->src_buff_));
+ }
+ return buffer;
+}
+
const char* mc_api::get_actor_host_name(smx_actor_t actor) const
{
const char* host_name = MC_smx_actor_get_host_name(actor);
return host_name;
}
+bool mc_api::check_send_request_detached(smx_simcall_t const& simcall) const
+{
+ simgrid::smpi::Request mpi_request;
+ mc_model_checker->get_remote_simulation().read(
+ &mpi_request, remote(static_cast<smpi::Request*>(simcall_comm_isend__get__data(simcall))));
+ return mpi_request.detached();
+}
+
+smx_actor_t mc_api::get_src_actor(mc::RemotePtr<kernel::activity::CommImpl> const& comm_addr) const
+{
+ simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+ mc_model_checker->get_remote_simulation().read(temp_comm, comm_addr);
+ const simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer();
+
+ auto src_proc = mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(comm->src_actor_.get()));
+ return src_proc;
+}
+
+smx_actor_t mc_api::get_dst_actor(mc::RemotePtr<kernel::activity::CommImpl> const& comm_addr) const
+{
+ simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
+ mc_model_checker->get_remote_simulation().read(temp_comm, comm_addr);
+ const simgrid::kernel::activity::CommImpl* comm = temp_comm.get_buffer();
+
+ auto dst_proc = mc_model_checker->get_remote_simulation().resolve_actor(simgrid::mc::remote(comm->dst_actor_.get()));
+ return dst_proc;
+}
+
std::size_t mc_api::get_remote_heap_bytes() const
{
RemoteSimulation& process = mc_model_checker->get_remote_simulation();
MC_show_deadlock();
}
-smx_actor_t mc_api::mc_smx_simcall_get_issuer(s_smx_simcall const* req) const
+smx_actor_t mc_api::simcall_get_issuer(s_smx_simcall const* req) const
{
return MC_smx_simcall_get_issuer(req);
}
return simgrid::mc::request_get_dot_output(req, value);
}
-const char* mc_api::simix_simcall_name(simgrid::simix::Simcall kind) const
+const char* mc_api::simcall_get_name(simgrid::simix::Simcall kind) const
{
return SIMIX_simcall_name(kind);
}
}
#endif
+void mc_api::restore_state(std::shared_ptr<simgrid::mc::Snapshot> system_state) const
+{
+ system_state->restore(&mc_model_checker->get_remote_simulation());
+}
+
bool mc_api::snapshot_equal(const Snapshot* s1, const Snapshot* s2) const
{
return simgrid::mc::snapshot_equal(s1, s2);
session->close();
}
-void mc_api::s_restore_initial_state() const
+void mc_api::restore_initial_state() const
{
session->restore_initial_state();
}
session->execute(transition);
}
-void mc_api::s_log_state() const
+void mc_api::log_state() const
{
session->log_state();
}