X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d47e21d93998034c0f8fa4a9a6c750002f7642fa..220a6109b767302515959ba7b80a36cfd9fd94ca:/src/mc/mc_private.h diff --git a/src/mc/mc_private.h b/src/mc/mc_private.h index 96fe0a0a28..1147044e5b 100644 --- a/src/mc/mc_private.h +++ b/src/mc/mc_private.h @@ -9,6 +9,7 @@ #include "simgrid_config.h" #include +#include #ifndef WIN32 #include #endif @@ -28,25 +29,61 @@ #include "msg/datatypes.h" #include "xbt/strbuff.h" #include "xbt/parmap.h" +#include "mc_mmu.h" +#include "mc_page_store.h" +#include "mc_interface.h" + +SG_BEGIN_DECL() typedef struct s_dw_frame s_dw_frame_t, *dw_frame_t; typedef struct s_mc_function_index_item s_mc_function_index_item_t, *mc_function_index_item_t; /****************************** Snapshots ***********************************/ -#define NB_REGIONS 3 /* binary data (data + BSS) (type = 2), libsimgrid data (data + BSS) (type = 1), std_heap (type = 0)*/ +#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)) +bool mc_region_contain(mc_mem_region_t region, void* p) +{ + return p >= region->start_addr && + p < (void*)((char*) region->start_addr + region->size); +} + /** Ignored data * * Some parts of the snapshot are ignored by zeroing them out: the real @@ -69,7 +106,30 @@ typedef struct s_mc_snapshot{ xbt_dynar_t to_ignore; uint64_t hash; xbt_dynar_t ignored_data; -} s_mc_snapshot_t, *mc_snapshot_t; +} s_mc_snapshot_t; + +/** @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, int process_index, mc_mem_region_t region) +{ + if (mc_region_contain(region, addr)) + return region; + else + return mc_get_snapshot_region(addr, snapshot, process_index); +} /** Information about a given stack frame * @@ -88,6 +148,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{ @@ -105,16 +166,8 @@ typedef struct s_mc_checkpoint_ignore_region{ size_t size; }s_mc_checkpoint_ignore_region_t, *mc_checkpoint_ignore_region_t; -SG_BEGIN_DECL() - -inline static void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot) { - if(snapshot==NULL) - xbt_die("snapshot is NULL"); - xbt_mheap_t heap = (xbt_mheap_t)snapshot->regions[0]->data; - return heap->breakval; -} +static void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot); -mc_snapshot_t SIMIX_pre_mc_snapshot(smx_simcall_t simcall); mc_snapshot_t MC_take_snapshot(int num_state); void MC_restore_snapshot(mc_snapshot_t); void MC_free_snapshot(mc_snapshot_t); @@ -123,17 +176,29 @@ int mc_important_snapshot(mc_snapshot_t snapshot); size_t* mc_take_page_snapshot_region(void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages); void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count); -void mc_restore_page_snapshot_region(mc_mem_region_t region, size_t page_count, uint64_t* pagemap, mc_mem_region_t reference_region); +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(); -typedef struct s_mc_pages_store s_mc_pages_store_t, * mc_pages_store_t; -mc_pages_store_t mc_pages_store_new(); +static inline __attribute__((always_inline)) +bool mc_snapshot_region_linear(mc_mem_region_t region) { + return !region || !region->data; +} + +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, 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, int process_index, size_t size); -void* mc_snapshot_read_region(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); +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) * @@ -152,35 +217,6 @@ typedef struct s_mc_model_checker { extern mc_model_checker_t mc_model_checker; -void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region); - -/** \brief Translate a pointer from process address space to snapshot address space - * - * The address space contains snapshot of the main/application memory: - * this function finds the address in a given snaphot for a given - * real/application address. - * - * For read only memory regions and other regions which are not int the - * snapshot, the address is not changed. - * - * \param addr Application address - * \param snapshot The snapshot of interest (if NULL no translation is done) - * \return Translated address in the snapshot address space - * */ -void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot); - -/** \brief Translate a pointer from the snapshot address space to the application address space - * - * This is the inverse of mc_translate_address. - * - * Does not work for per-page snapshot, we change the logic to handle this. - * - * \param addr Address in the snapshot address space - * \param snapsot Snapshot of interest (if NULL no translation is done) - * \return Translated address in the application address space - */ -uintptr_t mc_untranslate_address(void* addr, mc_snapshot_t snapshot); - extern xbt_dynar_t mc_checkpoint_ignore; /********************************* MC Global **********************************/ @@ -199,7 +235,6 @@ void MC_wait_for_requests(void); void MC_show_deadlock(smx_simcall_t req); void MC_show_stack_safety(xbt_fifo_t stack); void MC_dump_stack_safety(xbt_fifo_t stack); -int SIMIX_pre_mc_random(smx_simcall_t simcall, int min, int max); extern xbt_fifo_t mc_stack; int get_search_interval(xbt_dynar_t list, void *ref, int *min, int *max); @@ -283,8 +318,8 @@ void MC_print_statistics(mc_stats_t); /* Normally the system should operate in std, for switching to raw mode */ /* you must wrap the code between MC_SET_RAW_MODE and MC_UNSET_RAW_MODE */ -extern void *std_heap; -extern void *mc_heap; +extern xbt_mheap_t std_heap; +extern xbt_mheap_t mc_heap; /* FIXME: Horrible hack! because the mmalloc library doesn't provide yet of */ @@ -352,7 +387,6 @@ extern __thread mc_comparison_times_t mc_comp_times; extern __thread double mc_snapshot_comparison_time; int snapshot_compare(void *state1, void *state2); -int SIMIX_pre_mc_compare_snapshots(smx_simcall_t simcall, mc_snapshot_t s1, mc_snapshot_t s2); void print_comparison_times(void); //#define MC_DEBUG 1 @@ -381,7 +415,7 @@ typedef struct s_mc_visited_state{ }s_mc_visited_state_t, *mc_visited_state_t; extern xbt_dynar_t visited_states; -int is_visited_state(void); +mc_visited_state_t is_visited_state(void); void visited_state_free(mc_visited_state_t state); void visited_state_free_voidp(void *s); @@ -484,8 +518,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); @@ -515,8 +549,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_snapshot_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. */ @@ -599,6 +632,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); @@ -631,6 +665,7 @@ typedef struct s_mc_comm_pattern{ void *data; }s_mc_comm_pattern_t, *mc_comm_pattern_t; +extern xbt_dynar_t initial_communications_pattern; extern xbt_dynar_t communications_pattern; extern xbt_dynar_t incomplete_communications_pattern; @@ -657,7 +692,127 @@ bool mc_address_test(mc_address_set_t p, const void* value); * */ uint64_t mc_hash_processes_state(int num_state, xbt_dynar_t stacks); +/* *********** Snapshot *********** */ + +static inline __attribute__((always_inline)) +void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region) +{ + size_t pageno = mc_page_number(region->start_addr, (void*) addr); + size_t snapshot_pageno = region->page_numbers[pageno]; + const void* snapshot_page = mc_page_store_get_page(mc_model_checker->pages, snapshot_pageno); + return (char*) snapshot_page + mc_page_offset((void*) addr); +} + +/** \brief Translate a pointer from process address space to snapshot address space + * + * The address space contains snapshot of the main/application memory: + * this function finds the address in a given snaphot for a given + * real/application address. + * + * For read only memory regions and other regions which are not int the + * snapshot, the address is not changed. + * + * \param addr Application address + * \param snapshot The snapshot of interest (if NULL no translation is done) + * \return Translated address in the snapshot address space + * */ +static inline __attribute__((always_inline)) +void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot, int process_index) +{ + + // If not in a process state/clone: + if (!snapshot) { + return (uintptr_t *) addr; + } + + 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."); + + if (!region) { + return (void *) addr; + } + + // Flat snapshot: + else if (region->data) { + uintptr_t offset = addr - (uintptr_t) region->start_addr; + return (void *) ((uintptr_t) region->data + offset); + } + + // Per-page snapshot: + else if (region->page_numbers) { + return mc_translate_address_region(addr, region); + } + + else { + xbt_die("No data for this memory region"); + } +} + +static inline __attribute__ ((always_inline)) + void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot) { + if(snapshot==NULL) + xbt_die("snapshot is NULL"); + void** addr = &(std_heap->breakval); + 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, int process_index) +{ + void* res; + return *(void**) mc_snapshot_read(addr, snapshot, process_index, &res, sizeof(void*)); +} + +/** @brief Read memory from a snapshot region + * + * @param addr Process (non-snapshot) address of the data + * @param region Snapshot memory region where the data is located + * @param target Buffer to store the value + * @param size Size of the data to read in bytes + * @return Pointer where the data is located (target buffer of original location) + */ +static inline __attribute__((always_inline)) +void* mc_snapshot_read_region(void* addr, mc_mem_region_t region, void* target, size_t size) +{ + if (region==NULL) + return addr; + + uintptr_t offset = (char*) addr - (char*) region->start_addr; + + xbt_assert(mc_region_contain(region, addr), + "Trying to read out of the region boundary."); + + // Linear memory region: + if (region->data) { + return (char*) region->data + offset; + } + + // Fragmented memory region: + else if (region->page_numbers) { + // Last byte of the region: + void* end = (char*) addr + size - 1; + if( mc_same_page(addr, end) ) { + // The memory is contained in a single page: + return mc_translate_address_region((uintptr_t) addr, region); + } else { + // The memory spans several pages: + return mc_snapshot_read_fragmented(addr, region, target, size); + } + } + + else { + xbt_die("No data available for this region"); + } +} + +static inline __attribute__ ((always_inline)) +void* mc_snapshot_read_pointer_region(void* addr, mc_mem_region_t region) +{ + void* res; + return *(void**) mc_snapshot_read_region(addr, region, &res, sizeof(void*)); +} + SG_END_DECL() #endif -