* @param Snapshot region in the snapshot this pointer belongs to
* (or NULL if it does not belong to any snapshot region)
* */
-mc_mem_region_t mc_get_snapshot_region(const void* addr, mc_snapshot_t snapshot, int process_index)
+mc_mem_region_t mc_get_snapshot_region(
+ const void* addr, const s_mc_snapshot_t* snapshot, int process_index)
{
size_t n = snapshot->snapshot_regions_count;
for (size_t i = 0; i != n; ++i) {
if (region->storage_type == MC_REGION_STORAGE_TYPE_PRIVATIZED) {
#ifdef HAVE_SMPI
// Use the current process index of the snapshot:
- if (process_index == MC_PROCESS_INDEX_DISABLED) {
+ if (process_index == simgrid::mc::ProcessIndexDisabled) {
process_index = snapshot->privatization_index;
}
if (process_index < 0) {
xbt_die("Missing process index");
}
- if (process_index >= (int) region->privatized.regions_count) {
+ if (process_index >= (int) region->privatized_regions_.size()) {
xbt_die("Invalid process index");
}
- mc_mem_region_t priv_region = region->privatized.regions[process_index];
+ mc_mem_region_t priv_region = region->privatized_regions_[process_index].get();
xbt_assert(mc_region_contain(priv_region, addr));
return priv_region;
#else
// Read each page:
while (mc_page_number(NULL, addr) != page_end) {
- void* snapshot_addr = mc_translate_address_region((uintptr_t) addr, region);
+ void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t) addr, region);
void* next_page = mc_page_from_number(NULL, mc_page_number(NULL, addr) + 1);
size_t readable = (char*) next_page - (char*) addr;
memcpy(dest, snapshot_addr, readable);
}
// Read the end:
- void* snapshot_addr = mc_translate_address_region((uintptr_t)addr, region);
+ void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
memcpy(dest, snapshot_addr, size);
return target;
}
-/** @brief Read memory from a snapshot
- *
- * @param addr Process (non-snapshot) address of the data
- * @param snapshot Snapshot (or NULL is no snapshot)
- * @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 or original location)
- */
-const void* MC_snapshot_read(
- mc_snapshot_t snapshot, adress_space_read_flags_t flags,
- void* target, const void* addr, size_t size, int process_index)
-{
- mc_mem_region_t region = mc_get_snapshot_region(addr, snapshot, process_index);
- if (region)
- return MC_region_read(region, target, addr, size);
- else
- return MC_process_read(snapshot->process, flags, target, addr, size, process_index);
-}
-
/** Compare memory between snapshots (with known regions)
*
* @param addr1 Address in the first snapshot
return MC_snapshot_region_memcmp(addr1, region1, addr2, region2, size);
}
+namespace simgrid {
+namespace mc {
+
+Snapshot::Snapshot() :
+ process(nullptr),
+ num_state(0),
+ heap_bytes_used(0),
+ snapshot_regions(nullptr),
+ snapshot_regions_count(0),
+ enabled_processes(0),
+ privatization_index(0),
+ stack_sizes(nullptr),
+ stacks(nullptr),
+ to_ignore(nullptr),
+ hash(0),
+ ignored_data(nullptr),
+ total_fd(0),
+ current_fd(nullptr)
+{
+
+}
+Snapshot::~Snapshot()
+{
+ for (size_t i = 0; i < this->snapshot_regions_count; i++) {
+ delete this->snapshot_regions[i];
+ }
+ xbt_free(this->snapshot_regions);
+ xbt_free(this->stack_sizes);
+ xbt_dynar_free(&(this->stacks));
+ xbt_dynar_free(&(this->to_ignore));
+ xbt_dynar_free(&this->ignored_data);
+}
+
+const void* Snapshot::read_bytes(void* buffer, std::size_t size,
+ remote_ptr<void> address, int process_index,
+ AddressSpace::ReadMode mode) const
+{
+ mc_mem_region_t region = mc_get_snapshot_region((void*)address.address(), this, process_index);
+ if (region) {
+ const void* res = MC_region_read(region, buffer, (void*)address.address(), size);
+ if (buffer == res || mode == AddressSpace::Lazy)
+ return res;
+ else {
+ memcpy(buffer, res, size);
+ return buffer;
+ }
+ }
+ else
+ return this->read_bytes(buffer, size, address, process_index, mode);
+}
+
+}
+}
+
#ifdef SIMGRID_TEST
#include <string.h>
static void test_snapshot(bool sparse_checkpoint);
-XBT_TEST_UNIT("page_snapshots", test_per_snpashots, "Test per-page snapshots")
-{
- test_snapshot(1);
-}
-
-
XBT_TEST_UNIT("flat_snapshot", test_flat_snapshots, "Test flat snapshots")
{
test_snapshot(0);
}
+XBT_TEST_UNIT("page_snapshots", test_per_snpashots, "Test per-page snapshots")
+{
+ test_snapshot(1);
+}
static void test_snapshot(bool sparse_checkpoint) {
}
xbt_test_add("Compare whole region data for %i page(s)", n);
- xbt_test_assert(!MC_snapshot_region_memcmp(source, NULL, source, region, byte_size),
- "Mismatch in MC_snapshot_region_memcmp() for the whole region");
+
xbt_test_assert(MC_snapshot_region_memcmp(source, region0, source, region, byte_size),
"Unexpected match in MC_snapshot_region_memcmp() with previous snapshot");
- xbt_test_add("Compare parts of region data for %i page(s) with current value", n);
- for(int j=0; j!=100; ++j) {
- size_t offset = rand() % byte_size;
- size_t size = rand() % (byte_size - offset);
- xbt_test_assert(!MC_snapshot_region_memcmp((char*) source+offset, NULL, (char*) source+offset, region, size),
- "Mismatch in MC_snapshot_region_memcmp()");
- }
-
xbt_test_add("Compare parts of region data for %i page(s) with itself", n);
for(int j=0; j!=100; ++j) {
size_t offset = rand() % byte_size;
MC_REGION_TYPE_UNKNOWN, source, source, byte_size);
xbt_test_assert(MC_region_read_pointer(region2, source) == mc_model_checker,
"Mismtach in MC_region_read_pointer()");
- MC_region_destroy(region2);
+ delete region2;
}
- MC_region_destroy(region);
- MC_region_destroy(region0);
+ delete region;
+ delete region0;
munmap(destination, byte_size);
munmap(source, byte_size);
}
