From 4ea83ea565b18593a9e6864b7e43d02fc8500f23 Mon Sep 17 00:00:00 2001 From: Gabriel Corona Date: Fri, 29 May 2015 14:27:44 +0200 Subject: [PATCH] [mc] RegionSnapshot, make data private --- src/mc/mc_checkpoint.cpp | 40 ++++++++++++-------------- src/mc/mc_compare.cpp | 8 +++--- src/mc/mc_page_snapshot.cpp | 21 ++++++-------- src/mc/mc_snapshot.cpp | 4 +-- src/mc/mc_snapshot.h | 57 +++++++++++++++++++++++++++++++++---- 5 files changed, 85 insertions(+), 45 deletions(-) diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp index 26c6a2a185..071caa8593 100644 --- a/src/mc/mc_checkpoint.cpp +++ b/src/mc/mc_checkpoint.cpp @@ -92,18 +92,17 @@ static mc_mem_region_t mc_region_new_dense( mc_region_type_t region_type, void *start_addr, void* permanent_addr, size_t size) { - mc_mem_region_t region = new simgrid::mc::RegionSnapshot(); - region->region_type = region_type; - region->storage_type = MC_REGION_STORAGE_TYPE_FLAT; - region->start_addr = start_addr; - region->permanent_addr = permanent_addr; - region->size = size; - region->flat_data_.resize(size); - mc_model_checker->process().read_bytes(region->flat_data_.data(), size, + std::vector data(size); + mc_model_checker->process().read_bytes(data.data(), size, remote(permanent_addr), simgrid::mc::ProcessIndexDisabled); + + mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + region_type, start_addr, permanent_addr, size); + region->flat_data(std::move(data)); + XBT_DEBUG("New region : type : %d, data : %p (real addr %p), size : %zu", - region_type, region->flat_data_.data(), permanent_addr, size); + region_type, region->flat_data().data(), permanent_addr, size); return region; } @@ -137,7 +136,7 @@ static void MC_region_restore(mc_mem_region_t region) break; case MC_REGION_STORAGE_TYPE_FLAT: - mc_model_checker->process().write_bytes(region->flat_data_.data(), region->size, + mc_model_checker->process().write_bytes(region->flat_data().data(), region->size, remote(region->permanent_addr)); break; @@ -146,7 +145,7 @@ static void MC_region_restore(mc_mem_region_t region) break; case MC_REGION_STORAGE_TYPE_PRIVATIZED: - for (auto const& p : region->privatized_regions_) + for (auto const& p : region->privatized_data()) MC_region_restore(p.get()); break; } @@ -157,13 +156,6 @@ static mc_mem_region_t MC_region_new_privatized( ) { size_t process_count = MC_smpi_process_count(); - mc_mem_region_t region = new simgrid::mc::RegionSnapshot(); - region->region_type = region_type; - region->storage_type = MC_REGION_STORAGE_TYPE_PRIVATIZED; - region->start_addr = start_addr; - region->permanent_addr = permanent_addr; - region->size = size; - region->privatized_regions_.resize(process_count); // Read smpi_privatisation_regions from MCed: smpi_privatisation_region_t remote_smpi_privatisation_regions; @@ -175,13 +167,17 @@ static mc_mem_region_t MC_region_new_privatized( &privatisation_regions, sizeof(privatisation_regions), remote(remote_smpi_privatisation_regions)); - for (size_t i = 0; i < process_count; i++) { - region->privatized_regions_[i] = std::unique_ptr( + std::vector> data; + data.reserve(process_count); + for (size_t i = 0; i < process_count; i++) + data.push_back(std::unique_ptr( MC_region_new(region_type, start_addr, privatisation_regions[i].address, size) - ); - } + )); + mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + region_type, start_addr, permanent_addr, size); + region->privatized_data(std::move(data)); return region; } diff --git a/src/mc/mc_compare.cpp b/src/mc/mc_compare.cpp index 9887e55ac1..a5a0bc7857 100644 --- a/src/mc/mc_compare.cpp +++ b/src/mc/mc_compare.cpp @@ -275,14 +275,14 @@ static int compare_global_variables(mc_object_info_t object_info, } size_t process_count = MC_smpi_process_count(); - xbt_assert(process_count == r1->privatized_regions_.size() - && process_count == r2->privatized_regions_.size()); + xbt_assert(process_count == r1->privatized_data().size() + && process_count == r2->privatized_data().size()); // Compare the global variables separately for each simulates process: for (size_t process_index = 0; process_index < process_count; process_index++) { int is_diff = compare_global_variables(object_info, process_index, - r1->privatized_regions_[process_index].get(), - r2->privatized_regions_[process_index].get(), + r1->privatized_data()[process_index].get(), + r2->privatized_data()[process_index].get(), snapshot1, snapshot2); if (is_diff) return 1; } diff --git a/src/mc/mc_page_snapshot.cpp b/src/mc/mc_page_snapshot.cpp index 79e38e420f..cc75c46bde 100644 --- a/src/mc/mc_page_snapshot.cpp +++ b/src/mc/mc_page_snapshot.cpp @@ -87,22 +87,19 @@ mc_mem_region_t mc_region_new_sparse(mc_region_type_t region_type, { mc_process_t process = &mc_model_checker->process(); - mc_mem_region_t region = new simgrid::mc::RegionSnapshot(); - region->region_type = region_type; - region->storage_type = MC_REGION_STORAGE_TYPE_CHUNKED; - region->start_addr = start_addr; - region->permanent_addr = permanent_addr; - region->size = size; - 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); - // Take incremental snapshot: - region->page_numbers_ = simgrid::mc::PerPageCopy(mc_model_checker->page_store(), *process, - permanent_addr, page_count); + simgrid::mc::PerPageCopy page_data = + simgrid::mc::PerPageCopy(mc_model_checker->page_store(), *process, + permanent_addr, page_count); + + mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + region_type, start_addr, permanent_addr, size); + region->page_data(std::move(page_data)); return region; } @@ -111,9 +108,9 @@ void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg) { xbt_assert((((uintptr_t)reg->permanent_addr) & (xbt_pagesize-1)) == 0, "Not at the beginning of a page"); - xbt_assert(mc_page_count(reg->size) == reg->page_numbers_.page_count()); + xbt_assert(mc_page_count(reg->size) == reg->page_data().page_count()); mc_restore_page_snapshot_region(process, - reg->permanent_addr, reg->page_numbers_); + reg->permanent_addr, reg->page_data()); } } diff --git a/src/mc/mc_snapshot.cpp b/src/mc/mc_snapshot.cpp index 5a101b92ce..f0f36b10e5 100644 --- a/src/mc/mc_snapshot.cpp +++ b/src/mc/mc_snapshot.cpp @@ -41,10 +41,10 @@ mc_mem_region_t mc_get_snapshot_region( if (process_index < 0) { xbt_die("Missing process index"); } - if (process_index >= (int) region->privatized_regions_.size()) { + if (process_index >= (int) region->privatized_data().size()) { xbt_die("Invalid process index"); } - mc_mem_region_t priv_region = region->privatized_regions_[process_index].get(); + mc_mem_region_t priv_region = region->privatized_data()[process_index].get(); xbt_assert(mc_region_contain(priv_region, addr)); return priv_region; #else diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h index 412606f15e..0a46b747e9 100644 --- a/src/mc/mc_snapshot.h +++ b/src/mc/mc_snapshot.h @@ -149,6 +149,7 @@ public: * */ void *permanent_addr; +private: std::vector flat_data_; PerPageCopy page_numbers_; std::vector> privatized_regions_; @@ -161,9 +162,55 @@ public: size(0), permanent_addr(nullptr) {} + RegionSnapshot(mc_region_type_t type, void *start_addr, void* permanent_addr, size_t size) : + region_type(type), + storage_type(MC_REGION_STORAGE_TYPE_NONE), + object_info(nullptr), + start_addr(start_addr), + size(size), + permanent_addr(permanent_addr) + {} ~RegionSnapshot(); RegionSnapshot(RegionSnapshot const&) = delete; RegionSnapshot& operator=(RegionSnapshot const&) = delete; + + void clear_data() + { + storage_type = MC_REGION_STORAGE_TYPE_NONE; + flat_data_.clear(); + page_numbers_.clear(); + privatized_regions_.clear(); + } + + void flat_data(std::vector data) + { + storage_type = MC_REGION_STORAGE_TYPE_FLAT; + flat_data_ = std::move(data); + page_numbers_.clear(); + privatized_regions_.clear(); + } + std::vector const& flat_data() const { return flat_data_; } + + void page_data(PerPageCopy page_data) + { + storage_type = MC_REGION_STORAGE_TYPE_CHUNKED; + flat_data_.clear(); + page_numbers_ = std::move(page_data); + privatized_regions_.clear(); + } + PerPageCopy const& page_data() const { return page_numbers_; } + + void privatized_data(std::vector> data) + { + storage_type = MC_REGION_STORAGE_TYPE_PRIVATIZED; + flat_data_.clear(); + page_numbers_.clear(); + privatized_regions_ = std::move(data); + } + std::vector> const& privatized_data() const + { + return privatized_regions_; + } }; } @@ -187,7 +234,7 @@ void* mc_translate_address_region_chunked(uintptr_t addr, mc_mem_region_t region { size_t pageno = mc_page_number(region->start_addr, (void*) addr); const void* snapshot_page = - region->page_numbers_.page(pageno); + region->page_data().page(pageno); return (char*) snapshot_page + mc_page_offset((void*) addr); } @@ -202,7 +249,7 @@ void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int pr case MC_REGION_STORAGE_TYPE_FLAT: { uintptr_t offset = addr - (uintptr_t) region->start_addr; - return (void *) ((uintptr_t) region->flat_data_.data() + offset); + return (void *) ((uintptr_t) region->flat_data().data() + offset); } case MC_REGION_STORAGE_TYPE_CHUNKED: @@ -212,9 +259,9 @@ void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int pr { xbt_assert(process_index >=0, "Missing process index for privatized region"); - xbt_assert((size_t) process_index < region->privatized_regions_.size(), + xbt_assert((size_t) process_index < region->privatized_data().size(), "Out of range process index"); - mc_mem_region_t subregion = region->privatized_regions_[process_index].get(); + mc_mem_region_t subregion = region->privatized_data()[process_index].get(); xbt_assert(subregion, "Missing memory region for process %i", process_index); return mc_translate_address_region(addr, subregion, process_index); } @@ -380,7 +427,7 @@ const void* MC_region_read(mc_mem_region_t region, void* target, const void* add xbt_die("Storage type not supported"); case MC_REGION_STORAGE_TYPE_FLAT: - return (char*) region->flat_data_.data() + offset; + return (char*) region->flat_data().data() + offset; case MC_REGION_STORAGE_TYPE_CHUNKED: { -- 2.20.1