/* Configuration support */
e_mc_reduce_t mc_reduce_kind=e_mc_reduce_unset;
+
extern int _surf_init_status;
void _mc_cfg_cb_reduce(const char *name, int pos) {
if (_surf_init_status && !_surf_do_model_check) {
xbt_cfg_set_int(_surf_cfg_set,"model-check",1);
}
+void _mc_cfg_cb_timeout(const char *name, int pos) {
+ if (_surf_init_status && !_surf_do_model_check) {
+ xbt_die("You are specifying a value to enable/disable timeout for wait requests after the initialization (through MSG_config?), but model-checking was not activated at config time (through --cfg=model-check:1). This won't work, sorry.");
+ }
+ _surf_mc_timeout= xbt_cfg_get_int(_surf_cfg_set, name);
+ xbt_cfg_set_int(_surf_cfg_set,"model-check",1);
+}
+
+void _mc_cfg_cb_max_depth(const char *name, int pos) {
+ if (_surf_init_status && !_surf_do_model_check) {
+ xbt_die("You are specifying a max depth value after the initialization (through MSG_config?), but model-checking was not activated at config time (through --cfg=model-check:1). This won't work, sorry.");
+ }
+ _surf_mc_max_depth= xbt_cfg_get_int(_surf_cfg_set, name);
+ xbt_cfg_set_int(_surf_cfg_set,"model-check",1);
+}
+
+void _mc_cfg_cb_stateful(const char *name, int pos) {
+ if (_surf_init_status && !_surf_do_model_check) {
+ xbt_die("You are trying to change stateful mode after the initialization (through MSG_config?), but model-checking was not activated at config time (through --cfg=model-check:1). This won't work, sorry.");
+ }
+ _surf_mc_stateful= xbt_cfg_get_int(_surf_cfg_set, name);
+ xbt_cfg_set_int(_surf_cfg_set,"model-check",1);
+}
+
/* MC global data structures */
mc_state_t mc_current_state = NULL;
char mc_replay_mode = FALSE;
double *mc_time = NULL;
-mc_snapshot_t initial_snapshot = NULL;
-int raw_mem_set;
/* Safety */
xbt_fifo_t mc_stack_safety = NULL;
mc_stats_t mc_stats = NULL;
+mc_global_t initial_state_safety = NULL;
/* Liveness */
mc_stats_pair_t mc_stats_pair = NULL;
xbt_fifo_t mc_stack_liveness = NULL;
-mc_snapshot_t initial_snapshot_liveness = NULL;
+mc_global_t initial_state_liveness = NULL;
int compare;
/* Local */
xbt_dict_t mc_local_variables = NULL;
/* Ignore mechanism */
-extern xbt_dynar_t mc_comparison_ignore;
+xbt_dynar_t mc_stack_comparison_ignore;
+xbt_dynar_t mc_data_bss_comparison_ignore;
+extern xbt_dynar_t mc_heap_comparison_ignore;
extern xbt_dynar_t stacks_areas;
xbt_automaton_t _mc_property_automaton = NULL;
mc_reduce_kind=e_mc_reduce_dpor;
XBT_INFO("Check a safety property");
- MC_modelcheck();
+ MC_modelcheck_safety();
} else {
}
}
-/**
- * \brief Initialize the model-checker data structures
- */
-void MC_init_safety(void)
-{
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+void MC_compare(void){
+ compare = 1;
+}
+
+void MC_init(){
+
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+
+ mc_time = xbt_new0(double, simix_process_maxpid);
+
+ /* mc_time refers to clock for each process -> ignore it for heap comparison */
+ int i;
+ for(i = 0; i<simix_process_maxpid; i++)
+ MC_ignore_heap(&(mc_time[i]), sizeof(double));
+
+ compare = 0;
+
+ /* Initialize the data structures that must be persistent across every
+ iteration of the model-checker (in RAW memory) */
+
+ MC_SET_RAW_MEM;
+
+ char *ls_path = get_libsimgrid_path();
+
+ mc_local_variables = xbt_dict_new_homogeneous(NULL);
+
+ /* Get local variables in binary for state equality detection */
+ xbt_dict_t binary_location_list = MC_get_location_list(xbt_binary_name);
+ MC_get_local_variables(xbt_binary_name, binary_location_list, &mc_local_variables);
+
+ /* Get local variables in libsimgrid for state equality detection */
+ xbt_dict_t libsimgrid_location_list = MC_get_location_list(ls_path);
+ MC_get_local_variables(ls_path, libsimgrid_location_list, &mc_local_variables);
+
+ MC_UNSET_RAW_MEM;
+
+ MC_init_memory_map_info();
+
+ /* Get .plt section (start and end addresses) for data libsimgrid and data program comparison */
+ get_libsimgrid_plt_section();
+ get_binary_plt_section();
+
+ /* Ignore some variables from xbt/ex.h used by exception e for stacks comparison */
+ MC_ignore_stack("e", "*");
+ MC_ignore_stack("__ex_cleanup", "*");
+ MC_ignore_stack("__ex_mctx_en", "*");
+ MC_ignore_stack("__ex_mctx_me", "*");
+ MC_ignore_stack("_log_ev", "*");
+ MC_ignore_stack("_throw_ctx", "*");
+ MC_ignore_stack("ctx", "*");
+
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+
+}
+
+void MC_modelcheck_safety(void)
+{
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
/* Check if MC is already initialized */
- if (initial_snapshot)
+ if (initial_state_safety)
return;
mc_time = xbt_new0(double, simix_process_maxpid);
MC_UNSET_RAW_MEM;
+ if(_surf_mc_stateful > 0){
+ MC_init();
+ }else{
+ MC_init_memory_map_info();
+ get_libsimgrid_plt_section();
+ get_binary_plt_section();
+ }
+
MC_dpor_init();
MC_SET_RAW_MEM;
/* Save the initial state */
- initial_snapshot = xbt_new0(s_mc_snapshot_t, 1);
- MC_take_snapshot(initial_snapshot);
+ initial_state_safety = xbt_new0(s_mc_global_t, 1);
+ initial_state_safety->snapshot = MC_take_snapshot();
+ //MC_take_snapshot(initial_snapshot);
MC_UNSET_RAW_MEM;
-
if(raw_mem_set)
MC_SET_RAW_MEM;
- else
- MC_UNSET_RAW_MEM;
-
-}
-void MC_compare(void){
- compare = 1;
-}
-
-
-void MC_modelcheck(void)
-{
- MC_init_safety();
MC_dpor();
+
MC_exit();
}
void MC_modelcheck_liveness(){
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
-
- /* init stuff */
- XBT_INFO("Start init mc");
-
- mc_time = xbt_new0(double, simix_process_maxpid);
-
- /* mc_time refers to clock for each process -> ignore it for heap comparison */
- int i;
- for(i = 0; i<simix_process_maxpid; i++)
- MC_ignore(&(mc_time[i]), sizeof(double));
-
- compare = 0;
-
- /* Initialize the data structures that must be persistent across every
- iteration of the model-checker (in RAW memory) */
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ MC_init();
+
MC_SET_RAW_MEM;
-
- char *ls_path = get_libsimgrid_path();
-
- mc_local_variables = xbt_dict_new_homogeneous(NULL);
-
- /* Get local variables in binary for state equality detection */
- xbt_dict_t binary_location_list = MC_get_location_list(xbt_binary_name);
- MC_get_local_variables(xbt_binary_name, binary_location_list, &mc_local_variables);
-
- /* Get local variables in libsimgrid for state equality detection */
- xbt_dict_t libsimgrid_location_list = MC_get_location_list(ls_path);
- MC_get_local_variables(ls_path, libsimgrid_location_list, &mc_local_variables);
/* Initialize statistics */
mc_stats_pair = xbt_new0(s_mc_stats_pair_t, 1);
- XBT_DEBUG("Creating stack");
-
/* Create exploration stack */
mc_stack_liveness = xbt_fifo_new();
+ initial_state_liveness = xbt_new0(s_mc_global_t, 1);
+
MC_UNSET_RAW_MEM;
MC_ddfs_init();
/* We're done */
MC_print_statistics_pairs(mc_stats_pair);
xbt_free(mc_time);
- MC_memory_exit();
- exit(0);
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+
}
*/
void MC_replay(xbt_fifo_t stack, int start)
{
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ int raw_mem = (mmalloc_get_current_heap() == raw_heap);
int value, i = 1;
char *req_str;
if(start == -1){
/* Restore the initial state */
- MC_restore_snapshot(initial_snapshot);
+ MC_restore_snapshot(initial_state_safety->snapshot);
/* At the moment of taking the snapshot the raw heap was set, so restoring
* it will set it back again, we have to unset it to continue */
MC_UNSET_RAW_MEM;
}
XBT_DEBUG("**** End Replay ****");
- if(raw_mem_set)
+ if(raw_mem)
MC_SET_RAW_MEM;
else
MC_UNSET_RAW_MEM;
void MC_replay_liveness(xbt_fifo_t stack, int all_stack)
{
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ initial_state_liveness->raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
int value;
char *req_str;
XBT_DEBUG("**** Begin Replay ****");
/* Restore the initial state */
- MC_restore_snapshot(initial_snapshot_liveness);
+ MC_restore_snapshot(initial_state_liveness->snapshot);
+
/* At the moment of taking the snapshot the raw heap was set, so restoring
* it will set it back again, we have to unset it to continue */
- MC_UNSET_RAW_MEM;
+ if(!initial_state_liveness->raw_mem_set)
+ MC_UNSET_RAW_MEM;
if(all_stack){
XBT_DEBUG("**** End Replay ****");
- if(raw_mem_set)
+ if(initial_state_liveness->raw_mem_set)
MC_SET_RAW_MEM;
else
MC_UNSET_RAW_MEM;
void MC_dump_stack_safety(xbt_fifo_t stack)
{
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
MC_show_stack_safety(stack);
void MC_dump_stack_liveness(xbt_fifo_t stack){
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
mc_pair_stateless_t pair;
MC_SET_RAW_MEM;
while ((pair = (mc_pair_stateless_t) xbt_fifo_pop(stack)) != NULL)
- MC_pair_stateless_delete(pair);
+ pair_stateless_free(pair);
MC_UNSET_RAW_MEM;
if(raw_mem_set)
MC_SET_RAW_MEM;
- else
- MC_UNSET_RAW_MEM;
}
//XBT_INFO("Executed transitions = %lu", stats->executed_transitions);
XBT_INFO("Expanded / Visited = %lf",
(double) stats->visited_pairs / stats->expanded_pairs);
- /*XBT_INFO("Exploration coverage = %lf",
- (double)stats->expanded_states / stats->state_size); */
+
+ if(mmalloc_get_current_heap() == raw_heap)
+ MC_UNSET_RAW_MEM;
}
void MC_assert(int prop)
{
- if (MC_IS_ENABLED && !prop){
+ if (MC_is_active() && !prop){
XBT_INFO("**************************");
XBT_INFO("*** PROPERTY NOT VALID ***");
XBT_INFO("**************************");
}
static void MC_assert_pair(int prop){
- if (MC_IS_ENABLED && !prop) {
+ if (MC_is_active() && !prop) {
XBT_INFO("**************************");
XBT_INFO("*** PROPERTY NOT VALID ***");
XBT_INFO("**************************");
double MC_process_clock_get(smx_process_t process)
{
- if(mc_time)
- return mc_time[process->pid];
- else
+ if(mc_time){
+ if(process != NULL)
+ return mc_time[process->pid];
+ else
+ return -1;
+ }else{
return 0;
+ }
}
void MC_automaton_load(const char *file){
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
MC_SET_RAW_MEM;
if(raw_mem_set)
MC_SET_RAW_MEM;
- else
- MC_UNSET_RAW_MEM;
}
void MC_automaton_new_propositional_symbol(const char* id, void* fct) {
- raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
MC_SET_RAW_MEM;
if(raw_mem_set)
MC_SET_RAW_MEM;
- else
- MC_UNSET_RAW_MEM;
}
/************ MC_ignore ***********/
-void MC_ignore(void *address, size_t size){
+void MC_ignore_heap(void *address, size_t size){
+
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
MC_SET_RAW_MEM;
- if(mc_comparison_ignore == NULL)
- mc_comparison_ignore = xbt_dynar_new(sizeof(mc_ignore_region_t), NULL);
+ if(mc_heap_comparison_ignore == NULL)
+ mc_heap_comparison_ignore = xbt_dynar_new(sizeof(mc_heap_ignore_region_t), NULL);
- mc_ignore_region_t region = NULL;
- region = xbt_new0(s_mc_ignore_region_t, 1);
+ mc_heap_ignore_region_t region = NULL;
+ region = xbt_new0(s_mc_heap_ignore_region_t, 1);
region->address = address;
region->size = size;
}
unsigned int cursor = 0;
- mc_ignore_region_t current_region;
- xbt_dynar_foreach(mc_comparison_ignore, cursor, current_region){
+ mc_heap_ignore_region_t current_region;
+ xbt_dynar_foreach(mc_heap_comparison_ignore, cursor, current_region){
if(current_region->address > address)
break;
}
- xbt_dynar_insert_at(mc_comparison_ignore, cursor, ®ion);
+ xbt_dynar_insert_at(mc_heap_comparison_ignore, cursor, ®ion);
MC_UNSET_RAW_MEM;
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
}
-void MC_new_stack_area(void *stack, char *name){
+void MC_ignore_data_bss(void *address, size_t size){
- if(stacks_areas == NULL)
- stacks_areas = xbt_dynar_new(sizeof(stack_region_t), NULL);
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+
+ MC_SET_RAW_MEM;
+
+ if(mc_data_bss_comparison_ignore == NULL)
+ mc_data_bss_comparison_ignore = xbt_dynar_new(sizeof(mc_data_bss_ignore_variable_t), NULL);
+
+ if(xbt_dynar_is_empty(mc_data_bss_comparison_ignore)){
+
+ mc_data_bss_ignore_variable_t var = NULL;
+ var = xbt_new0(s_mc_data_bss_ignore_variable_t, 1);
+ var->address = address;
+ var->size = size;
+
+ xbt_dynar_insert_at(mc_data_bss_comparison_ignore, 0, &var);
+
+ }else{
+
+ unsigned int cursor = 0;
+ int start = 0;
+ int end = xbt_dynar_length(mc_data_bss_comparison_ignore) - 1;
+ mc_data_bss_ignore_variable_t current_var = NULL;
+
+ while(start <= end){
+ cursor = (start + end) / 2;
+ current_var = (mc_data_bss_ignore_variable_t)xbt_dynar_get_as(mc_data_bss_comparison_ignore, cursor, mc_data_bss_ignore_variable_t);
+ if(current_var->address == address){
+ MC_UNSET_RAW_MEM;
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+ return;
+ }
+ if(current_var->address < address)
+ start = cursor + 1;
+ if(current_var->address > address)
+ end = cursor - 1;
+ }
+
+ mc_data_bss_ignore_variable_t var = NULL;
+ var = xbt_new0(s_mc_data_bss_ignore_variable_t, 1);
+ var->address = address;
+ var->size = size;
+
+ if(current_var->address < address)
+ xbt_dynar_insert_at(mc_data_bss_comparison_ignore, cursor + 1, &var);
+ else
+ xbt_dynar_insert_at(mc_data_bss_comparison_ignore, cursor, &var);
+
+ }
+
+ MC_UNSET_RAW_MEM;
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+}
+
+void MC_ignore_stack(const char *var_name, const char *frame){
+
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
MC_SET_RAW_MEM;
+
+ if(mc_stack_comparison_ignore == NULL)
+ mc_stack_comparison_ignore = xbt_dynar_new(sizeof(mc_stack_ignore_variable_t), NULL);
+
+ if(xbt_dynar_is_empty(mc_stack_comparison_ignore)){
+
+ mc_stack_ignore_variable_t var = NULL;
+ var = xbt_new0(s_mc_stack_ignore_variable_t, 1);
+ var->var_name = strdup(var_name);
+ var->frame = strdup(frame);
+
+ xbt_dynar_insert_at(mc_stack_comparison_ignore, 0, &var);
+
+ }else{
+
+ unsigned int cursor = 0;
+ int start = 0;
+ int end = xbt_dynar_length(mc_stack_comparison_ignore) - 1;
+ mc_stack_ignore_variable_t current_var = NULL;
+
+ while(start <= end){
+ cursor = (start + end) / 2;
+ current_var = (mc_stack_ignore_variable_t)xbt_dynar_get_as(mc_stack_comparison_ignore, cursor, mc_stack_ignore_variable_t);
+ if(strcmp(current_var->frame, frame) == 0){
+ if(strcmp(current_var->var_name, var_name) == 0){
+ MC_UNSET_RAW_MEM;
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+ return;
+ }
+ if(strcmp(current_var->var_name, var_name) < 0)
+ start = cursor + 1;
+ if(strcmp(current_var->var_name, var_name) > 0)
+ end = cursor - 1;
+ }
+ if(strcmp(current_var->frame, frame) < 0)
+ start = cursor + 1;
+ if(strcmp(current_var->frame, frame) > 0)
+ end = cursor - 1;
+ }
+
+ mc_stack_ignore_variable_t var = NULL;
+ var = xbt_new0(s_mc_stack_ignore_variable_t, 1);
+ var->var_name = strdup(var_name);
+ var->frame = strdup(frame);
+
+ if(strcmp(current_var->frame, frame) < 0)
+ xbt_dynar_insert_at(mc_stack_comparison_ignore, cursor + 1, &var);
+ else
+ xbt_dynar_insert_at(mc_stack_comparison_ignore, cursor, &var);
+
+ }
+
+ MC_UNSET_RAW_MEM;
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
+
+}
+
+void MC_new_stack_area(void *stack, char *name, void* context, size_t size){
+
+ int raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
+
+ MC_SET_RAW_MEM;
+ if(stacks_areas == NULL)
+ stacks_areas = xbt_dynar_new(sizeof(stack_region_t), NULL);
+
stack_region_t region = NULL;
region = xbt_new0(s_stack_region_t, 1);
region->address = stack;
region->process_name = strdup(name);
+ region->context = context;
+ region->size = size;
xbt_dynar_push(stacks_areas, ®ion);
+
MC_UNSET_RAW_MEM;
+
+ if(raw_mem_set)
+ MC_SET_RAW_MEM;
}
/************ DWARF ***********/
dw_location_t new_element = xbt_new0(s_dw_location_t, 1);
new_element->type = e_dw_bregister_op;
new_element->location.breg_op.reg = atoi(strtok(tok2, "DW_OP_breg"));
- new_element->location.breg_op.offset = atoi(xbt_dynar_get_as(tokens2, 2, char*));
+ new_element->location.breg_op.offset = atoi(xbt_dynar_get_as(tokens2, 1, char*));
xbt_dynar_push(loc->location.compose, &new_element);
}else if(strncmp(tok2, "DW_OP_lit", 9) == 0){
dw_location_t new_element = xbt_new0(s_dw_location_t, 1);