From: Gabriel Corona Date: Mon, 30 Jun 2014 11:06:12 +0000 (+0200) Subject: [mc] Make state/snapshot comparison work with SMPI variable privatisation X-Git-Tag: v3_12~890^2 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/e102d3275d9234526b53423b8a8e5bbd68ce5891 [mc] Make state/snapshot comparison work with SMPI variable privatisation Changes : * a snapshot region now has a standard address (address in the virtual process) and permanent address (address of the privatisation region, where the memory is always mapped event when another process is active); * handle privatised memory regions on snapshot and snapshot restore; * compare global vaiable separately for each simulated process; * the ID of the simulated must be passed everywhere; * mc_snapshot_read() and friends as well as DWARF expression can be evaluated in the context of a given simulated process and fetch the data in the corresponding privatisation region. --- diff --git a/include/xbt/mmalloc.h b/include/xbt/mmalloc.h index 13222c6f1d..191d3cc3e2 100644 --- a/include/xbt/mmalloc.h +++ b/include/xbt/mmalloc.h @@ -71,7 +71,7 @@ struct s_dw_type; int mmalloc_compare_heap(struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2); int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2); int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t to_ignore1, xbt_dynar_t to_ignore2); -int compare_heap_area(void *area1, void* area2, struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_dynar_t previous, struct s_dw_type *type, int pointer_level); +int compare_heap_area(int process_index, void *area1, void* area2, struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_dynar_t previous, struct s_dw_type *type, int pointer_level); void reset_heap_information(void); size_t mmalloc_get_bytes_used(xbt_mheap_t); diff --git a/src/include/mc/datatypes.h b/src/include/mc/datatypes.h index cd8caab749..ffc5d6f5bc 100644 --- a/src/include/mc/datatypes.h +++ b/src/include/mc/datatypes.h @@ -38,6 +38,7 @@ typedef struct s_stack_region{ void *context; size_t size; int block; + int process_index; }s_stack_region_t, *stack_region_t; void heap_ignore_region_free(mc_heap_ignore_region_t r); diff --git a/src/include/mc/mc.h b/src/include/mc/mc.h index 3922d533a3..1368b59bbf 100644 --- a/src/include/mc/mc.h +++ b/src/include/mc/mc.h @@ -82,7 +82,7 @@ XBT_PUBLIC(void) MC_ignore_heap(void *address, size_t size); XBT_PUBLIC(void) MC_remove_ignore_heap(void *address, size_t size); XBT_PUBLIC(void) MC_ignore_local_variable(const char *var_name, const char *frame); XBT_PUBLIC(void) MC_ignore_global_variable(const char *var_name); -void MC_new_stack_area(void *stack, char *name, void *context, size_t size); +XBT_PUBLIC(void) MC_new_stack_area(void *stack, smx_process_t process, void *context, size_t size); /********************************* Memory *************************************/ XBT_PUBLIC(void) MC_memory_init(void); /* Initialize the memory subsystem */ diff --git a/src/mc/mc_checkpoint.c b/src/mc/mc_checkpoint.c index 26506342d0..dd6eccc325 100644 --- a/src/mc/mc_checkpoint.c +++ b/src/mc/mc_checkpoint.c @@ -7,8 +7,11 @@ #define _GNU_SOURCE #define UNW_LOCAL_ONLY + #include #include + +#include "internal_config.h" #include "mc_private.h" #include "xbt/module.h" #include @@ -62,6 +65,9 @@ static void local_variable_free_voidp(void *v) void MC_region_destroy(mc_mem_region_t reg) { + if (reg) + return; + //munmap(reg->data, reg->size); xbt_free(reg->data); if (reg->page_numbers) { @@ -73,8 +79,9 @@ void MC_region_destroy(mc_mem_region_t reg) void MC_free_snapshot(mc_snapshot_t snapshot) { unsigned int i; - for (i = 0; i < NB_REGIONS; i++) + for (i = 0; i < NB_REGIONS; i++) { MC_region_destroy(snapshot->regions[i]); + } xbt_free(snapshot->stack_sizes); xbt_dynar_free(&(snapshot->stacks)); @@ -95,27 +102,36 @@ void MC_free_snapshot(mc_snapshot_t snapshot) /******************************* Snapshot regions ********************************/ /*********************************************************************************/ -static mc_mem_region_t mc_region_new_dense(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg) + static mc_mem_region_t mc_region_new_dense(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t ref_reg) { mc_mem_region_t new_reg = xbt_new(s_mc_mem_region_t, 1); new_reg->start_addr = start_addr; + new_reg->permanent_addr = permanent_addr; new_reg->data = NULL; new_reg->size = size; new_reg->page_numbers = NULL; new_reg->data = xbt_malloc(size); - memcpy(new_reg->data, start_addr, size); + memcpy(new_reg->data, permanent_addr, size); XBT_DEBUG("New region : type : %d, data : %p (real addr %p), size : %zu", - type, new_reg->data, start_addr, size); + type, new_reg->data, permanent_addr, size); return new_reg; } -static mc_mem_region_t MC_region_new(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg) +/** @brief Take a snapshot of a given region + * + * @param type + * @param start_addr Address of the region in the simulated process + * @param permanent_addr Permanent address of this data (for privatized variables, this is the virtual address of the privatized mapping) + * @param size Size of the data* + * @param ref_reg Reference corresponding region + */ +static mc_mem_region_t MC_region_new(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t ref_reg) { if (_sg_mc_sparse_checkpoint) { - return mc_region_new_sparse(type, start_addr, size, ref_reg); + return mc_region_new_sparse(type, start_addr, permanent_addr, size, ref_reg); } else { - return mc_region_new_dense(type, start_addr, size, ref_reg); + return mc_region_new_dense(type, start_addr, permanent_addr, size, ref_reg); } } @@ -134,7 +150,7 @@ static void MC_region_restore(mc_mem_region_t reg, mc_mem_region_t ref_reg) /*FIXME: check if start_addr is still mapped, if it is not, then map it before copying the data */ if (!reg->page_numbers) { - memcpy(reg->start_addr, reg->data, reg->size); + memcpy(reg->permanent_addr, reg->data, reg->size); } else { mc_region_restore_sparse(reg, ref_reg); } @@ -142,44 +158,53 @@ static void MC_region_restore(mc_mem_region_t reg, mc_mem_region_t ref_reg) } static void MC_snapshot_add_region(mc_snapshot_t snapshot, int type, - void *start_addr, size_t size) + void *start_addr, void* permanent_addr, size_t size) { mc_mem_region_t ref_reg = mc_model_checker->parent_snapshot ? mc_model_checker->parent_snapshot->regions[type] : NULL; - mc_mem_region_t new_reg = MC_region_new(type, start_addr, size, ref_reg); + mc_mem_region_t new_reg = MC_region_new(type, start_addr, start_addr, size, ref_reg); snapshot->regions[type] = new_reg; return; } static void MC_get_memory_regions(mc_snapshot_t snapshot) { - size_t i; void *start_heap = ((xbt_mheap_t) std_heap)->base; void *end_heap = ((xbt_mheap_t) std_heap)->breakval; - MC_snapshot_add_region(snapshot, 0, start_heap, + MC_snapshot_add_region(snapshot, 0, start_heap, start_heap, (char *) end_heap - (char *) start_heap); snapshot->heap_bytes_used = mmalloc_get_bytes_used(std_heap); + snapshot->privatization_regions = NULL; - MC_snapshot_add_region(snapshot, 1, mc_libsimgrid_info->start_rw, - mc_libsimgrid_info->end_rw - - mc_libsimgrid_info->start_rw); - if (!smpi_privatize_global_variables) { - MC_snapshot_add_region(snapshot, 2, mc_binary_info->start_rw, - mc_binary_info->end_rw - mc_binary_info->start_rw); - snapshot->privatization_regions = NULL; - snapshot->privatization_index = -1; - } else { + MC_snapshot_add_region(snapshot, 1, + mc_libsimgrid_info->start_rw, mc_libsimgrid_info->start_rw, + mc_libsimgrid_info->end_rw - mc_libsimgrid_info->start_rw); + +#ifdef HAVE_SMPI + size_t i; + if (smpi_privatize_global_variables && smpi_process_count()) { + // Snapshot the global variable of the application separately for each + // simulated process: snapshot->privatization_regions = - xbt_new(mc_mem_region_t, SIMIX_process_count()); - for (i = 0; i < SIMIX_process_count(); i++) { + xbt_new(mc_mem_region_t, smpi_process_count()); + for (i = 0; i < smpi_process_count(); i++) { mc_mem_region_t ref_reg = mc_model_checker->parent_snapshot ? mc_model_checker->parent_snapshot->privatization_regions[i] : NULL; snapshot->privatization_regions[i] = - MC_region_new(-1, mappings[i], size_data_exe, ref_reg); + MC_region_new(-1, mc_binary_info->start_rw, mappings[i], size_data_exe, ref_reg); } snapshot->privatization_index = loaded_page; + snapshot->regions[2] = NULL; + } else +#endif + { + MC_snapshot_add_region(snapshot, 2, + mc_binary_info->start_rw, mc_binary_info->start_rw, + mc_binary_info->end_rw - mc_binary_info->start_rw); + snapshot->privatization_regions = NULL; + snapshot->privatization_index = -1; } } @@ -335,7 +360,7 @@ static bool mc_valid_variable(dw_variable_t var, dw_frame_t scope, } static void mc_fill_local_variables_values(mc_stack_frame_t stack_frame, - dw_frame_t scope, xbt_dynar_t result) + dw_frame_t scope, int process_index, xbt_dynar_t result) { void *ip = (void *) stack_frame->ip; if (ip < scope->low_pc || ip >= scope->high_pc) @@ -369,7 +394,7 @@ static void mc_fill_local_variables_values(mc_stack_frame_t stack_frame, current_variable->object_info, &(stack_frame->unw_cursor), (void *) stack_frame->frame_base, - NULL); + NULL, process_index); } else { xbt_die("No address"); } @@ -380,11 +405,11 @@ static void mc_fill_local_variables_values(mc_stack_frame_t stack_frame, // Recursive processing of nested scopes: dw_frame_t nested_scope = NULL; xbt_dynar_foreach(scope->scopes, cursor, nested_scope) { - mc_fill_local_variables_values(stack_frame, nested_scope, result); + mc_fill_local_variables_values(stack_frame, nested_scope, process_index, result); } } -static xbt_dynar_t MC_get_local_variables_values(xbt_dynar_t stack_frames) +static xbt_dynar_t MC_get_local_variables_values(xbt_dynar_t stack_frames, int process_index) { unsigned cursor1 = 0; @@ -393,7 +418,7 @@ static xbt_dynar_t MC_get_local_variables_values(xbt_dynar_t stack_frames) xbt_dynar_new(sizeof(local_variable_t), local_variable_free_voidp); xbt_dynar_foreach(stack_frames, cursor1, stack_frame) { - mc_fill_local_variables_values(stack_frame, stack_frame->frame, variables); + mc_fill_local_variables_values(stack_frame, stack_frame->frame, process_index, variables); } return variables; @@ -484,7 +509,8 @@ static xbt_dynar_t MC_take_snapshot_stacks(mc_snapshot_t * snapshot) xbt_dynar_foreach(stacks_areas, cursor, current_stack) { mc_snapshot_stack_t st = xbt_new(s_mc_snapshot_stack_t, 1); st->stack_frames = MC_unwind_stack_frames(current_stack->context); - st->local_variables = MC_get_local_variables_values(st->stack_frames); + st->local_variables = MC_get_local_variables_values(st->stack_frames, current_stack->process_index); + st->process_index = current_stack->process_index; unw_word_t sp = xbt_dynar_get_as(st->stack_frames, 0, mc_stack_frame_t)->sp; @@ -631,8 +657,11 @@ void MC_restore_snapshot(mc_snapshot_t snapshot) parent_snapshot ? parent_snapshot->regions[i] : NULL); } +#ifdef HAVE_SMPI if (snapshot->privatization_regions) { - for (i = 0; i < SIMIX_process_count(); i++) { + // Restore the global variables of the application separately for each + // simulated process: + for (i = 0; i < smpi_process_count(); i++) { if (snapshot->privatization_regions[i]) { MC_region_restore(snapshot->privatization_regions[i], parent_snapshot ? parent_snapshot->privatization_regions[i] : NULL); @@ -640,6 +669,7 @@ void MC_restore_snapshot(mc_snapshot_t snapshot) } switch_data_segment(snapshot->privatization_index); } +#endif if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) { mc_softdirty_reset(); diff --git a/src/mc/mc_compare.cpp b/src/mc/mc_compare.cpp index a00aa375bf..1891f31d8a 100644 --- a/src/mc/mc_compare.cpp +++ b/src/mc/mc_compare.cpp @@ -8,8 +8,13 @@ #include #include +#include "internal_config.h" #include "mc_private.h" +#ifdef HAVE_SMPI +#include "smpi/private.h" +#endif + #include "xbt/mmalloc.h" #include "xbt/mmalloc/mmprivate.h" @@ -87,6 +92,7 @@ static int add_compared_pointers(mc_compare_state& state, void *p1, void *p2) } static int compare_areas_with_type(struct mc_compare_state& state, + int process_index, void* real_area1, mc_snapshot_t snapshot1, mc_mem_region_t region1, void* real_area2, mc_snapshot_t snapshot2, mc_mem_region_t region2, dw_type_t type, int pointer_level) @@ -146,7 +152,7 @@ static int compare_areas_with_type(struct mc_compare_state& state, } for (i = 0; i < type->element_count; i++) { size_t off = i * elm_size; - res = compare_areas_with_type(state, + res = compare_areas_with_type(state, process_index, (char*) real_area1 + off, snapshot1, region1, (char*) real_area2 + off, snapshot2, region2, type->subtype, pointer_level); @@ -186,7 +192,7 @@ static int compare_areas_with_type(struct mc_compare_state& state, && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2))) return 1; // The pointers are both in the heap: - return compare_heap_area(addr_pointed1, addr_pointed2, snapshot1, + return compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1, snapshot2, NULL, type->subtype, pointer_level); } @@ -197,7 +203,7 @@ static int compare_areas_with_type(struct mc_compare_state& state, if (type->dw_type_id == NULL) return (addr_pointed1 != addr_pointed2); else { - return compare_areas_with_type(state, + return compare_areas_with_type(state, process_index, addr_pointed1, snapshot1, region1, addr_pointed2, snapshot2, region2, type->subtype, pointer_level); @@ -217,13 +223,13 @@ static int compare_areas_with_type(struct mc_compare_state& state, case DW_TAG_class_type: xbt_dynar_foreach(type->members, cursor, member) { void *member1 = - mc_member_resolve(real_area1, type, member, snapshot1); + mc_member_resolve(real_area1, type, member, snapshot1, process_index); void *member2 = - mc_member_resolve(real_area2, type, member, snapshot2); - mc_mem_region_t subregion1 = mc_get_region_hinted(member1, snapshot1, region1); - mc_mem_region_t subregion2 = mc_get_region_hinted(member2, snapshot2, region2); + mc_member_resolve(real_area2, type, member, snapshot2, process_index); + mc_mem_region_t subregion1 = mc_get_region_hinted(member1, snapshot1, process_index, region1); + mc_mem_region_t subregion2 = mc_get_region_hinted(member2, snapshot2, process_index, region2); res = - compare_areas_with_type(state, + compare_areas_with_type(state, process_index, member1, snapshot1, subregion1, member2, snapshot2, subregion2, member->subtype, pointer_level); @@ -242,7 +248,9 @@ static int compare_areas_with_type(struct mc_compare_state& state, return 0; } -static int compare_global_variables(int region_type, mc_mem_region_t r1, +static int compare_global_variables(mc_object_info_t object_info, + int process_index, + mc_mem_region_t r1, mc_mem_region_t r2, mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) { @@ -254,12 +262,6 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, unsigned int cursor = 0; dw_variable_t current_var; - mc_object_info_t object_info = NULL; - if (region_type == 2) { - object_info = mc_binary_info; - } else { - object_info = mc_libsimgrid_info; - } variables = object_info->global_variables; xbt_dynar_foreach(variables, cursor, current_var) { @@ -273,7 +275,7 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, dw_type_t bvariable_type = current_var->type; res = - compare_areas_with_type(state, + compare_areas_with_type(state, process_index, (char *) current_var->address, snapshot1, r1, (char *) current_var->address, snapshot2, r2, bvariable_type, 0); @@ -289,7 +291,8 @@ static int compare_global_variables(int region_type, mc_mem_region_t r1, } -static int compare_local_variables(mc_snapshot_t snapshot1, +static int compare_local_variables(int process_index, + mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, mc_snapshot_stack_t stack1, mc_snapshot_stack_t stack2) @@ -326,9 +329,9 @@ static int compare_local_variables(mc_snapshot_t snapshot1, dw_type_t subtype = current_var1->type; res = - compare_areas_with_type(state, - current_var1->address, snapshot1, mc_get_snapshot_region(current_var1->address, snapshot1), - current_var2->address, snapshot2, mc_get_snapshot_region(current_var2->address, snapshot2), + compare_areas_with_type(state, process_index, + current_var1->address, snapshot1, mc_get_snapshot_region(current_var1->address, snapshot1, process_index), + current_var2->address, snapshot2, mc_get_snapshot_region(current_var2->address, snapshot2, process_index), subtype, 0); if (res == 1) { @@ -441,9 +444,9 @@ int snapshot_compare(void *state1, void *state2) #endif /* Init heap information used in heap comparison algorithm */ - xbt_mheap_t heap1 = (xbt_mheap_t) mc_snapshot_read(std_heap, s1, + xbt_mheap_t heap1 = (xbt_mheap_t) mc_snapshot_read(std_heap, s1, MC_NO_PROCESS_INDEX, alloca(sizeof(struct mdesc)), sizeof(struct mdesc)); - xbt_mheap_t heap2 = (xbt_mheap_t) mc_snapshot_read(std_heap, s2, + xbt_mheap_t heap2 = (xbt_mheap_t) mc_snapshot_read(std_heap, s2, MC_NO_PROCESS_INDEX, alloca(sizeof(struct mdesc)), sizeof(struct mdesc)); res_init = init_heap_information(heap1, heap2, s1->to_ignore, s2->to_ignore); if (res_init == -1) { @@ -473,7 +476,6 @@ int snapshot_compare(void *state1, void *state2) is_diff = 0; #endif mc_snapshot_stack_t stack1, stack2; - while (cursor < xbt_dynar_length(s1->stacks)) { stack1 = (mc_snapshot_stack_t) xbt_dynar_get_as(s1->stacks, cursor, @@ -481,8 +483,14 @@ int snapshot_compare(void *state1, void *state2) stack2 = (mc_snapshot_stack_t) xbt_dynar_get_as(s2->stacks, cursor, mc_snapshot_stack_t); - diff_local = - compare_local_variables(s1, s2, stack1, stack2); + + if (stack1->process_index != stack2->process_index) { + diff_local = 1; + XBT_DEBUG("(%d - %d) Stacks with different process index (%i vs %i)", num1, num2, + stack1->process_index, stack2->process_index); + } + else diff_local = + compare_local_variables(stack1->process_index, s1, s2, stack1, stack2); if (diff_local > 0) { #ifdef MC_DEBUG if (is_diff == 0) { @@ -524,6 +532,8 @@ int snapshot_compare(void *state1, void *state2) }; #endif + mc_object_info_t object_infos[] = { NULL, mc_libsimgrid_info, mc_binary_info }; + int k = 0; for (k = 2; k != 0; --k) { #ifdef MC_DEBUG @@ -533,8 +543,21 @@ int snapshot_compare(void *state1, void *state2) #endif /* Compare global variables */ - is_diff = - compare_global_variables(k, s1->regions[k], s2->regions[k], s1, s2); +#ifdef HAVE_SMPI + if (object_infos[k] == mc_binary_info && smpi_privatize_global_variables) { + // Compare the global variables separately for each simulates process: + for (int process_index = 0; process_index < smpi_process_count(); process_index++) { + is_diff = + compare_global_variables(object_infos[k], process_index, + s1->privatization_regions[process_index], s2->privatization_regions[process_index], s1, s2); + if (is_diff) break; + } + } + else +#endif + is_diff = + compare_global_variables(object_infos[k], MC_NO_PROCESS_INDEX, s1->regions[k], s2->regions[k], s1, s2); + if (is_diff != 0) { #ifdef MC_DEBUG xbt_os_walltimer_stop(timer); diff --git a/src/mc/mc_diff.c b/src/mc/mc_diff.c index 3fee5787d2..5e360a2626 100644 --- a/src/mc/mc_diff.c +++ b/src/mc/mc_diff.c @@ -436,8 +436,8 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) mc_mem_region_t heap_region2 = snapshot2->regions[0]; // This is in snapshot do not use them directly: - malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1); - malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2); + malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1, MC_NO_PROCESS_INDEX); + malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2, MC_NO_PROCESS_INDEX); while (i1 <= state->heaplimit) { @@ -488,7 +488,7 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) (char *) ((xbt_mheap_t) state->s_heap)->heapbase)); res_compare = - compare_heap_area(addr_block1, addr_block2, snapshot1, snapshot2, + compare_heap_area(MC_NO_PROCESS_INDEX, addr_block1, addr_block2, snapshot1, snapshot2, NULL, NULL, 0); if (res_compare != 1) { @@ -528,7 +528,7 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) } res_compare = - compare_heap_area(addr_block1, addr_block2, snapshot1, snapshot2, + compare_heap_area(MC_NO_PROCESS_INDEX, addr_block1, addr_block2, snapshot1, snapshot2, NULL, NULL, 0); if (res_compare != 1) { @@ -581,7 +581,7 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) (j1 << heapinfo2->type)); res_compare = - compare_heap_area(addr_frag1, addr_frag2, snapshot1, snapshot2, + compare_heap_area(MC_NO_PROCESS_INDEX, addr_frag1, addr_frag2, snapshot1, snapshot2, NULL, NULL, 0); if (res_compare != 1) @@ -622,7 +622,7 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) (j2 << heapinfo2b->type)); res_compare = - compare_heap_area(addr_frag1, addr_frag2, snapshot2, snapshot2, + compare_heap_area(MC_NO_PROCESS_INDEX, addr_frag1, addr_frag2, snapshot2, snapshot2, NULL, NULL, 0); if (res_compare != 1) { @@ -754,7 +754,7 @@ int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2) * @param size * @param check_ignore */ -static int compare_heap_area_without_type(struct s_mc_diff *state, +static int compare_heap_area_without_type(struct s_mc_diff *state, int process_index, void *real_area1, void *real_area2, mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, @@ -794,8 +794,8 @@ static int compare_heap_area_without_type(struct s_mc_diff *state, if (mc_snapshot_region_memcmp(((char *) real_area1) + i, heap_region1, ((char *) real_area2) + i, heap_region2, 1) != 0) { pointer_align = (i / sizeof(void *)) * sizeof(void *); - addr_pointed1 = mc_snapshot_read_pointer((char *) real_area1 + pointer_align, snapshot1); - addr_pointed2 = mc_snapshot_read_pointer((char *) real_area2 + pointer_align, snapshot2); + addr_pointed1 = mc_snapshot_read_pointer((char *) real_area1 + pointer_align, snapshot1, process_index); + addr_pointed2 = mc_snapshot_read_pointer((char *) real_area2 + pointer_align, snapshot2, process_index); if (addr_pointed1 > maestro_stack_start && addr_pointed1 < maestro_stack_end @@ -809,7 +809,7 @@ static int compare_heap_area_without_type(struct s_mc_diff *state, && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)) { // Both addreses are in the heap: res_compare = - compare_heap_area(addr_pointed1, addr_pointed2, snapshot1, + compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous, NULL, 0); if (res_compare == 1) { return res_compare; @@ -844,7 +844,7 @@ static int compare_heap_area_without_type(struct s_mc_diff *state, * @param pointer_level * @return 0 (same), 1 (different), -1 (unknown) */ -static int compare_heap_area_with_type(struct s_mc_diff *state, +static int compare_heap_area_with_type(struct s_mc_diff *state, int process_index, void *real_area1, void *real_area2, mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, @@ -940,7 +940,7 @@ top: for (i = 0; i < type->element_count; i++) { // TODO, add support for variable stride (DW_AT_byte_stride) res = - compare_heap_area_with_type(state, + compare_heap_area_with_type(state, process_index, (char *) real_area1 + (i * elm_size), (char *) real_area2 + (i * elm_size), snapshot1, snapshot2, previous, @@ -954,21 +954,21 @@ top: case DW_TAG_rvalue_reference_type: case DW_TAG_pointer_type: if (type->subtype && type->subtype->type == DW_TAG_subroutine_type) { - addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1); - addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2); + addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1, process_index); + addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2, process_index); return (addr_pointed1 != addr_pointed2);; } else { pointer_level++; if (pointer_level > 1) { /* Array of pointers */ for (i = 0; i < (area_size / sizeof(void *)); i++) { - addr_pointed1 = mc_snapshot_read_pointer((char*) real_area1 + i * sizeof(void *), snapshot1); - addr_pointed2 = mc_snapshot_read_pointer((char*) real_area2 + i * sizeof(void *), snapshot2); + addr_pointed1 = mc_snapshot_read_pointer((char*) real_area1 + i * sizeof(void *), snapshot1, process_index); + addr_pointed2 = mc_snapshot_read_pointer((char*) real_area2 + i * sizeof(void *), snapshot2, process_index); if (addr_pointed1 > state->s_heap && addr_pointed1 < mc_snapshot_get_heap_end(snapshot1) && addr_pointed2 > state->s_heap && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)) res = - compare_heap_area(addr_pointed1, addr_pointed2, snapshot1, + compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous, type->subtype, pointer_level); else @@ -977,13 +977,13 @@ top: return res; } } else { - addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1); - addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2); + addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1, process_index); + addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2, process_index); if (addr_pointed1 > state->s_heap && addr_pointed1 < mc_snapshot_get_heap_end(snapshot1) && addr_pointed2 > state->s_heap && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)) - return compare_heap_area(addr_pointed1, addr_pointed2, snapshot1, + return compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1, snapshot2, previous, type->subtype, pointer_level); else @@ -999,7 +999,7 @@ top: if (area_size > type->byte_size && area_size % type->byte_size == 0) { for (i = 0; i < (area_size / type->byte_size); i++) { res = - compare_heap_area_with_type(state, + compare_heap_area_with_type(state, process_index, (char *) real_area1 + i * type->byte_size, (char *) real_area2 + i * type->byte_size, snapshot1, snapshot2, previous, type, -1, @@ -1015,11 +1015,11 @@ top: xbt_dynar_foreach(type->members, cursor, member) { // TODO, optimize this? (for the offset case) char *real_member1 = - mc_member_resolve(real_area1, type, member, snapshot1); + mc_member_resolve(real_area1, type, member, snapshot1, process_index); char *real_member2 = - mc_member_resolve(real_area2, type, member, snapshot2); + mc_member_resolve(real_area2, type, member, snapshot2, process_index); res = - compare_heap_area_with_type(state, real_member1, real_member2, + compare_heap_area_with_type(state, process_index, real_member1, real_member2, snapshot1, snapshot2, previous, member->subtype, -1, check_ignore, 0); @@ -1030,7 +1030,7 @@ top: } break; case DW_TAG_union_type: - return compare_heap_area_without_type(state, real_area1, real_area2, + return compare_heap_area_without_type(state, process_index, real_area1, real_area2, snapshot1, snapshot2, previous, type->byte_size, check_ignore); break; @@ -1054,7 +1054,7 @@ top: */ static dw_type_t get_offset_type(void *real_base_address, dw_type_t type, int offset, int area_size, - mc_snapshot_t snapshot) + mc_snapshot_t snapshot, int process_index) { // Beginning of the block, the infered variable type if the type of the block: @@ -1083,7 +1083,7 @@ static dw_type_t get_offset_type(void *real_base_address, dw_type_t type, return member->subtype; } else { char *real_member = - mc_member_resolve(real_base_address, type, member, snapshot); + mc_member_resolve(real_base_address, type, member, snapshot, process_index); if (real_member - (char *) real_base_address == offset) return member->subtype; } @@ -1110,7 +1110,7 @@ static dw_type_t get_offset_type(void *real_base_address, dw_type_t type, * @param pointer_level * @return 0 (same), 1 (different), -1 */ -int compare_heap_area(void *area1, void *area2, mc_snapshot_t snapshot1, +int compare_heap_area(int process_index, void *area1, void *area2, mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, xbt_dynar_t previous, dw_type_t type, int pointer_level) { @@ -1130,8 +1130,8 @@ int compare_heap_area(void *area1, void *area2, mc_snapshot_t snapshot1, int match_pairs = 0; - malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1); - malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2); + malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1, process_index); + malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2, process_index); malloc_info heapinfo_temp1, heapinfo_temp2; @@ -1389,24 +1389,24 @@ int compare_heap_area(void *area1, void *area2, mc_snapshot_t snapshot1, && state->types2_(block2, frag2) != NULL) { new_type1 = get_offset_type(real_addr_frag1, state->types1_(block1, frag1), - offset1, size, snapshot1); + offset1, size, snapshot1, process_index); new_type2 = get_offset_type(real_addr_frag2, state->types2_(block2, frag2), - offset1, size, snapshot2); + offset1, size, snapshot2, process_index); } else if (state->types1_(block1, frag1) != NULL) { new_type1 = get_offset_type(real_addr_frag1, state->types1_(block1, frag1), - offset1, size, snapshot1); + offset1, size, snapshot1, process_index); new_type2 = get_offset_type(real_addr_frag2, state->types1_(block1, frag1), - offset2, size, snapshot2); + offset2, size, snapshot2, process_index); } else if (state->types2_(block2, frag2) != NULL) { new_type1 = get_offset_type(real_addr_frag1, state->types2_(block2, frag2), - offset1, size, snapshot1); + offset1, size, snapshot1, process_index); new_type2 = get_offset_type(real_addr_frag2, state->types2_(block2, frag2), - offset2, size, snapshot2); + offset2, size, snapshot2, process_index); } else { if (match_pairs) { match_equals(state, previous); @@ -1477,12 +1477,12 @@ int compare_heap_area(void *area1, void *area2, mc_snapshot_t snapshot1, /* Start comparison */ if (type) { res_compare = - compare_heap_area_with_type(state, real_area1_to_compare, real_area2_to_compare, snapshot1, snapshot2, + compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2, previous, type, size, check_ignore, pointer_level); } else { res_compare = - compare_heap_area_without_type(state, real_area1_to_compare, real_area2_to_compare, snapshot1, snapshot2, + compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2, previous, size, check_ignore); } if (res_compare == 1) { diff --git a/src/mc/mc_dwarf_expression.c b/src/mc/mc_dwarf_expression.c index b1f0ac5a40..3b6c9a4deb 100644 --- a/src/mc/mc_dwarf_expression.c +++ b/src/mc/mc_dwarf_expression.c @@ -382,7 +382,7 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, // Computed address: uintptr_t address = (uintptr_t) state->stack[state->stack_size - 1]; uintptr_t temp; - uintptr_t* res = (uintptr_t*) mc_snapshot_read((void*) address, state->snapshot, &temp, sizeof(uintptr_t)); + uintptr_t* res = (uintptr_t*) mc_snapshot_read((void*) address, state->snapshot, state->process_index, &temp, sizeof(uintptr_t)); state->stack[state->stack_size - 1] = *res; } break; @@ -407,7 +407,7 @@ uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t * c, void *frame_pointer_address, - mc_snapshot_t snapshot) + mc_snapshot_t snapshot, int process_index) { s_mc_expression_state_t state; memset(&state, 0, sizeof(s_mc_expression_state_t)); @@ -415,6 +415,7 @@ uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, state.cursor = c; state.snapshot = snapshot; state.object_info = object_info; + state.process_index = process_index; if (mc_dwarf_execute_expression(expression->size, expression->ops, &state)) xbt_die("Error evaluating DWARF expression"); @@ -428,7 +429,7 @@ uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t * c, void *frame_pointer_address, - mc_snapshot_t snapshot) + mc_snapshot_t snapshot, int process_index) { unw_word_t ip; @@ -443,7 +444,7 @@ uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, || (c && ip >= (unw_word_t) expression->lowpc && ip < (unw_word_t) expression->highpc)) { return mc_dwarf_resolve_location(expression, object_info, c, - frame_pointer_address, snapshot); + frame_pointer_address, snapshot, process_index); } } xbt_die("Could not resolve location"); @@ -458,7 +459,7 @@ void *mc_find_frame_base(dw_frame_t frame, mc_object_info_t object_info, unw_cursor_t * unw_cursor) { return (void *) mc_dwarf_resolve_locations(&frame->frame_base, object_info, - unw_cursor, NULL, NULL); + unw_cursor, NULL, NULL, -1); } void mc_dwarf_expression_clear(mc_expression_t expression) diff --git a/src/mc/mc_hash.c b/src/mc/mc_hash.c index 3a96df8c4e..cc78c3d7e2 100644 --- a/src/mc/mc_hash.c +++ b/src/mc/mc_hash.c @@ -69,6 +69,7 @@ static void mc_hash_binary(mc_hash_t * hash, const void *s, size_t len) } } +#if 0 /** \brief Compute a hash for a given value of a given type * * We try to be very conservative (do not hash too ambiguous things). @@ -199,7 +200,6 @@ top: } } - static void mc_hash_object_globals(mc_hash_t * hash, mc_hashing_state * state, mc_object_info_t info) { @@ -316,6 +316,7 @@ static void mc_hash_stacks(mc_hash_t * hash, mc_hashing_state * state, ++i; } } +#endif uint64_t mc_hash_processes_state(int num_state, xbt_dynar_t stacks) { @@ -327,9 +328,9 @@ uint64_t mc_hash_processes_state(int num_state, xbt_dynar_t stacks) mc_hash_t hash = MC_HASH_INIT; MC_HASH(hash, xbt_swag_size(simix_global->process_list)); // process count - mc_hash_object_globals(&hash, &state, mc_binary_info); + // mc_hash_object_globals(&hash, &state, mc_binary_info); // mc_hash_object_globals(&hash, &state, mc_libsimgrid_info); - mc_hash_stacks(&hash, &state, stacks); + // mc_hash_stacks(&hash, &state, stacks); mc_hash_state_destroy(&state); diff --git a/src/mc/mc_ignore.c b/src/mc/mc_ignore.c index 8fab43ca0f..48f770477b 100644 --- a/src/mc/mc_ignore.c +++ b/src/mc/mc_ignore.c @@ -4,7 +4,9 @@ /* 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 "internal_config.h" #include "mc_private.h" +#include "smpi/private.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_ignore, mc, "Logging specific to MC ignore mechanism"); @@ -299,7 +301,18 @@ void MC_ignore_local_variable(const char *var_name, const char *frame_name) } -void MC_new_stack_area(void *stack, char *name, void *context, size_t size) +/** @brief Register a stack in the model checker + * + * The stacks are allocated in the heap. The MC handle them especially + * when we analyse/compare the content of theap so it must be told where + * they are with this function. + * + * @param stack + * @param process Process owning the stack + * @param context + * @param size Size of the stack + */ +void MC_new_stack_area(void *stack, smx_process_t process, void *context, size_t size) { int raw_mem_set = (mmalloc_get_current_heap() == mc_heap); @@ -312,12 +325,19 @@ void MC_new_stack_area(void *stack, char *name, void *context, size_t size) stack_region_t region = NULL; region = xbt_new0(s_stack_region_t, 1); region->address = stack; - region->process_name = strdup(name); + region->process_name = process && process->name ? strdup(process->name) : NULL; region->context = context; region->size = size; region->block = ((char *) stack - (char *) ((xbt_mheap_t) std_heap)->heapbase) / BLOCKSIZE + 1; +#ifdef HAVE_SMPI + if (smpi_privatize_global_variables && process) { + region->process_index = smpi_process_index_of_smx_process(process); + } else +#endif + region->process_index = -1; + xbt_dynar_push(stacks_areas, ®ion); if (!raw_mem_set) diff --git a/src/mc/mc_member.c b/src/mc/mc_member.c index 1d33a11999..ff7667d8a7 100644 --- a/src/mc/mc_member.c +++ b/src/mc/mc_member.c @@ -15,7 +15,7 @@ * @return Process address of the given member of the 'object' struct/class */ void *mc_member_resolve(const void *base, dw_type_t type, dw_type_t member, - mc_snapshot_t snapshot) + mc_snapshot_t snapshot, int process_index) { if (!member->location.size) { return ((char *) base) + member->offset; @@ -28,6 +28,7 @@ void *mc_member_resolve(const void *base, dw_type_t type, dw_type_t member, state.snapshot = snapshot; state.stack_size = 1; state.stack[0] = (uintptr_t) base; + state.process_index = process_index; if (mc_dwarf_execute_expression (member->location.size, member->location.ops, &state)) diff --git a/src/mc/mc_page_snapshot.cpp b/src/mc/mc_page_snapshot.cpp index ce175c2736..5718967fa8 100644 --- a/src/mc/mc_page_snapshot.cpp +++ b/src/mc/mc_page_snapshot.cpp @@ -158,27 +158,30 @@ static void mc_read_pagemap(uint64_t* pagemap, size_t page_start, size_t page_co // ***** High level API -mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg) +mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t ref_reg) { mc_mem_region_t new_reg = xbt_new(s_mc_mem_region_t, 1); new_reg->start_addr = start_addr; + new_reg->permanent_addr = permanent_addr; new_reg->data = NULL; new_reg->size = size; new_reg->page_numbers = NULL; xbt_assert((((uintptr_t)start_addr) & (xbt_pagesize-1)) == 0, "Not at the beginning of a page"); + xbt_assert((((uintptr_t)permanent_addr) & (xbt_pagesize-1)) == 0, + "Not at the beginning of a page"); size_t page_count = mc_page_count(size); uint64_t* pagemap = NULL; if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) { pagemap = (uint64_t*) mmalloc_no_memset((xbt_mheap_t) mc_heap, sizeof(uint64_t) * page_count); - mc_read_pagemap(pagemap, mc_page_number(NULL, start_addr), page_count); + mc_read_pagemap(pagemap, mc_page_number(NULL, permanent_addr), page_count); } // Take incremental snapshot: - new_reg->page_numbers = mc_take_page_snapshot_region(start_addr, page_count, pagemap, + new_reg->page_numbers = mc_take_page_snapshot_region(permanent_addr, page_count, pagemap, ref_reg==NULL ? NULL : ref_reg->page_numbers); if(pagemap) { @@ -189,7 +192,7 @@ mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, size_t size, mc void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg) { - xbt_assert((((uintptr_t)reg->start_addr) & (xbt_pagesize-1)) == 0, + xbt_assert((((uintptr_t)reg->permanent_addr) & (xbt_pagesize-1)) == 0, "Not at the beginning of a page"); size_t page_count = mc_page_count(reg->size); @@ -198,11 +201,11 @@ void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg) // Read soft-dirty bits if necessary in order to know which pages have changed: if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) { pagemap = (uint64_t*) mmalloc_no_memset((xbt_mheap_t) mc_heap, sizeof(uint64_t) * page_count); - mc_read_pagemap(pagemap, mc_page_number(NULL, reg->start_addr), page_count); + mc_read_pagemap(pagemap, mc_page_number(NULL, reg->permanent_addr), page_count); } // Incremental per-page snapshot restoration: - mc_restore_page_snapshot_region(reg->start_addr, page_count, reg->page_numbers, + mc_restore_page_snapshot_region(reg->permanent_addr, page_count, reg->page_numbers, pagemap, ref_reg ? ref_reg->page_numbers : NULL); // This is funny, the restoration can restore the state of the current heap, diff --git a/src/mc/mc_private.h b/src/mc/mc_private.h index 899168c3d9..c06613eded 100644 --- a/src/mc/mc_private.h +++ b/src/mc/mc_private.h @@ -41,15 +41,39 @@ typedef struct s_mc_function_index_item s_mc_function_index_item_t, *mc_function #define NB_REGIONS 3 /* binary data (data + BSS) (type = 2), libsimgrid data (data + BSS) (type = 1), std_heap (type = 0)*/ +/** @brief Copy/snapshot of a given memory region + * + * Two types of region snapshots exist: + *
    + *
  • flat/dense snapshots are a simple copy of the region;
    • + *
  • sparse/per-page snapshots are snaapshots which shared + * identical pages.
    • + *
+ */ typedef struct s_mc_mem_region{ - // Real address: + /** @brief Virtual address of the region in the simulated process */ void *start_addr; - // Copy of the datra: + + /** @brief Permanent virtual address of the region + * + * This is usually the same address as the simuilated process address. + * However, when using SMPI privatization of global variables, + * each SMPI process has its own set of global variables stored + * at a different virtual address. The scheduler maps those region + * on the region of the global variables. + * + * */ + void *permanent_addr; + + /** @brief Copy of the snapshot for flat snapshots regions (NULL otherwise) */ void *data; - // Size of the data region: + + /** @brief Size of the data region in bytes */ size_t size; - // For per-page snapshots, this is an array to the number of + + /** @brief Pages indices in the page store for per-page snapshots (NULL otherwise) */ size_t* page_numbers; + } s_mc_mem_region_t, *mc_mem_region_t; static inline __attribute__ ((always_inline)) @@ -83,15 +107,27 @@ typedef struct s_mc_snapshot{ xbt_dynar_t ignored_data; } s_mc_snapshot_t, *mc_snapshot_t; -mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot); +/** @brief Process index used when no process is available + * + * The expected behaviour is that if a process index is needed it will fail. + * */ +#define MC_NO_PROCESS_INDEX -1 + +/** @brief Process index when any process is suitable + * + * We could use a special negative value in the future. + */ +#define MC_ANY_PROCESS_INDEX 0 + +mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot, int process_index); static inline __attribute__ ((always_inline)) -mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, mc_mem_region_t region) +mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, int process_index, mc_mem_region_t region) { if (mc_region_contain(region, addr)) return region; else - return mc_get_snapshot_region(addr, snapshot); + return mc_get_snapshot_region(addr, snapshot, process_index); } /** Information about a given stack frame @@ -111,6 +147,7 @@ typedef struct s_mc_stack_frame { typedef struct s_mc_snapshot_stack{ xbt_dynar_t local_variables; xbt_dynar_t stack_frames; // mc_stack_frame_t + int process_index; }s_mc_snapshot_stack_t, *mc_snapshot_stack_t; typedef struct s_mc_global_t{ @@ -141,7 +178,7 @@ size_t* mc_take_page_snapshot_region(void* data, size_t page_count, uint64_t* pa void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count); void mc_restore_page_snapshot_region(void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos); -mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg); +mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, void* data_addr, size_t size, mc_mem_region_t ref_reg); void MC_region_destroy(mc_mem_region_t reg); void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg); void mc_softdirty_reset(); @@ -153,15 +190,15 @@ bool mc_snapshot_region_linear(mc_mem_region_t region) { void* mc_snapshot_read_fragmented(void* addr, mc_mem_region_t region, void* target, size_t size); -void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, void* target, size_t size); +void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, int process_index, void* target, size_t size); int mc_snapshot_region_memcmp( void* addr1, mc_mem_region_t region1, void* addr2, mc_mem_region_t region2, size_t size); int mc_snapshot_memcmp( void* addr1, mc_snapshot_t snapshot1, - void* addr2, mc_snapshot_t snapshot2, size_t size); + void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size); -static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot); +static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index); /** @brief State of the model-checker (global variables for the model checker) * @@ -483,8 +520,8 @@ typedef struct s_mc_location_list { mc_expression_t locations; } s_mc_location_list_t, *mc_location_list_t; -uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot); -uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot); +uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot, int process_index); +uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot, int process_index); void mc_dwarf_expression_clear(mc_expression_t expression); void mc_dwarf_expression_init(mc_expression_t expression, size_t len, Dwarf_Op* ops); @@ -514,7 +551,7 @@ struct s_dw_type{ dw_type_t full_type; // The same (but more complete) type }; -void* mc_member_resolve(const void* base, dw_type_t type, dw_type_t member, mc_snapshot_t snapshot); +void* mc_member_resolve(const void* base, dw_type_t type, dw_type_t member, mc_snapshot_t snapshot, int process_index); typedef struct s_dw_variable{ Dwarf_Off dwarf_offset; /* Global offset of the field. */ @@ -597,6 +634,7 @@ typedef struct s_mc_expression_state { void* frame_base; mc_snapshot_t snapshot; mc_object_info_t object_info; + int process_index; } s_mc_expression_state_t, *mc_expression_state_t; int mc_dwarf_execute_expression(size_t n, const Dwarf_Op* ops, mc_expression_state_t state); @@ -681,7 +719,7 @@ void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region) * \return Translated address in the snapshot address space * */ static inline __attribute__((always_inline)) -void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot) +void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot, int process_index) { // If not in a process state/clone: @@ -689,7 +727,7 @@ void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot) return (uintptr_t *) addr; } - mc_mem_region_t region = mc_get_snapshot_region((void*) addr, snapshot); + mc_mem_region_t region = mc_get_snapshot_region((void*) addr, snapshot, process_index); xbt_assert(mc_region_contain(region, (void*) addr), "Trying to read out of the region boundary."); @@ -718,14 +756,14 @@ static inline __attribute__ ((always_inline)) if(snapshot==NULL) xbt_die("snapshot is NULL"); void** addr = &((xbt_mheap_t)std_heap)->breakval; - return mc_snapshot_read_pointer(addr, snapshot); + return mc_snapshot_read_pointer(addr, snapshot, MC_ANY_PROCESS_INDEX); } static inline __attribute__ ((always_inline)) -void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot) +void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index) { void* res; - return *(void**) mc_snapshot_read(addr, snapshot, &res, sizeof(void*)); + return *(void**) mc_snapshot_read(addr, snapshot, process_index, &res, sizeof(void*)); } /** @brief Read memory from a snapshot region diff --git a/src/mc/mc_snapshot.c b/src/mc/mc_snapshot.c index dfe0a822de..bc1b5535d1 100644 --- a/src/mc/mc_snapshot.c +++ b/src/mc/mc_snapshot.c @@ -6,6 +6,9 @@ #include +#include "internal_config.h" +#include "smpi/private.h" + #include "mc_private.h" #include "mc_mmu.h" #include "mc_page_store.h" @@ -17,14 +20,35 @@ * @param Snapshot region in the snapshot this pointer belongs to * (or NULL if it does not belong to any snapshot region) * */ -mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot) +mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot, int process_index) { +#ifdef HAVE_SMPI + if (snapshot->privatization_regions) { + + if (process_index < 0) { + + mc_mem_region_t region = snapshot->privatization_regions[0]; + if( mc_region_contain(region, addr) ) { + xbt_die("Missing process index"); + } + + } else { + if (process_index >= smpi_process_count()) { + xbt_die("Invalid process index"); + } + + mc_mem_region_t region = snapshot->privatization_regions[process_index]; + if( mc_region_contain(region, addr) ) { + return region; + } + + } + } +#endif + for (size_t i = 0; i != NB_REGIONS; ++i) { mc_mem_region_t region = snapshot->regions[i]; - void* start = region->start_addr; - void* end = (char*) start + region->size; - - if (addr >= start && addr < end) { + if ( region && mc_region_contain(region, addr) ) { return region; } } @@ -80,10 +104,10 @@ void* mc_snapshot_read_fragmented(void* addr, mc_mem_region_t region, void* targ * @param size Size of the data to read in bytes * @return Pointer where the data is located (target buffer or original location) */ -void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, void* target, size_t size) +void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, int process_index, void* target, size_t size) { if (snapshot) { - mc_mem_region_t region = mc_get_snapshot_region(addr, snapshot); + mc_mem_region_t region = mc_get_snapshot_region(addr, snapshot, process_index); return mc_snapshot_read_region(addr, region, target, size); } else { return addr; @@ -100,7 +124,8 @@ void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, void* target, size_t * */ int mc_snapshot_region_memcmp( void* addr1, mc_mem_region_t region1, - void* addr2, mc_mem_region_t region2, size_t size) + void* addr2, mc_mem_region_t region2, + size_t size) { // Using alloca() for large allocations may trigger stack overflow: // use malloc if the buffer is too big. @@ -132,10 +157,10 @@ int mc_snapshot_region_memcmp( * */ int mc_snapshot_memcmp( void* addr1, mc_snapshot_t snapshot1, - void* addr2, mc_snapshot_t snapshot2, size_t size) + void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size) { - mc_mem_region_t region1 = mc_get_snapshot_region(addr1, snapshot1); - mc_mem_region_t region2 = mc_get_snapshot_region(addr2, snapshot2); + mc_mem_region_t region1 = mc_get_snapshot_region(addr1, snapshot1, process_index); + mc_mem_region_t region2 = mc_get_snapshot_region(addr2, snapshot2, process_index); return mc_snapshot_region_memcmp(addr1, region1, addr2, region2, size); } @@ -191,11 +216,11 @@ static void test_snapshot(bool sparse_checkpoint) { // Init memory and take snapshots: init_memory(source, byte_size); - mc_mem_region_t region0 = mc_region_new_sparse(0, source, byte_size, NULL); + mc_mem_region_t region0 = mc_region_new_sparse(0, source, source, byte_size, NULL); for(int i=0; istack, ((smx_context_t)context)->process->name, + if (MC_is_active() && code) { + MC_new_stack_area(context->stack, ((smx_context_t)context)->process, &(context->uc), smx_context_usable_stack_size); + } return (smx_context_t) context; } diff --git a/src/smpi/private.h b/src/smpi/private.h index 4fa25f18ae..4b3b5f7732 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -17,6 +17,8 @@ #include "smpi/smpi_cocci.h" #include "instr/instr_private.h" +SG_BEGIN_DECL() + struct s_smpi_process_data; typedef struct s_smpi_process_data *smpi_process_data_t; @@ -677,4 +679,8 @@ const char* encode_datatype(MPI_Datatype datatype); extern void** mappings; extern int loaded_page; +int smpi_process_index_of_smx_process(smx_process_t process); + +SG_END_DECL() + #endif diff --git a/src/smpi/smpi_bench.c b/src/smpi/smpi_bench.c index e33d659375..4138cac7e6 100644 --- a/src/smpi/smpi_bench.c +++ b/src/smpi/smpi_bench.c @@ -74,6 +74,7 @@ double smpi_cpu_threshold; double smpi_running_power; int* fds; +size_t mappings_count = 0; void** mappings; int loaded_page = -1; char* start_data_exe = NULL; @@ -610,7 +611,6 @@ void switch_data_segment(int dest){ if (loaded_page==dest)//no need to switch either return; - #ifdef HAVE_MMAP int i; if(loaded_page==-1){//initial switch, do the copy from the real page here diff --git a/src/smpi/smpi_global.c b/src/smpi/smpi_global.c index 61ffee727f..dda28d93eb 100644 --- a/src/smpi/smpi_global.c +++ b/src/smpi/smpi_global.c @@ -219,6 +219,11 @@ int smpi_process_index(void) return data ? data->index : MPI_UNDEFINED; } +int smpi_process_index_of_smx_process(smx_process_t process) { + smpi_process_data_t data = SIMIX_process_get_data(process); + return data ? data->index : MPI_UNDEFINED; +} + MPI_Comm smpi_process_comm_world(void) { smpi_process_data_t data = smpi_process_data(); diff --git a/teshsuite/mc/dwarf/dwarf.c b/teshsuite/mc/dwarf/dwarf.c index 513e2ed772..ab52f5b882 100644 --- a/teshsuite/mc/dwarf/dwarf.c +++ b/teshsuite/mc/dwarf/dwarf.c @@ -82,7 +82,7 @@ static void test_local_variable(mc_object_info_t info, const char* function, con assert(var); void* frame_base = mc_find_frame_base(subprogram, info, cursor); - xbt_assert((void*)mc_dwarf_resolve_locations(&var->locations, info, cursor, frame_base, NULL) == address, + xbt_assert((void*)mc_dwarf_resolve_locations(&var->locations, info, cursor, frame_base, NULL, -1) == address, "Bad resolution of local variable %s of %s", variable, function); }