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