X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/02a7d032779c8f37702c9513f1c3fbb988088677..928649fec04d89b678017ec4cadbc97e5ef901f5:/src/mc/mc_snapshot.h

diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h
index 412606f15e..4ce34ed26e 100644
--- a/src/mc/mc_snapshot.h
+++ b/src/mc/mc_snapshot.h
@@ -33,7 +33,7 @@ typedef enum e_mc_region_type_t {
 } mc_region_type_t;
 
 // TODO, use OO instead of this
-typedef enum e_mc_region_storeage_type_t {
+typedef enum e_mc_region_storage_type_t {
   MC_REGION_STORAGE_TYPE_NONE = 0,
   MC_REGION_STORAGE_TYPE_FLAT = 1,
   MC_REGION_STORAGE_TYPE_CHUNKED = 2,
@@ -127,16 +127,16 @@ public:
  *      each type.
  */
 class RegionSnapshot {
-public:
-  mc_region_type_t region_type;
-  mc_region_storage_type_t storage_type;
-  mc_object_info_t object_info;
+private:
+  mc_region_type_t region_type_;
+  mc_region_storage_type_t storage_type_;
+  mc_object_info_t object_info_;
 
   /** @brief  Virtual address of the region in the simulated process */
-  void *start_addr;
+  void *start_addr_;
 
   /** @brief Size of the data region in bytes */
-  size_t size;
+  size_t size_;
 
   /** @brief Permanent virtual address of the region
    *
@@ -147,23 +147,132 @@ public:
    * on the region of the global variables.
    *
    * */
-  void *permanent_addr;
+  void *permanent_addr_;
 
   std::vector<char> flat_data_;
   PerPageCopy page_numbers_;
-  std::vector<std::unique_ptr<RegionSnapshot>> privatized_regions_;
+  std::vector<RegionSnapshot> privatized_regions_;
 public:
   RegionSnapshot() :
-    region_type(MC_REGION_TYPE_UNKNOWN),
-    storage_type(MC_REGION_STORAGE_TYPE_NONE),
-    object_info(nullptr),
-    start_addr(nullptr),
-    size(0),
-    permanent_addr(nullptr)
+    region_type_(MC_REGION_TYPE_UNKNOWN),
+    storage_type_(MC_REGION_STORAGE_TYPE_NONE),
+    object_info_(nullptr),
+    start_addr_(nullptr),
+    size_(0),
+    permanent_addr_(nullptr)
+  {}
+  RegionSnapshot(mc_region_type_t type, void *start_addr, void* permanent_addr, size_t size) :
+    region_type_(type),
+    storage_type_(MC_REGION_STORAGE_TYPE_NONE),
+    object_info_(nullptr),
+    start_addr_(start_addr),
+    size_(size),
+    permanent_addr_(permanent_addr)
   {}
   ~RegionSnapshot();
-  RegionSnapshot(RegionSnapshot const&) = delete;
-  RegionSnapshot& operator=(RegionSnapshot const&) = delete;
+  RegionSnapshot(RegionSnapshot const&) = default;
+  RegionSnapshot& operator=(RegionSnapshot const&) = default;
+  RegionSnapshot(RegionSnapshot&& that)
+  {
+    region_type_ = that.region_type_;
+    storage_type_ = that.storage_type_;
+    object_info_ = that.object_info_;
+    start_addr_ = that.start_addr_;
+    size_ = that.size_;
+    permanent_addr_ = that.permanent_addr_;
+    flat_data_ = std::move(that.flat_data_);
+    page_numbers_ = std::move(that.page_numbers_);
+    privatized_regions_ = std::move(that.privatized_regions_);
+    that.clear();
+  }
+  RegionSnapshot& operator=(RegionSnapshot&& that)
+  {
+    region_type_ = that.region_type_;
+    storage_type_ = that.storage_type_;
+    object_info_ = that.object_info_;
+    start_addr_ = that.start_addr_;
+    size_ = that.size_;
+    permanent_addr_ = that.permanent_addr_;
+    flat_data_ = std::move(that.flat_data_);
+    page_numbers_ = std::move(that.page_numbers_);
+    privatized_regions_ = std::move(that.privatized_regions_);
+    that.clear();
+    return *this;
+  }
+
+  // Data
+
+  void clear()
+  {
+    region_type_ = MC_REGION_TYPE_UNKNOWN;
+    storage_type_ = MC_REGION_STORAGE_TYPE_NONE;
+    privatized_regions_.clear();
+    page_numbers_.clear();
+    flat_data_.clear();
+    object_info_ = nullptr;
+    start_addr_ = nullptr;
+    size_ = 0;
+    permanent_addr_ = nullptr;
+  }
+
+  void clear_data()
+  {
+    storage_type_ = MC_REGION_STORAGE_TYPE_NONE;
+    flat_data_.clear();
+    page_numbers_.clear();
+    privatized_regions_.clear();
+  }
+  
+  void flat_data(std::vector<char> data)
+  {
+    storage_type_ = MC_REGION_STORAGE_TYPE_FLAT;
+    flat_data_ = std::move(data);
+    page_numbers_.clear();
+    privatized_regions_.clear();
+  }
+  std::vector<char> const& flat_data() const { return flat_data_; }
+
+  void page_data(PerPageCopy page_data)
+  {
+    storage_type_ = MC_REGION_STORAGE_TYPE_CHUNKED;
+    flat_data_.clear();
+    page_numbers_ = std::move(page_data);
+    privatized_regions_.clear();
+  }
+  PerPageCopy const& page_data() const { return page_numbers_; }
+
+  void privatized_data(std::vector<RegionSnapshot> data)
+  {
+    storage_type_ = MC_REGION_STORAGE_TYPE_PRIVATIZED;
+    flat_data_.clear();
+    page_numbers_.clear();
+    privatized_regions_ = std::move(data);
+  }
+  std::vector<RegionSnapshot> const& privatized_data() const
+  {
+    return privatized_regions_;
+  }
+  std::vector<RegionSnapshot>& privatized_data()
+  {
+    return privatized_regions_;
+  }
+
+  mc_object_info_t object_info() const { return object_info_; }
+  void object_info(mc_object_info_t info) { object_info_ = info; }
+
+  // Other getters
+
+  remote_ptr<void> start() const { return remote(start_addr_); }
+  remote_ptr<void> end() const { return remote((char*)start_addr_ + size_); }
+  remote_ptr<void> permanent_address() const { return remote(permanent_addr_); }
+  std::size_t size() const { return size_; }
+  mc_region_storage_type_t storage_type() const { return storage_type_; }
+  mc_region_type_t region_type() const { return region_type_; }
+
+  bool contain(remote_ptr<void> p) const
+  {
+    return p >= start() && p < end();
+  }
 };
 
 }
@@ -171,38 +280,37 @@ public:
 
 typedef class simgrid::mc::RegionSnapshot s_mc_mem_region_t, *mc_mem_region_t;
 
-MC_SHOULD_BE_INTERNAL mc_mem_region_t mc_region_new_sparse(
+MC_SHOULD_BE_INTERNAL simgrid::mc::RegionSnapshot MC_region_sparse(
   mc_region_type_t type, void *start_addr, void* data_addr, size_t size);
 XBT_INTERNAL void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg);
 
 static inline  __attribute__ ((always_inline))
 bool mc_region_contain(mc_mem_region_t region, const void* p)
 {
-  return p >= region->start_addr &&
-    p < (void*)((char*) region->start_addr + region->size);
+  return region->contain(simgrid::mc::remote(p));
 }
 
 static inline __attribute__((always_inline))
 void* mc_translate_address_region_chunked(uintptr_t addr, mc_mem_region_t region)
 {
-  size_t pageno = mc_page_number(region->start_addr, (void*) addr);
+  size_t pageno = mc_page_number((void*)region->start().address(), (void*) addr);
   const void* snapshot_page =
-    region->page_numbers_.page(pageno);
+    region->page_data().page(pageno);
   return (char*) snapshot_page + mc_page_offset((void*) addr);
 }
 
 static inline __attribute__((always_inline))
 void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int process_index)
 {
-  switch (region->storage_type) {
+  switch (region->storage_type()) {
   case MC_REGION_STORAGE_TYPE_NONE:
   default:
     xbt_die("Storage type not supported");
 
   case MC_REGION_STORAGE_TYPE_FLAT:
     {
-      uintptr_t offset = addr - (uintptr_t) region->start_addr;
-      return (void *) ((uintptr_t) region->flat_data_.data() + offset);
+      uintptr_t offset = (uintptr_t) addr - (uintptr_t) region->start().address();
+      return (void *) ((uintptr_t) region->flat_data().data() + offset);
     }
 
   case MC_REGION_STORAGE_TYPE_CHUNKED:
@@ -212,11 +320,10 @@ void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int pr
     {
       xbt_assert(process_index >=0,
         "Missing process index for privatized region");
-      xbt_assert((size_t) process_index < region->privatized_regions_.size(),
+      xbt_assert((size_t) process_index < region->privatized_data().size(),
         "Out of range process index");
-      mc_mem_region_t subregion = region->privatized_regions_[process_index].get();
-      xbt_assert(subregion, "Missing memory region for process %i", process_index);
-      return mc_translate_address_region(addr, subregion, process_index);
+      simgrid::mc::RegionSnapshot& subregion= region->privatized_data()[process_index];
+      return mc_translate_address_region(addr, &subregion, process_index);
     }
   }
 }
@@ -331,16 +438,6 @@ XBT_INTERNAL void mc_restore_page_snapshot_region(
 MC_SHOULD_BE_INTERNAL const void* MC_region_read_fragmented(
   mc_mem_region_t region, void* target, const void* addr, size_t size);
 
-// Deprecated compatibility wrapper
-static inline
-const void* MC_snapshot_read(mc_snapshot_t snapshot,
-  simgrid::mc::AddressSpace::ReadMode mode,
-  void* target, const void* addr, size_t size, int process_index)
-{
-  return snapshot->read_bytes(target, size, simgrid::mc::remote(addr),
-    process_index, mode);
-}
-
 MC_SHOULD_BE_INTERNAL int MC_snapshot_region_memcmp(
   const void* addr1, mc_mem_region_t region1,
   const void* addr2, mc_mem_region_t region2, size_t size);
@@ -369,18 +466,18 @@ const void* MC_region_read(mc_mem_region_t region, void* target, const void* add
 {
   xbt_assert(region);
 
-  uintptr_t offset = (char*) addr - (char*) region->start_addr;
+  uintptr_t offset = (uintptr_t) addr - (uintptr_t) region->start().address();
 
   xbt_assert(mc_region_contain(region, addr),
     "Trying to read out of the region boundary.");
 
-  switch (region->storage_type) {
+  switch (region->storage_type()) {
   case MC_REGION_STORAGE_TYPE_NONE:
   default:
     xbt_die("Storage type not supported");
 
   case MC_REGION_STORAGE_TYPE_FLAT:
-    return (char*) region->flat_data_.data() + offset;
+    return (char*) region->flat_data().data() + offset;
 
   case MC_REGION_STORAGE_TYPE_CHUNKED:
     {