#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) {
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_test_add("Initialisation");
- _sg_mc_soft_dirty = 0;
_sg_mc_sparse_checkpoint = sparse_checkpoint;
xbt_assert(xbt_pagesize == getpagesize());
xbt_assert(1 << xbt_pagebits == xbt_pagesize);
- mc_model_checker = xbt_new0(s_mc_model_checker_t, 1);
- mc_model_checker->pages = mc_pages_store_new();
+ mc_model_checker = new ::simgrid::mc::ModelChecker(getpid(), -1);
for(int n=1; n!=256; ++n) {
// Init memory and take snapshots:
init_memory(source, byte_size);
- mc_mem_region_t region0 = mc_region_new_sparse(MC_REGION_TYPE_UNKNOWN, source, source, byte_size, NULL);
+ mc_mem_region_t region0 = mc_region_new_sparse(
+ MC_REGION_TYPE_UNKNOWN, source, source, byte_size);
for(int i=0; i<n; i+=2) {
init_memory((char*) source + i*xbt_pagesize, xbt_pagesize);
}
- mc_mem_region_t region = mc_region_new_sparse(MC_REGION_TYPE_UNKNOWN, source, source, byte_size, NULL);
+ mc_mem_region_t region = mc_region_new_sparse(
+ MC_REGION_TYPE_UNKNOWN, source, source, byte_size);
void* destination = mmap(NULL, byte_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
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);
if (n==1) {
xbt_test_add("Read pointer for %i page(s)", n);
memcpy(source, &mc_model_checker, sizeof(void*));
- mc_mem_region_t region2 = mc_region_new_sparse(MC_REGION_TYPE_UNKNOWN, source, source, byte_size, NULL);
+ mc_mem_region_t region2 = mc_region_new_sparse(
+ 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);
munmap(source, byte_size);
}
- mc_pages_store_delete(mc_model_checker->pages);
- xbt_free(mc_model_checker);
+ delete mc_model_checker;
mc_model_checker = NULL;
}