X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d47e21d93998034c0f8fa4a9a6c750002f7642fa..98c076f6daa9f55f8e0e06a583c07bc05777854c:/src/mc/mc_private.h diff --git a/src/mc/mc_private.h b/src/mc/mc_private.h index 96fe0a0a28..cb229e9aa9 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,6 +29,10 @@ #include "msg/datatypes.h" #include "xbt/strbuff.h" #include "xbt/parmap.h" +#include "mc_mmu.h" +#include "mc_page_store.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; @@ -47,6 +52,13 @@ typedef struct s_mc_mem_region{ 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 @@ -71,6 +83,17 @@ 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); + +static inline __attribute__ ((always_inline)) +mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, mc_mem_region_t region) +{ + if (mc_region_contain(region, addr)) + return region; + else + return mc_get_snapshot_region(addr, snapshot); +} + /** Information about a given stack frame * */ @@ -105,14 +128,7 @@ 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); @@ -126,14 +142,26 @@ 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); mc_mem_region_t mc_region_new_sparse(int type, void *start_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_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); +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); + +static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot); /** @brief State of the model-checker (global variables for the model checker) * @@ -152,35 +180,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 **********************************/ @@ -516,7 +515,6 @@ struct s_dw_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); typedef struct s_dw_variable{ Dwarf_Off dwarf_offset; /* Global offset of the field. */ @@ -657,6 +655,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) +{ + + // 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); + + 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 = &((xbt_mheap_t)std_heap)->breakval; + return mc_snapshot_read_pointer(addr, snapshot); +} + +static inline __attribute__ ((always_inline)) +void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot) +{ + void* res; + return *(void**) mc_snapshot_read(addr, snapshot, &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