#include "mc_snapshot.h"
#include "mc_private.h"
#include "mc_mmu.h"
-#include "mc_page_store.h"
+#include "PageStore.hpp"
extern "C" {
* @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) {
// 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++) {
+ MC_region_destroy(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_assert(source!=MAP_FAILED, "Could not allocate destination memory");
xbt_test_add("Reading whole region data for %i page(s)", n);
- const void* read = MC_region_read(region, source, destination, byte_size);
+ const void* read = MC_region_read(region, destination, source, byte_size);
xbt_test_assert(!memcmp(source, read, byte_size), "Mismatch in MC_region_read()");
xbt_test_add("Reading parts of region data for %i page(s)", n);
