src/mc/sosp/Snapshot_test.cpp

   1 /* Copyright (c) 2014-2020. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "src/include/catch.hpp"
   7 #include "src/mc/mc_config.hpp"
   8 #include "src/mc/sosp/Snapshot.hpp"
   9
  10 #include <cstddef>
  11 #include <memory>
  12 #include <sys/mman.h>
  13 #include <xbt/random.hpp>
  14
  15 /**************** Class BOOST_tests *************************/
  16 using simgrid::mc::Region;
  17 class snap_test_helper {
  18 public:
  19   static void init_memory(void* mem, size_t size);
  20   static void Init();
  21   typedef struct {
  22     size_t size;
  23     void* src;
  24     void* dstn;
  25     Region* region0;
  26     Region* region;
  27   } prologue_return;
  28   static prologue_return prologue(int n); // common to the below 5 fxs
  29   static void read_whole_region();
  30   static void read_region_parts();
  31   static void compare_whole_region();
  32   static void compare_region_parts();
  33   static void read_pointer();
  34
  35   static void cleanup()
  36   {
  37     delete mc_model_checker;
  38     mc_model_checker = nullptr;
  39   }
  40
  41   static std::unique_ptr<simgrid::mc::RemoteSimulation> process;
  42 };
  43
  44 // static member variables init.
  45 std::unique_ptr<simgrid::mc::RemoteSimulation> snap_test_helper::process = nullptr;
  46
  47 void snap_test_helper::init_memory(void* mem, size_t size)
  48 {
  49   auto* dest = static_cast<char*>(mem);
  50   for (size_t i = 0; i < size; ++i) {
  51     dest[i] = simgrid::xbt::random::uniform_int(0, 0xff);
  52   }
  53 }
  54
  55 void snap_test_helper::Init()
  56 {
  57   REQUIRE(xbt_pagesize == getpagesize());
  58   REQUIRE(1 << xbt_pagebits == xbt_pagesize);
  59
  60   process = std::make_unique<simgrid::mc::RemoteSimulation>(getpid());
  61   process->init();
  62   mc_model_checker = new ::simgrid::mc::ModelChecker(std::move(process), -1);
  63 }
  64
  65 snap_test_helper::prologue_return snap_test_helper::prologue(int n)
  66 {
  67   // Store region page(s):
  68   size_t byte_size = n * xbt_pagesize;
  69   void* source     = mmap(nullptr, byte_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  70   INFO("Could not allocate source memory")
  71   REQUIRE(source != MAP_FAILED);
  72
  73   // Init memory and take snapshots:
  74   init_memory(source, byte_size);
  75   auto* region0 = new simgrid::mc::Region(simgrid::mc::RegionType::Data, source, byte_size);
  76   for (int i = 0; i < n; i += 2) {
  77     init_memory((char*)source + i * xbt_pagesize, xbt_pagesize);
  78   }
  79   auto* region = new simgrid::mc::Region(simgrid::mc::RegionType::Data, source, byte_size);
  80
  81   void* destination = mmap(nullptr, byte_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  82   INFO("Could not allocate destination memory");
  83   REQUIRE(source != MAP_FAILED);
  84
  85   return {.size    = byte_size,
  86           .src     = source,
  87           .dstn    = destination,
  88           .region0 = std::move(region0),
  89           .region  = std::move(region)};
  90 }
  91
  92 void snap_test_helper::read_whole_region()
  93 {
  94   for (int n = 1; n != 32; ++n) {
  95     prologue_return ret = prologue(n);
  96     const void* read    = ret.region->read(ret.dstn, ret.src, ret.size);
  97     INFO("Mismatch in MC_region_read()");
  98     REQUIRE(not memcmp(ret.src, read, ret.size));
  99
 100     munmap(ret.dstn, ret.size);
 101     munmap(ret.src, ret.size);
 102     delete ret.region0;
 103     delete ret.region;
 104   }
 105 }
 106
 107 void snap_test_helper::read_region_parts()
 108 {
 109   for (int n = 1; n != 32; ++n) {
 110     prologue_return ret = prologue(n);
 111
 112     for (int j = 0; j != 100; ++j) {
 113       size_t offset    = simgrid::xbt::random::uniform_int(0, ret.size - 1);
 114       size_t size      = simgrid::xbt::random::uniform_int(0, ret.size - offset - 1);
 115       const void* read = ret.region->read(ret.dstn, (const char*)ret.src + offset, size);
 116       INFO("Mismatch in MC_region_read()");
 117       REQUIRE(not memcmp((char*)ret.src + offset, read, size));
 118     }
 119     munmap(ret.dstn, ret.size);
 120     munmap(ret.src, ret.size);
 121     delete ret.region0;
 122     delete ret.region;
 123   }
 124 }
 125
 126 void snap_test_helper::compare_whole_region()
 127 {
 128   for (int n = 1; n != 32; ++n) {
 129     prologue_return ret = prologue(n);
 130
 131     INFO("Unexpected match in MC_snapshot_region_memcmp() with previous snapshot");
 132     REQUIRE(MC_snapshot_region_memcmp(ret.src, ret.region0, ret.src, ret.region, ret.size));
 133
 134     munmap(ret.dstn, ret.size);
 135     munmap(ret.src, ret.size);
 136     delete ret.region0;
 137     delete ret.region;
 138   }
 139 }
 140
 141 void snap_test_helper::compare_region_parts()
 142 {
 143   for (int n = 1; n != 32; ++n) {
 144     prologue_return ret = prologue(n);
 145
 146     for (int j = 0; j != 100; ++j) {
 147       size_t offset = simgrid::xbt::random::uniform_int(0, ret.size - 1);
 148       size_t size   = simgrid::xbt::random::uniform_int(0, ret.size - offset - 1);
 149
 150       INFO("Mismatch in MC_snapshot_region_memcmp()");
 151       REQUIRE(not MC_snapshot_region_memcmp((char*)ret.src + offset, ret.region, (char*)ret.src + offset, ret.region,
 152                                             size));
 153     }
 154     munmap(ret.dstn, ret.size);
 155     munmap(ret.src, ret.size);
 156     delete ret.region0;
 157     delete ret.region;
 158   }
 159 }
 160
 161 void snap_test_helper::read_pointer()
 162 {
 163   prologue_return ret = prologue(1);
 164   memcpy(ret.src, &mc_model_checker, sizeof(void*));
 165   const simgrid::mc::Region* region2 = new simgrid::mc::Region(simgrid::mc::RegionType::Data, ret.src, ret.size);
 166   INFO("Mismtach in MC_region_read_pointer()");
 167   REQUIRE(MC_region_read_pointer(region2, ret.src) == mc_model_checker);
 168
 169   munmap(ret.dstn, ret.size);
 170   munmap(ret.src, ret.size);
 171   delete ret.region0;
 172   delete ret.region;
 173   delete region2;
 174 }
 175
 176 /*************** End: class snap_test_helper *****************************/
 177
 178 TEST_CASE("MC::Snapshot: A copy/snapshot of a given memory region", "MC::Snapshot")
 179 {
 180   INFO("Sparse snapshot (using pages)");
 181
 182   snap_test_helper::Init();
 183
 184   INFO("Read whole region");
 185   snap_test_helper::read_whole_region();
 186
 187   INFO("Read region parts");
 188   snap_test_helper::read_region_parts();
 189
 190   INFO("Compare whole region");
 191   snap_test_helper::compare_whole_region();
 192
 193   INFO("Compare region parts");
 194   snap_test_helper::compare_region_parts();
 195
 196   INFO("Read pointer");
 197   snap_test_helper::read_pointer();
 198
 199   snap_test_helper::cleanup();
 200 }