X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b8df87e176f27b25534f27d7e240defa32ca35bc..b923f24fcb86571011626426f577fe6322094bb3:/src/mc/sosp/mc_snapshot.hpp

diff --git a/src/mc/sosp/mc_snapshot.hpp b/src/mc/sosp/mc_snapshot.hpp
index 92a4325c7e..19264557d4 100644
--- a/src/mc/sosp/mc_snapshot.hpp
+++ b/src/mc/sosp/mc_snapshot.hpp
@@ -13,9 +13,7 @@
 
 // ***** Snapshot region
 
-XBT_PRIVATE void mc_region_restore_sparse(simgrid::mc::RemoteClient* process, mc_mem_region_t reg);
-
-static XBT_ALWAYS_INLINE void* mc_translate_address_region_chunked(uintptr_t addr, mc_mem_region_t region)
+static XBT_ALWAYS_INLINE void* mc_translate_address_region_chunked(uintptr_t addr, simgrid::mc::RegionSnapshot* region)
 {
   auto split                = simgrid::mc::mmu::split(addr - region->start().address());
   auto pageno               = split.first;
@@ -24,7 +22,8 @@ static XBT_ALWAYS_INLINE void* mc_translate_address_region_chunked(uintptr_t add
   return (char*)snapshot_page + offset;
 }
 
-static XBT_ALWAYS_INLINE void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int process_index)
+static XBT_ALWAYS_INLINE void* mc_translate_address_region(uintptr_t addr, simgrid::mc::RegionSnapshot* region,
+                                                           int process_index)
 {
   switch (region->storage_type()) {
     case simgrid::mc::StorageType::Flat: {
@@ -44,8 +43,8 @@ static XBT_ALWAYS_INLINE void* mc_translate_address_region(uintptr_t addr, mc_me
   }
 }
 
-XBT_PRIVATE mc_mem_region_t mc_get_snapshot_region(const void* addr, const simgrid::mc::Snapshot* snapshot,
-                                                   int process_index);
+XBT_PRIVATE simgrid::mc::RegionSnapshot* mc_get_snapshot_region(const void* addr, const simgrid::mc::Snapshot* snapshot,
+                                                                int process_index);
 
 // ***** MC Snapshot
 
@@ -59,13 +58,6 @@ struct s_mc_snapshot_ignored_data_t {
   std::vector<char> data;
 };
 
-struct s_fd_infos_t {
-  std::string filename;
-  int number;
-  off_t current_position;
-  int flags;
-};
-
 /** Information about a given stack frame */
 struct s_mc_stack_frame_t {
   /** Instruction pointer */
@@ -110,21 +102,21 @@ public:
   // To be private
   int num_state;
   std::size_t heap_bytes_used;
-  std::vector<std::unique_ptr<s_mc_mem_region_t>> snapshot_regions;
+  std::vector<std::unique_ptr<RegionSnapshot>> snapshot_regions;
   std::set<pid_t> enabled_processes;
   int privatization_index;
   std::vector<std::size_t> stack_sizes;
   std::vector<s_mc_snapshot_stack_t> stacks;
   std::vector<simgrid::mc::IgnoredHeapRegion> to_ignore;
-  std::uint64_t hash;
+  std::uint64_t hash = 0;
   std::vector<s_mc_snapshot_ignored_data_t> ignored_data;
-  std::vector<s_fd_infos_t> current_fds;
 };
 } // namespace mc
 } // namespace simgrid
 
-static XBT_ALWAYS_INLINE mc_mem_region_t mc_get_region_hinted(void* addr, simgrid::mc::Snapshot* snapshot,
-                                                              int process_index, mc_mem_region_t region)
+static XBT_ALWAYS_INLINE simgrid::mc::RegionSnapshot* mc_get_region_hinted(void* addr, simgrid::mc::Snapshot* snapshot,
+                                                                           int process_index,
+                                                                           simgrid::mc::RegionSnapshot* region)
 {
   if (region->contain(simgrid::mc::remote(addr)))
     return region;
@@ -137,18 +129,16 @@ static const void* mc_snapshot_get_heap_end(simgrid::mc::Snapshot* snapshot);
 namespace simgrid {
 namespace mc {
 
-XBT_PRIVATE std::shared_ptr<simgrid::mc::Snapshot> take_snapshot(int num_state);
-XBT_PRIVATE void restore_snapshot(std::shared_ptr<simgrid::mc::Snapshot> snapshot);
+XBT_PRIVATE std::shared_ptr<Snapshot> take_snapshot(int num_state);
+XBT_PRIVATE void restore_snapshot(std::shared_ptr<Snapshot> snapshot);
 } // namespace mc
 } // namespace simgrid
 
-XBT_PRIVATE void mc_restore_page_snapshot_region(simgrid::mc::RemoteClient* process, void* start_addr,
-                                                 simgrid::mc::ChunkedData const& pagenos);
-
-const void* MC_region_read_fragmented(mc_mem_region_t region, void* target, const void* addr, std::size_t size);
+const void* MC_region_read_fragmented(simgrid::mc::RegionSnapshot* region, void* target, const void* addr,
+                                      std::size_t size);
 
-int MC_snapshot_region_memcmp(const void* addr1, mc_mem_region_t region1, const void* addr2, mc_mem_region_t region2,
-                              std::size_t size);
+int MC_snapshot_region_memcmp(const void* addr1, simgrid::mc::RegionSnapshot* region1, const void* addr2,
+                              simgrid::mc::RegionSnapshot* region2, std::size_t size);
 
 static XBT_ALWAYS_INLINE const void* mc_snapshot_get_heap_end(simgrid::mc::Snapshot* snapshot)
 {
@@ -165,7 +155,7 @@ static XBT_ALWAYS_INLINE const void* mc_snapshot_get_heap_end(simgrid::mc::Snaps
  *  @param size    Size of the data to read in bytes
  *  @return Pointer where the data is located (target buffer of original location)
  */
-static XBT_ALWAYS_INLINE const void* MC_region_read(mc_mem_region_t region, void* target, const void* addr,
+static XBT_ALWAYS_INLINE const void* MC_region_read(simgrid::mc::RegionSnapshot* region, void* target, const void* addr,
                                                     std::size_t size)
 {
   xbt_assert(region);
@@ -181,7 +171,7 @@ static XBT_ALWAYS_INLINE const void* MC_region_read(mc_mem_region_t region, void
     case simgrid::mc::StorageType::Chunked: {
       // Last byte of the region:
       void* end = (char*)addr + size - 1;
-      if (simgrid::mc::mmu::sameChunk((std::uintptr_t)addr, (std::uintptr_t)end)) {
+      if (simgrid::mc::mmu::same_chunk((std::uintptr_t)addr, (std::uintptr_t)end)) {
         // The memory is contained in a single page:
         return mc_translate_address_region_chunked((uintptr_t)addr, region);
       }
@@ -196,7 +186,7 @@ static XBT_ALWAYS_INLINE const void* MC_region_read(mc_mem_region_t region, void
   }
 }
 
-static XBT_ALWAYS_INLINE void* MC_region_read_pointer(mc_mem_region_t region, const void* addr)
+static XBT_ALWAYS_INLINE void* MC_region_read_pointer(simgrid::mc::RegionSnapshot* region, const void* addr)
 {
   void* res;
   return *(void**)MC_region_read(region, &res, addr, sizeof(void*));