From: Gabriel Corona Date: Fri, 29 May 2015 13:57:30 +0000 (+0200) Subject: [mc] Use vector instead of vector> in... X-Git-Tag: v3_12~696 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/928649fec04d89b678017ec4cadbc97e5ef901f5 [mc] Use vector instead of vector> in RegionSnapshot --- diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp index 9a1285bb78..7940e39b74 100644 --- a/src/mc/mc_checkpoint.cpp +++ b/src/mc/mc_checkpoint.cpp @@ -88,7 +88,7 @@ RegionSnapshot::~RegionSnapshot() {} extern "C" { -static mc_mem_region_t mc_region_new_dense( +static simgrid::mc::RegionSnapshot MC_region_dense( mc_region_type_t region_type, void *start_addr, void* permanent_addr, size_t size) { @@ -97,13 +97,13 @@ static mc_mem_region_t mc_region_new_dense( remote(permanent_addr), simgrid::mc::ProcessIndexDisabled); - mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + simgrid::mc::RegionSnapshot region( region_type, start_addr, permanent_addr, size); - region->flat_data(std::move(data)); + 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); - return region; + region_type, region.flat_data().data(), permanent_addr, size); + return std::move(region); } /** @brief Take a snapshot of a given region @@ -113,13 +113,13 @@ static mc_mem_region_t mc_region_new_dense( * @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* */ -static mc_mem_region_t MC_region_new( +static simgrid::mc::RegionSnapshot MC_region( mc_region_type_t type, void *start_addr, void* permanent_addr, size_t size) { if (_sg_mc_sparse_checkpoint) { - return mc_region_new_sparse(type, start_addr, permanent_addr, size); + return MC_region_sparse(type, start_addr, permanent_addr, size); } else { - return mc_region_new_dense(type, start_addr, permanent_addr, size); + return MC_region_dense(type, start_addr, permanent_addr, size); } } @@ -145,13 +145,13 @@ static void MC_region_restore(mc_mem_region_t region) break; case MC_REGION_STORAGE_TYPE_PRIVATIZED: - for (auto const& p : region->privatized_data()) - MC_region_restore(p.get()); + for (auto& p : region->privatized_data()) + MC_region_restore(&p); break; } } -static mc_mem_region_t MC_region_new_privatized( +static simgrid::mc::RegionSnapshot MC_region_privatized( mc_region_type_t region_type, void *start_addr, void* permanent_addr, size_t size ) { @@ -167,18 +167,18 @@ static mc_mem_region_t MC_region_new_privatized( &privatisation_regions, sizeof(privatisation_regions), remote(remote_smpi_privatisation_regions)); - std::vector> data; + 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, + data.push_back( + MC_region(region_type, start_addr, privatisation_regions[i].address, size) - )); + ); - mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + simgrid::mc::RegionSnapshot region = simgrid::mc::RegionSnapshot( region_type, start_addr, permanent_addr, size); - region->privatized_data(std::move(data)); - return region; + region.privatized_data(std::move(data)); + return std::move(region); } static void MC_snapshot_add_region(int index, mc_snapshot_t snapshot, mc_region_type_t type, @@ -190,15 +190,17 @@ static void MC_snapshot_add_region(int index, mc_snapshot_t snapshot, mc_region_ else if (type == MC_REGION_TYPE_HEAP) xbt_assert(!object_info, "Unexpected object info for heap region."); - mc_mem_region_t region; const bool privatization_aware = MC_object_info_is_privatized(object_info); + + simgrid::mc::RegionSnapshot region; if (privatization_aware && MC_smpi_process_count()) - region = MC_region_new_privatized(type, start_addr, permanent_addr, size); + region = MC_region_privatized(type, start_addr, permanent_addr, size); else - region = MC_region_new(type, start_addr, permanent_addr, size); + region = MC_region(type, start_addr, permanent_addr, size); - region->object_info(object_info); - snapshot->snapshot_regions[index] = region; + region.object_info(object_info); + snapshot->snapshot_regions[index] + = new simgrid::mc::RegionSnapshot(std::move(region)); return; } diff --git a/src/mc/mc_compare.cpp b/src/mc/mc_compare.cpp index 73b4b3441f..d9af408dfa 100644 --- a/src/mc/mc_compare.cpp +++ b/src/mc/mc_compare.cpp @@ -281,8 +281,8 @@ static int compare_global_variables(mc_object_info_t object_info, // 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_data()[process_index].get(), - r2->privatized_data()[process_index].get(), + &r1->privatized_data()[process_index], + &r2->privatized_data()[process_index], snapshot1, snapshot2); if (is_diff) return 1; } diff --git a/src/mc/mc_page_snapshot.cpp b/src/mc/mc_page_snapshot.cpp index f0fb2c13e9..eeaa925005 100644 --- a/src/mc/mc_page_snapshot.cpp +++ b/src/mc/mc_page_snapshot.cpp @@ -82,7 +82,7 @@ void mc_restore_page_snapshot_region(mc_process_t process, // ***** High level API -mc_mem_region_t mc_region_new_sparse(mc_region_type_t region_type, +simgrid::mc::RegionSnapshot MC_region_sparse(mc_region_type_t region_type, void *start_addr, void* permanent_addr, size_t size) { mc_process_t process = &mc_model_checker->process(); @@ -93,15 +93,13 @@ mc_mem_region_t mc_region_new_sparse(mc_region_type_t region_type, "Not at the beginning of a page"); size_t page_count = mc_page_count(size); - simgrid::mc::PerPageCopy page_data = - simgrid::mc::PerPageCopy(mc_model_checker->page_store(), *process, + simgrid::mc::PerPageCopy page_data(mc_model_checker->page_store(), *process, permanent_addr, page_count); - mc_mem_region_t region = new simgrid::mc::RegionSnapshot( + simgrid::mc::RegionSnapshot region( region_type, start_addr, permanent_addr, size); - region->page_data(std::move(page_data)); - - return region; + region.page_data(std::move(page_data)); + return std::move(region); } void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg) diff --git a/src/mc/mc_snapshot.cpp b/src/mc/mc_snapshot.cpp index 89f5c56bc7..21cfc7b3bd 100644 --- a/src/mc/mc_snapshot.cpp +++ b/src/mc/mc_snapshot.cpp @@ -44,9 +44,9 @@ mc_mem_region_t mc_get_snapshot_region( if (process_index >= (int) region->privatized_data().size()) { xbt_die("Invalid process index"); } - mc_mem_region_t priv_region = region->privatized_data()[process_index].get(); - xbt_assert(mc_region_contain(priv_region, addr)); - return priv_region; + simgrid::mc::RegionSnapshot& priv_region = region->privatized_data()[process_index]; + xbt_assert(mc_region_contain(&priv_region, addr)); + return &priv_region; #else xbt_die("Privatized region in a non SMPI build (this should not happen)"); #endif @@ -256,55 +256,52 @@ 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( + simgrid::mc::RegionSnapshot region0 = MC_region_sparse( MC_REGION_TYPE_UNKNOWN, source, source, byte_size); for(int i=0; i flat_data_; PerPageCopy page_numbers_; - std::vector> privatized_regions_; + std::vector privatized_regions_; public: RegionSnapshot() : region_type_(MC_REGION_TYPE_UNKNOWN), @@ -170,11 +170,51 @@ public: permanent_addr_(permanent_addr) {} ~RegionSnapshot(); - RegionSnapshot(RegionSnapshot const&) = delete; - RegionSnapshot& operator=(RegionSnapshot const&) = delete; + RegionSnapshot(RegionSnapshot const&) = default; + RegionSnapshot& operator=(RegionSnapshot const&) = default; + RegionSnapshot(RegionSnapshot&& that) + { + region_type_ = that.region_type_; + storage_type_ = that.storage_type_; + object_info_ = that.object_info_; + start_addr_ = that.start_addr_; + size_ = that.size_; + permanent_addr_ = that.permanent_addr_; + flat_data_ = std::move(that.flat_data_); + page_numbers_ = std::move(that.page_numbers_); + privatized_regions_ = std::move(that.privatized_regions_); + that.clear(); + } + RegionSnapshot& operator=(RegionSnapshot&& that) + { + region_type_ = that.region_type_; + storage_type_ = that.storage_type_; + object_info_ = that.object_info_; + start_addr_ = that.start_addr_; + size_ = that.size_; + permanent_addr_ = that.permanent_addr_; + flat_data_ = std::move(that.flat_data_); + page_numbers_ = std::move(that.page_numbers_); + privatized_regions_ = std::move(that.privatized_regions_); + that.clear(); + return *this; + } // Data + void clear() + { + region_type_ = MC_REGION_TYPE_UNKNOWN; + storage_type_ = MC_REGION_STORAGE_TYPE_NONE; + privatized_regions_.clear(); + page_numbers_.clear(); + flat_data_.clear(); + object_info_ = nullptr; + start_addr_ = nullptr; + size_ = 0; + permanent_addr_ = nullptr; + } + void clear_data() { storage_type_ = MC_REGION_STORAGE_TYPE_NONE; @@ -201,14 +241,18 @@ public: } PerPageCopy const& page_data() const { return page_numbers_; } - void privatized_data(std::vector> data) + 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 + std::vector const& privatized_data() const + { + return privatized_regions_; + } + std::vector& privatized_data() { return privatized_regions_; } @@ -236,7 +280,7 @@ public: typedef class simgrid::mc::RegionSnapshot s_mc_mem_region_t, *mc_mem_region_t; -MC_SHOULD_BE_INTERNAL mc_mem_region_t mc_region_new_sparse( +MC_SHOULD_BE_INTERNAL simgrid::mc::RegionSnapshot MC_region_sparse( mc_region_type_t type, void *start_addr, void* data_addr, size_t size); XBT_INTERNAL void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg); @@ -278,9 +322,8 @@ void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int pr "Missing process index for privatized region"); xbt_assert((size_t) process_index < region->privatized_data().size(), "Out of range process index"); - 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); + simgrid::mc::RegionSnapshot& subregion= region->privatized_data()[process_index]; + return mc_translate_address_region(addr, &subregion, process_index); } } }