static void update_comm_pattern(mc_comm_pattern_t comm_pattern, smx_synchro_t comm_addr)
{
s_smx_synchro_t comm;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&comm, comm_addr, sizeof(comm));
smx_process_t src_proc = MC_smx_resolve_process(comm.comm.src_proc);
comm_pattern->dst_host = MC_smx_process_get_host_name(dst_proc);
if (comm_pattern->data_size == -1 && comm.comm.src_buff != NULL) {
size_t buff_size;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&buff_size, comm.comm.dst_buff_size, sizeof(buff_size));
comm_pattern->data_size = buff_size;
comm_pattern->data = xbt_malloc0(comm_pattern->data_size);
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
comm_pattern->data, comm.comm.src_buff, comm_pattern->data_size);
}
}
pattern->comm_addr = simcall_comm_isend__get__result(request);
s_smx_synchro_t synchro;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&synchro, pattern->comm_addr, sizeof(synchro));
char* remote_name;
- MC_process_read_simple(&mc_model_checker->process, &remote_name,
+ MC_process_read_simple(&mc_model_checker->process(), &remote_name,
synchro.comm.rdv ? &synchro.comm.rdv->name : &synchro.comm.rdv_cpy->name,
sizeof(remote_name));
pattern->rdv =
- MC_process_read_string(&mc_model_checker->process, remote_name);
+ MC_process_read_string(&mc_model_checker->process(), remote_name);
pattern->src_proc = MC_smx_resolve_process(synchro.comm.src_proc)->pid;
pattern->src_host = MC_smx_process_get_host_name(issuer);
struct s_smpi_mpi_request mpi_request;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&mpi_request, (MPI_Request) simcall_comm_isend__get__data(request),
sizeof(mpi_request));
pattern->tag = mpi_request.tag;
if(synchro.comm.src_buff != NULL){
pattern->data_size = synchro.comm.src_buff_size;
pattern->data = xbt_malloc0(pattern->data_size);
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
pattern->data, synchro.comm.src_buff, pattern->data_size);
}
if(mpi_request.detached){
pattern->comm_addr = simcall_comm_irecv__get__result(request);
struct s_smpi_mpi_request mpi_request;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&mpi_request, (MPI_Request) simcall_comm_irecv__get__data(request),
sizeof(mpi_request));
pattern->tag = mpi_request.tag;
s_smx_synchro_t synchro;
- MC_process_read_simple(&mc_model_checker->process,
+ MC_process_read_simple(&mc_model_checker->process(),
&synchro, pattern->comm_addr, sizeof(synchro));
char* remote_name;
- MC_process_read_simple(&mc_model_checker->process, &remote_name,
+ MC_process_read_simple(&mc_model_checker->process(), &remote_name,
synchro.comm.rdv ? &synchro.comm.rdv->name : &synchro.comm.rdv_cpy->name,
sizeof(remote_name));
pattern->rdv =
- MC_process_read_string(&mc_model_checker->process, remote_name);
+ MC_process_read_string(&mc_model_checker->process(), remote_name);
pattern->dst_proc = MC_smx_resolve_process(synchro.comm.dst_proc)->pid;
pattern->dst_host = MC_smx_process_get_host_name(issuer);
} else {
static void MC_pre_modelcheck_comm_determinism(void)
{
- MC_SET_MC_HEAP;
-
mc_state_t initial_state = NULL;
smx_process_t process;
int i;
}
initial_state = MC_state_new();
- MC_SET_STD_HEAP;
XBT_DEBUG("********* Start communication determinism verification *********");
/* Wait for requests (schedules processes) */
MC_wait_for_requests();
- MC_SET_MC_HEAP;
-
/* Get an enabled process and insert it in the interleave set of the initial state */
MC_EACH_SIMIX_PROCESS(process,
if (MC_process_is_enabled(process)) {
);
xbt_fifo_unshift(mc_stack, initial_state);
-
- MC_SET_STD_HEAP;
-
}
static void MC_modelcheck_comm_determinism_main(void)
xbt_free(req_str);
if (dot_output != NULL) {
- MC_SET_MC_HEAP;
req_str = MC_request_get_dot_output(req, value);
- MC_SET_STD_HEAP;
}
MC_state_set_executed_request(state, req, value);
/* Answer the request */
MC_simcall_handle(req, value); /* After this call req is no longer useful */
- MC_SET_MC_HEAP;
if(!initial_global_state->initial_communications_pattern_done)
MC_handle_comm_pattern(call, req, value, initial_communications_pattern, 0);
else
MC_handle_comm_pattern(call, req, value, NULL, 0);
- MC_SET_STD_HEAP;
/* Wait for requests (schedules processes) */
MC_wait_for_requests();
/* Create the new expanded state */
- MC_SET_MC_HEAP;
-
next_state = MC_state_new();
if ((visited_state = is_visited_state(next_state)) == NULL) {
if (dot_output != NULL)
xbt_free(req_str);
- MC_SET_STD_HEAP;
-
} else {
if (xbt_fifo_size(mc_stack) > _sg_mc_max_depth) {
XBT_DEBUG("There are no more processes to interleave. (depth %d)", xbt_fifo_size(mc_stack));
}
- MC_SET_MC_HEAP;
-
if (!initial_global_state->initial_communications_pattern_done)
initial_global_state->initial_communications_pattern_done = 1;
MC_state_delete(state, !state->in_visited_states ? 1 : 0);
XBT_DEBUG("Delete state %d at depth %d", state->num, xbt_fifo_size(mc_stack) + 1);
- MC_SET_STD_HEAP;
-
visited_state = NULL;
/* Check for deadlocks */
return;
}
- MC_SET_MC_HEAP;
-
while ((state = (mc_state_t) xbt_fifo_shift(mc_stack)) != NULL) {
if (MC_state_interleave_size(state) && xbt_fifo_size(mc_stack) < _sg_mc_max_depth) {
/* We found a back-tracking point, let's loop */
XBT_DEBUG("Back-tracking to state %d at depth %d", state->num, xbt_fifo_size(mc_stack) + 1);
xbt_fifo_unshift(mc_stack, state);
- MC_SET_STD_HEAP;
MC_replay(mc_stack);
MC_state_delete(state, !state->in_visited_states ? 1 : 0);
}
}
-
- MC_SET_STD_HEAP;
}
}
MC_print_statistics(mc_stats);
- MC_SET_STD_HEAP;
-
exit(0);
}
void MC_modelcheck_comm_determinism(void)
{
+ XBT_INFO("Check communication determinism");
+ mc_reduce_kind = e_mc_reduce_none;
+ MC_wait_for_requests();
+
if (mc_mode == MC_MODE_CLIENT) {
// This will move somehwere else:
MC_client_handle_messages();
}
- xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
/* Create exploration stack */
mc_stack = xbt_fifo_new();
- MC_SET_STD_HEAP;
-
MC_pre_modelcheck_comm_determinism();
- MC_SET_MC_HEAP;
initial_global_state = xbt_new0(s_mc_global_t, 1);
initial_global_state->snapshot = MC_take_snapshot(0);
initial_global_state->initial_communications_pattern_done = 0;
initial_global_state->recv_diff = NULL;
initial_global_state->send_diff = NULL;
- MC_SET_STD_HEAP;
-
MC_modelcheck_comm_determinism_main();
-
- mmalloc_set_current_heap(heap);
}
}