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<char> 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;
}
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;
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;
}
)
{
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;
&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<simgrid::mc::RegionSnapshot>(
+ std::vector<std::unique_ptr<simgrid::mc::RegionSnapshot>> data;
+ data.reserve(process_count);
+ for (size_t i = 0; i < process_count; i++)
+ data.push_back(std::unique_ptr<simgrid::mc::RegionSnapshot>(
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;
}
}
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;
}
{
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;
}
{
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());
}
}
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
* */
void *permanent_addr;
+private:
std::vector<char> flat_data_;
PerPageCopy page_numbers_;
std::vector<std::unique_ptr<RegionSnapshot>> privatized_regions_;
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<char> data)
+ {
+ storage_type = MC_REGION_STORAGE_TYPE_FLAT;
+ flat_data_ = std::move(data);
+ page_numbers_.clear();
+ privatized_regions_.clear();
+ }
+ std::vector<char> 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<std::unique_ptr<RegionSnapshot>> data)
+ {
+ storage_type = MC_REGION_STORAGE_TYPE_PRIVATIZED;
+ flat_data_.clear();
+ page_numbers_.clear();
+ privatized_regions_ = std::move(data);
+ }
+ std::vector<std::unique_ptr<RegionSnapshot>> const& privatized_data() const
+ {
+ return privatized_regions_;
+ }
};
}
{
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);
}
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:
{
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);
}
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:
{
