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