src/mc/sosp/Snapshot_test.cpp

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