static void update_comm_pattern(
simgrid::mc::PatternCommunication* comm_pattern,
- simgrid::mc::RemotePtr<simgrid::simix::Comm> comm_addr)
+ simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr)
{
// HACK, type punning
- simgrid::mc::Remote<simgrid::simix::Comm> temp_comm;
+ simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
mc_model_checker->process().read(temp_comm, comm_addr);
- simgrid::simix::Comm* comm =
- static_cast<simgrid::simix::Comm*>(temp_comm.data());
+ simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
- smx_process_t src_proc = mc_model_checker->process().resolveProcess(
- simgrid::mc::remote(comm->src_proc));
- smx_process_t dst_proc = mc_model_checker->process().resolveProcess(
- simgrid::mc::remote(comm->dst_proc));
+ smx_actor_t src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->src_proc));
+ smx_actor_t dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc));
comm_pattern->src_proc = src_proc->pid;
comm_pattern->dst_proc = dst_proc->pid;
- comm_pattern->src_host = MC_smx_process_get_host_name(src_proc);
- comm_pattern->dst_host = MC_smx_process_get_host_name(dst_proc);
+ comm_pattern->src_host = MC_smx_actor_get_host_name(src_proc);
+ comm_pattern->dst_host = MC_smx_actor_get_host_name(dst_proc);
if (comm_pattern->data.size() == 0 && comm->src_buff != nullptr) {
size_t buff_size;
mc_model_checker->process().read(
void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type_t call_type, int backtracking)
{
- const smx_process_t issuer = MC_smx_simcall_get_issuer(request);
+ const smx_actor_t issuer = MC_smx_simcall_get_issuer(request);
simgrid::mc::PatternCommunicationList* initial_pattern = xbt_dynar_get_as(
initial_communications_pattern, issuer->pid, simgrid::mc::PatternCommunicationList*);
xbt_dynar_t incomplete_pattern = xbt_dynar_get_as(
pattern->type = simgrid::mc::PatternCommunicationType::send;
pattern->comm_addr = simcall_comm_isend__get__result(request);
- simgrid::mc::Remote<simgrid::simix::Comm> temp_synchro;
+ simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_synchro;
mc_model_checker->process().read(temp_synchro, remote(
- static_cast<simgrid::simix::Comm*>(pattern->comm_addr)));
- simgrid::simix::Comm* synchro =
- static_cast<simgrid::simix::Comm*>(temp_synchro.data());
+ static_cast<simgrid::kernel::activity::Comm*>(pattern->comm_addr)));
+ simgrid::kernel::activity::Comm* synchro =
+ static_cast<simgrid::kernel::activity::Comm*>(temp_synchro.getBuffer());
char* remote_name = mc_model_checker->process().read<char*>(
(std::uint64_t)(synchro->mbox ? &synchro->mbox->name : &synchro->mbox_cpy->name));
pattern->rdv = mc_model_checker->process().read_string(remote_name);
- pattern->src_proc = mc_model_checker->process().resolveProcess(
- simgrid::mc::remote(synchro->src_proc))->pid;
- pattern->src_host = MC_smx_process_get_host_name(issuer);
+ pattern->src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(synchro->src_proc))->pid;
+ pattern->src_host = MC_smx_actor_get_host_name(issuer);
struct s_smpi_mpi_request mpi_request =
mc_model_checker->process().read<s_smpi_mpi_request>(
&mpi_request, remote((struct s_smpi_mpi_request*)simcall_comm_irecv__get__data(request)));
pattern->tag = mpi_request.tag;
- simgrid::mc::Remote<simgrid::simix::Comm> temp_comm;
+ simgrid::mc::Remote<simgrid::kernel::activity::Comm> temp_comm;
mc_model_checker->process().read(temp_comm, remote(
- static_cast<simgrid::simix::Comm*>(pattern->comm_addr)));
- simgrid::simix::Comm* comm =
- static_cast<simgrid::simix::Comm*>(temp_comm.data());
+ static_cast<simgrid::kernel::activity::Comm*>(pattern->comm_addr)));
+ simgrid::kernel::activity::Comm* comm = temp_comm.getBuffer();
char* remote_name;
mc_model_checker->process().read(&remote_name,
remote(comm->mbox ? &comm->mbox->name : &comm->mbox_cpy->name));
pattern->rdv = mc_model_checker->process().read_string(remote_name);
- pattern->dst_proc = mc_model_checker->process().resolveProcess(
- simgrid::mc::remote(comm->dst_proc))->pid;
- pattern->dst_host = MC_smx_process_get_host_name(issuer);
+ pattern->dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc))->pid;
+ pattern->dst_host = MC_smx_actor_get_host_name(issuer);
} else
xbt_die("Unexpected call_type %i", (int) call_type);
void CommunicationDeterminismChecker::complete_comm_pattern(
- xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::simix::Comm> comm_addr,
+ xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::Comm> comm_addr,
unsigned int issuer, int backtracking)
{
simgrid::mc::PatternCommunication* current_comm_pattern;
}
std::unique_ptr<simgrid::mc::State> initial_state =
- std::unique_ptr<simgrid::mc::State>(MC_state_new(++expandedStatesCount_));
+ std::unique_ptr<simgrid::mc::State>(new simgrid::mc::State(++expandedStatesCount_));
XBT_DEBUG("********* Start communication determinism verification *********");
- /* Get an enabled process and insert it in the interleave set of the initial state */
- for (auto& p : mc_model_checker->process().simix_processes())
- if (simgrid::mc::process_is_enabled(&p.copy))
- initial_state->interleave(&p.copy);
+ /* Get an enabled actor and insert it in the interleave set of the initial state */
+ for (auto& actor : mc_model_checker->process().actors())
+ if (simgrid::mc::actor_is_enabled(actor.copy.getBuffer()))
+ initial_state->interleave(actor.copy.getBuffer());
stack_.push_back(std::move(initial_state));
}
static inline
bool all_communications_are_finished()
{
- for (size_t current_process = 1; current_process < MC_smx_get_maxpid(); current_process++) {
- xbt_dynar_t pattern = xbt_dynar_get_as(
- incomplete_communications_pattern, current_process, xbt_dynar_t);
+ for (size_t current_actor = 1; current_actor < MC_smx_get_maxpid(); current_actor++) {
+ xbt_dynar_t pattern = xbt_dynar_get_as(incomplete_communications_pattern, current_actor, xbt_dynar_t);
if (!xbt_dynar_is_empty(pattern)) {
XBT_DEBUG("Some communications are not finished, cannot stop the exploration ! State not visited.");
return false;
/* because we got a copy of the executed request, we have to fetch the
real one, pointed by the request field of the issuer process */
- const smx_process_t issuer = MC_smx_simcall_get_issuer(saved_req);
+ const smx_actor_t issuer = MC_smx_simcall_get_issuer(saved_req);
smx_simcall_t req = &issuer->simcall;
/* TODO : handle test and testany simcalls */
/* Create the new expanded state */
std::unique_ptr<simgrid::mc::State> next_state =
- std::unique_ptr<simgrid::mc::State>(MC_state_new(++expandedStatesCount_));
+ std::unique_ptr<simgrid::mc::State>(new simgrid::mc::State(++expandedStatesCount_));
/* If comm determinism verification, we cannot stop the exploration if
- some communications are not finished (at least, data are transfered).
+ some communications are not finished (at least, data are transferred).
These communications are incomplete and they cannot be analyzed and
compared with the initial pattern. */
bool compare_snapshots = all_communications_are_finished()
|| (visited_state = visitedStates_.addVisitedState(
expandedStatesCount_, next_state.get(), compare_snapshots)) == nullptr) {
- /* Get enabled processes and insert them in the interleave set of the next state */
- for (auto& p : mc_model_checker->process().simix_processes())
- if (simgrid::mc::process_is_enabled(&p.copy))
- next_state->interleave(&p.copy);
+ /* Get enabled actors and insert them in the interleave set of the next state */
+ for (auto& actor : mc_model_checker->process().actors())
+ if (simgrid::mc::actor_is_enabled(actor.copy.getBuffer()))
+ next_state->interleave(actor.copy.getBuffer());
if (dot_output != nullptr)
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
