X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d2e206d0539afade3722f7aa9f7a65ad8a714253..873fe7743b2a9f2eddc53ed3383bdd74bb3fe226:/src/mc/mc_comm_determinism.cpp diff --git a/src/mc/mc_comm_determinism.cpp b/src/mc/mc_comm_determinism.cpp index 018a90afa4..7e7d2b1814 100644 --- a/src/mc/mc_comm_determinism.cpp +++ b/src/mc/mc_comm_determinism.cpp @@ -4,6 +4,14 @@ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ +#include + +#include +#include +#include +#include +#include + #include "src/mc/mc_state.h" #include "src/mc/mc_comm_pattern.h" #include "src/mc/mc_request.h" @@ -11,16 +19,16 @@ #include "src/mc/mc_private.h" #include "src/mc/mc_record.h" #include "src/mc/mc_smx.h" -#include "src/mc/mc_client.h" +#include "src/mc/Client.hpp" #include "src/mc/mc_exit.h" using simgrid::mc::remote; -extern "C" { - XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_comm_determinism, mc, "Logging specific to MC communication determinism detection"); +extern "C" { + /********** Global variables **********/ xbt_dynar_t initial_communications_pattern; @@ -41,15 +49,14 @@ static e_mc_comm_pattern_difference_t compare_comm_pattern(mc_comm_pattern_t com return TAG_DIFF; if (comm1->data_size != comm2->data_size) return DATA_SIZE_DIFF; - if(comm1->data == NULL && comm2->data == NULL) + if(comm1->data == nullptr && comm2->data == NULL) return NONE_DIFF; - if(comm1->data != NULL && comm2->data !=NULL) { + if(comm1->data != nullptr && comm2->data !=NULL) { if (!memcmp(comm1->data, comm2->data, comm1->data_size)) return NONE_DIFF; return DATA_DIFF; - }else{ + } else return DATA_DIFF; - } return NONE_DIFF; } @@ -84,7 +91,7 @@ static char* print_determinism_result(e_mc_comm_pattern_difference_t diff, int p res = bprintf("%s\n Different data for communication #%d", type, cursor); break; default: - res = NULL; + res = nullptr; break; } @@ -102,7 +109,7 @@ static void update_comm_pattern(mc_comm_pattern_t comm_pattern, smx_synchro_t co 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); - if (comm_pattern->data_size == -1 && comm.comm.src_buff != NULL) { + if (comm_pattern->data_size == -1 && comm.comm.src_buff != nullptr) { size_t buff_size; mc_model_checker->process().read( &buff_size, remote(comm.comm.dst_buff_size)); @@ -128,12 +135,12 @@ static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int if (diff != NONE_DIFF) { if (comm->type == SIMIX_COMM_SEND){ initial_global_state->send_deterministic = 0; - if(initial_global_state->send_diff != NULL) + if(initial_global_state->send_diff != nullptr) xbt_free(initial_global_state->send_diff); initial_global_state->send_diff = print_determinism_result(diff, process, comm, list->index_comm + 1); }else{ initial_global_state->recv_deterministic = 0; - if(initial_global_state->recv_diff != NULL) + if(initial_global_state->recv_diff != nullptr) xbt_free(initial_global_state->recv_diff); initial_global_state->recv_diff = print_determinism_result(diff, process, comm, list->index_comm + 1); } @@ -143,7 +150,7 @@ static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int XBT_INFO("*********************************************************"); XBT_INFO("%s", initial_global_state->send_diff); xbt_free(initial_global_state->send_diff); - initial_global_state->send_diff = NULL; + initial_global_state->send_diff = nullptr; MC_print_statistics(mc_stats); mc_model_checker->exit(SIMGRID_MC_EXIT_NON_DETERMINISM); }else if(_sg_mc_comms_determinism && (!initial_global_state->send_deterministic && !initial_global_state->recv_deterministic)) { @@ -153,9 +160,9 @@ static void deterministic_comm_pattern(int process, mc_comm_pattern_t comm, int XBT_INFO("%s", initial_global_state->send_diff); XBT_INFO("%s", initial_global_state->recv_diff); xbt_free(initial_global_state->send_diff); - initial_global_state->send_diff = NULL; + initial_global_state->send_diff = nullptr; xbt_free(initial_global_state->recv_diff); - initial_global_state->recv_diff = NULL; + initial_global_state->recv_diff = nullptr; MC_print_statistics(mc_stats); mc_model_checker->exit(SIMGRID_MC_EXIT_NON_DETERMINISM); } @@ -178,7 +185,7 @@ void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type mc_comm_pattern_t pattern = xbt_new0(s_mc_comm_pattern_t, 1); pattern->data_size = -1; - pattern->data = NULL; + pattern->data = nullptr; pattern->index = initial_pattern->index_comm + xbt_dynar_length(incomplete_pattern); @@ -201,7 +208,7 @@ void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type (std::uint64_t) simcall_comm_isend__get__data(request)); pattern->tag = mpi_request.tag; - if(synchro.comm.src_buff != NULL){ + if(synchro.comm.src_buff != nullptr){ pattern->data_size = synchro.comm.src_buff_size; pattern->data = xbt_malloc0(pattern->data_size); mc_model_checker->process().read_bytes( @@ -242,9 +249,8 @@ void MC_get_comm_pattern(xbt_dynar_t list, smx_simcall_t request, e_mc_call_type pattern->rdv = mc_model_checker->process().read_string(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 { + } else xbt_die("Unexpected call_type %i", (int) call_type); - } xbt_dynar_push( xbt_dynar_get_as(incomplete_communications_pattern, issuer->pid, xbt_dynar_t), @@ -260,7 +266,7 @@ void MC_complete_comm_pattern(xbt_dynar_t list, smx_synchro_t comm_addr, unsigne int completed = 0; /* Complete comm pattern */ - xbt_dynar_foreach(xbt_dynar_get_as(incomplete_communications_pattern, issuer, xbt_dynar_t), cursor, current_comm_pattern) { + xbt_dynar_foreach(xbt_dynar_get_as(incomplete_communications_pattern, issuer, xbt_dynar_t), cursor, current_comm_pattern) if (current_comm_pattern->comm_addr == comm_addr) { update_comm_pattern(current_comm_pattern, comm_addr); completed = 1; @@ -270,17 +276,17 @@ void MC_complete_comm_pattern(xbt_dynar_t list, smx_synchro_t comm_addr, unsigne XBT_DEBUG("Remove incomplete comm pattern for process %u at cursor %u", issuer, cursor); break; } - } + if(!completed) xbt_die("Corresponding communication not found!"); mc_list_comm_pattern_t pattern = xbt_dynar_get_as( initial_communications_pattern, issuer, mc_list_comm_pattern_t); - if (!initial_global_state->initial_communications_pattern_done) { + if (!initial_global_state->initial_communications_pattern_done) /* Store comm pattern */ xbt_dynar_push(pattern->list, &comm_pattern); - } else { + else { /* Evaluate comm determinism */ deterministic_comm_pattern(issuer, comm_pattern, backtracking); pattern->index_comm++; @@ -294,13 +300,11 @@ static int MC_modelcheck_comm_determinism_main(void); static void MC_pre_modelcheck_comm_determinism(void) { - mc_state_t initial_state = NULL; - smx_process_t process; + mc_state_t initial_state = nullptr; int i; const int maxpid = MC_smx_get_maxpid(); - if (_sg_mc_visited > 0) - visited_states = xbt_dynar_new(sizeof(mc_visited_state_t), visited_state_free_voidp); + simgrid::mc::visited_states.clear(); // Create initial_communications_pattern elements: initial_communications_pattern = xbt_dynar_new(sizeof(mc_list_comm_pattern_t), MC_list_comm_pattern_free_voidp); @@ -314,7 +318,7 @@ static void MC_pre_modelcheck_comm_determinism(void) // Create incomplete_communications_pattern elements: incomplete_communications_pattern = xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp); for (i=0; i < maxpid; i++){ - xbt_dynar_t process_pattern = xbt_dynar_new(sizeof(mc_comm_pattern_t), NULL); + xbt_dynar_t process_pattern = xbt_dynar_new(sizeof(mc_comm_pattern_t), nullptr); xbt_dynar_insert_at(incomplete_communications_pattern, i, &process_pattern); } @@ -326,11 +330,9 @@ static void MC_pre_modelcheck_comm_determinism(void) mc_model_checker->wait_for_requests(); /* 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)) { - MC_state_interleave_process(initial_state, process); - } - ); + for (auto& p : mc_model_checker->process().simix_processes()) + if (simgrid::mc::process_is_enabled(&p.copy)) + MC_state_interleave_process(initial_state, &p.copy); xbt_fifo_unshift(mc_stack, initial_state); } @@ -338,12 +340,11 @@ static void MC_pre_modelcheck_comm_determinism(void) static int MC_modelcheck_comm_determinism_main(void) { - char *req_str = NULL; + char *req_str = nullptr; int value; - mc_visited_state_t visited_state = NULL; - smx_simcall_t req = NULL; - smx_process_t process = NULL; - mc_state_t state = NULL, next_state = NULL; + std::unique_ptr visited_state = nullptr; + smx_simcall_t req = nullptr; + mc_state_t state = nullptr, next_state = NULL; while (xbt_fifo_size(mc_stack) > 0) { @@ -360,32 +361,30 @@ static int MC_modelcheck_comm_determinism_main(void) if ((xbt_fifo_size(mc_stack) <= _sg_mc_max_depth) && (req = MC_state_get_request(state, &value)) - && (visited_state == NULL)) { + && (visited_state == nullptr)) { - req_str = MC_request_to_string(req, value, MC_REQUEST_SIMIX); + req_str = simgrid::mc::request_to_string(req, value, simgrid::mc::RequestType::simix); XBT_DEBUG("Execute: %s", req_str); xbt_free(req_str); - if (dot_output != NULL) { - req_str = MC_request_get_dot_output(req, value); - } + if (dot_output != nullptr) + req_str = simgrid::mc::request_get_dot_output(req, value); MC_state_set_executed_request(state, req, value); mc_stats->executed_transitions++; /* TODO : handle test and testany simcalls */ e_mc_call_type_t call = MC_CALL_TYPE_NONE; - if (_sg_mc_comms_determinism || _sg_mc_send_determinism) { + if (_sg_mc_comms_determinism || _sg_mc_send_determinism) call = MC_get_call_type(req); - } /* Answer the request */ - MC_simcall_handle(req, value); /* After this call req is no longer useful */ + simgrid::mc::handle_simcall(req, value); /* After this call req is no longer useful */ 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_handle_comm_pattern(call, req, value, nullptr, 0); /* Wait for requests (schedules processes) */ mc_model_checker->wait_for_requests(); @@ -393,39 +392,33 @@ static int MC_modelcheck_comm_determinism_main(void) /* Create the new expanded state */ next_state = MC_state_new(); - if ((visited_state = is_visited_state(next_state)) == NULL) { + if ((visited_state = simgrid::mc::is_visited_state(next_state)) == nullptr) { /* Get enabled processes and insert them in the interleave set of the next state */ - MC_EACH_SIMIX_PROCESS(process, - if (MC_process_is_enabled(process)) { - MC_state_interleave_process(next_state, process); - } - ); + for (auto& p : mc_model_checker->process().simix_processes()) + if (simgrid::mc::process_is_enabled(&p.copy)) + MC_state_interleave_process(next_state, &p.copy); - if (dot_output != NULL) + if (dot_output != nullptr) fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num, next_state->num, req_str); - } else { - - if (dot_output != NULL) - fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", state->num, visited_state->other_num == -1 ? visited_state->num : visited_state->other_num, req_str); - - } + } else if (dot_output != nullptr) + fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n", + state->num, visited_state->other_num == -1 ? visited_state->num : visited_state->other_num, req_str); xbt_fifo_unshift(mc_stack, next_state); - if (dot_output != NULL) + if (dot_output != nullptr) xbt_free(req_str); } else { - if (xbt_fifo_size(mc_stack) > _sg_mc_max_depth) { + if (xbt_fifo_size(mc_stack) > _sg_mc_max_depth) XBT_WARN("/!\\ Max depth reached ! /!\\ "); - } else if (visited_state != NULL) { + else if (visited_state != nullptr) XBT_DEBUG("State already visited (equal to state %d), exploration stopped on this path.", visited_state->other_num == -1 ? visited_state->num : visited_state->other_num); - } else { + else XBT_DEBUG("There are no more processes to interleave. (depth %d)", xbt_fifo_size(mc_stack)); - } if (!initial_global_state->initial_communications_pattern_done) initial_global_state->initial_communications_pattern_done = 1; @@ -435,15 +428,15 @@ static int MC_modelcheck_comm_determinism_main(void) 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); - visited_state = NULL; + visited_state = nullptr; /* Check for deadlocks */ - if (MC_deadlock_check()) { - MC_show_deadlock(NULL); + if (mc_model_checker->checkDeadlock()) { + MC_show_deadlock(nullptr); return SIMGRID_MC_EXIT_DEADLOCK; } - while ((state = (mc_state_t) xbt_fifo_shift(mc_stack)) != NULL) { + while ((state = (mc_state_t) xbt_fifo_shift(mc_stack)) != nullptr) 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); @@ -458,7 +451,7 @@ static int MC_modelcheck_comm_determinism_main(void) XBT_DEBUG("Delete state %d at depth %d", state->num, xbt_fifo_size(mc_stack) + 1); MC_state_delete(state, !state->in_visited_states ? 1 : 0); } - } + } } @@ -469,13 +462,11 @@ static int MC_modelcheck_comm_determinism_main(void) int MC_modelcheck_comm_determinism(void) { XBT_INFO("Check communication determinism"); - mc_reduce_kind = e_mc_reduce_none; mc_model_checker->wait_for_requests(); - if (mc_mode == MC_MODE_CLIENT) { + if (mc_mode == MC_MODE_CLIENT) // This will move somehwere else: - MC_client_handle_messages(); - } + simgrid::mc::Client::get()->handleMessages(); /* Create exploration stack */ mc_stack = xbt_fifo_new(); @@ -483,12 +474,12 @@ int MC_modelcheck_comm_determinism(void) MC_pre_modelcheck_comm_determinism(); initial_global_state = xbt_new0(s_mc_global_t, 1); - initial_global_state->snapshot = MC_take_snapshot(0); + initial_global_state->snapshot = simgrid::mc::take_snapshot(0); initial_global_state->initial_communications_pattern_done = 0; initial_global_state->recv_deterministic = 1; initial_global_state->send_deterministic = 1; - initial_global_state->recv_diff = NULL; - initial_global_state->send_diff = NULL; + initial_global_state->recv_diff = nullptr; + initial_global_state->send_diff = nullptr; return MC_modelcheck_comm_determinism_main(); }