src/mc/sosp/mc_snapshot.cpp

   1 /* Copyright (c) 2014-2018. 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 <cstddef>
   7
   8 #include <memory>
   9 #include <utility>
  10
  11 #include "xbt/asserts.h"
  12 #include "xbt/sysdep.h"
  13
  14 #include "src/internal_config.h"
  15 #include "src/smpi/include/private.hpp"
  16
  17 #include "src/mc/mc_mmu.hpp"
  18 #include "src/mc/mc_private.hpp"
  19 #include "src/mc/sosp/PageStore.hpp"
  20 #include "src/mc/sosp/mc_snapshot.hpp"
  21
  22 /** @brief Find the snapshoted region from a pointer
  23  *
  24  *  @param addr     Pointer
  25  *  @param snapshot Snapshot
  26  *  @param Snapshot region in the snapshot this pointer belongs to
  27  *         (or nullptr if it does not belong to any snapshot region)
  28  * */
  29 mc_mem_region_t mc_get_snapshot_region(const void* addr, const simgrid::mc::Snapshot* snapshot, int process_index)
  30 {
  31   size_t n = snapshot->snapshot_regions.size();
  32   for (size_t i = 0; i != n; ++i) {
  33     mc_mem_region_t region = snapshot->snapshot_regions[i].get();
  34     if (not(region && region->contain(simgrid::mc::remote(addr))))
  35       continue;
  36
  37     if (region->storage_type() == simgrid::mc::StorageType::Privatized) {
  38 #if HAVE_SMPI
  39       // Use the current process index of the snapshot:
  40       if (process_index == simgrid::mc::ProcessIndexDisabled)
  41         process_index = snapshot->privatization_index;
  42       if (process_index < 0)
  43         xbt_die("Missing process index");
  44       if (process_index >= (int)region->privatized_data().size())
  45         xbt_die("Invalid process index");
  46       simgrid::mc::RegionSnapshot& priv_region = region->privatized_data()[process_index];
  47       xbt_assert(priv_region.contain(simgrid::mc::remote(addr)));
  48       return &priv_region;
  49 #else
  50       xbt_die("Privatized region in a non SMPI build (this should not happen)");
  51 #endif
  52     }
  53
  54     return region;
  55   }
  56
  57   return nullptr;
  58 }
  59
  60 /** @brief Read memory from a snapshot region broken across fragmented pages
  61  *
  62  *  @param addr    Process (non-snapshot) address of the data
  63  *  @param region  Snapshot memory region where the data is located
  64  *  @param target  Buffer to store the value
  65  *  @param size    Size of the data to read in bytes
  66  *  @return Pointer where the data is located (target buffer of original location)
  67  */
  68 const void* MC_region_read_fragmented(mc_mem_region_t region, void* target, const void* addr, size_t size)
  69 {
  70   // Last byte of the memory area:
  71   void* end = (char*)addr + size - 1;
  72
  73   // TODO, we assume the chunks are aligned to natural chunk boundaries.
  74   // We should remove this assumption.
  75
  76   // Page of the last byte of the memory area:
  77   size_t page_end = simgrid::mc::mmu::split((std::uintptr_t)end).first;
  78
  79   void* dest = target;
  80
  81   if (dest == nullptr)
  82     xbt_die("Missing destination buffer for fragmented memory access");
  83
  84   // Read each page:
  85   while (simgrid::mc::mmu::split((std::uintptr_t)addr).first != page_end) {
  86     void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
  87     void* next_page     = (void*)simgrid::mc::mmu::join(simgrid::mc::mmu::split((std::uintptr_t)addr).first + 1, 0);
  88     size_t readable     = (char*)next_page - (char*)addr;
  89     memcpy(dest, snapshot_addr, readable);
  90     addr = (char*)addr + readable;
  91     dest = (char*)dest + readable;
  92     size -= readable;
  93   }
  94
  95   // Read the end:
  96   void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
  97   memcpy(dest, snapshot_addr, size);
  98
  99   return target;
 100 }
 101
 102 /** Compare memory between snapshots (with known regions)
 103  *
 104  * @param addr1 Address in the first snapshot
 105  * @param snapshot2 Region of the address in the first snapshot
 106  * @param addr2 Address in the second snapshot
 107  * @param snapshot2 Region of the address in the second snapshot
 108  * @return same as memcmp
 109  * */
 110 int MC_snapshot_region_memcmp(const void* addr1, mc_mem_region_t region1, const void* addr2, mc_mem_region_t region2,
 111                               size_t size)
 112 {
 113   // Using alloca() for large allocations may trigger stack overflow:
 114   // use malloc if the buffer is too big.
 115   bool stack_alloc = size < 64;
 116   void* buffer1a   = nullptr;
 117   void* buffer2a   = nullptr;
 118   if (region1 != nullptr && region1->storage_type() != simgrid::mc::StorageType::Flat)
 119     buffer1a = stack_alloc ? alloca(size) : ::operator new(size);
 120   if (region2 != nullptr && region2->storage_type() != simgrid::mc::StorageType::Flat)
 121     buffer2a = stack_alloc ? alloca(size) : ::operator new(size);
 122   const void* buffer1 = MC_region_read(region1, buffer1a, addr1, size);
 123   const void* buffer2 = MC_region_read(region2, buffer2a, addr2, size);
 124   int res;
 125   if (buffer1 == buffer2)
 126     res = 0;
 127   else
 128     res = memcmp(buffer1, buffer2, size);
 129   if (not stack_alloc) {
 130     ::operator delete(buffer1a);
 131     ::operator delete(buffer2a);
 132   }
 133   return res;
 134 }
 135
 136 namespace simgrid {
 137 namespace mc {
 138
 139 Snapshot::Snapshot(RemoteClient* process, int _num_state)
 140     : AddressSpace(process)
 141     , num_state(_num_state)
 142     , heap_bytes_used(0)
 143     , enabled_processes()
 144     , privatization_index(0)
 145     , hash(0)
 146 {
 147 }
 148
 149 const void* Snapshot::read_bytes(void* buffer, std::size_t size, RemotePtr<void> address, int process_index,
 150                                  ReadOptions options) const
 151 {
 152   mc_mem_region_t region = mc_get_snapshot_region((void*)address.address(), this, process_index);
 153   if (region) {
 154     const void* res = MC_region_read(region, buffer, (void*)address.address(), size);
 155     if (buffer == res || options & ReadOptions::lazy())
 156       return res;
 157     else {
 158       memcpy(buffer, res, size);
 159       return buffer;
 160     }
 161   } else
 162     return this->process()->read_bytes(buffer, size, address, process_index, options);
 163 }
 164
 165 } // namespace mc
 166 } // namespace simgrid