Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
mc: create RegionSparse, RegionDense and RegionPrivatized (WIP)
[simgrid.git] / src / mc / sosp / RegionSnapshot.hpp
index de4734a..2284ffa 100644 (file)
@@ -28,42 +28,43 @@ enum class StorageType { NoData = 0, Flat = 1, Chunked = 2, Privatized = 3 };
 
 class Buffer {
 private:
-  enum class Type { Malloc, Mmap };
   void* data_ = nullptr;
   std::size_t size_;
-  Type type_ = Type::Malloc;
 
-  Buffer(std::size_t size, Type type = Type::Malloc);
-  Buffer(void* data, std::size_t size, Type type = Type::Malloc) : data_(data), size_(size), type_(type) {}
+  explicit Buffer(std::size_t size) : size_(size) { data_ = ::operator new(size_); }
+
+  Buffer(void* data, std::size_t size) : data_(data), size_(size) {}
 
 public:
   Buffer() = default;
-  void clear() noexcept;
+  void clear() noexcept
+  {
+    ::operator delete(data_);
+    data_ = nullptr;
+    size_ = 0;
+  }
+
   ~Buffer() noexcept { clear(); }
 
-  static Buffer malloc(std::size_t size) { return Buffer(size, Type::Malloc); }
-  static Buffer mmap(std::size_t size) { return Buffer(size, Type::Mmap); }
+  static Buffer malloc(std::size_t size) { return Buffer(size); }
 
   // No copy
   Buffer(Buffer const& buffer) = delete;
   Buffer& operator=(Buffer const& buffer) = delete;
 
   // Move
-  Buffer(Buffer&& that) noexcept : data_(that.data_), size_(that.size_), type_(that.type_)
+  Buffer(Buffer&& that) noexcept : data_(that.data_), size_(that.size_)
   {
     that.data_ = nullptr;
     that.size_ = 0;
-    that.type_ = Type::Malloc;
   }
   Buffer& operator=(Buffer&& that) noexcept
   {
     clear();
     data_      = that.data_;
     size_      = that.size_;
-    type_      = that.type_;
     that.data_ = nullptr;
     that.size_ = 0;
-    that.type_ = Type::Malloc;
     return *this;
   }
 
@@ -96,16 +97,16 @@ public:
   static const RegionType HeapRegion    = RegionType::Heap;
   static const RegionType DataRegion    = RegionType::Data;
 
-private:
-  RegionType region_type_;
-  StorageType storage_type_;
-  simgrid::mc::ObjectInformation* object_info_;
+protected:
+  RegionType region_type_                      = UnknownRegion;
+  StorageType storage_type_                    = StorageType::NoData;
+  simgrid::mc::ObjectInformation* object_info_ = nullptr;
 
   /** @brief  Virtual address of the region in the simulated process */
-  void* start_addr_;
+  void* start_addr_ = nullptr;
 
   /** @brief Size of the data region in bytes */
-  std::size_t size_;
+  std::size_t size_ = 0;
 
   /** @brief Permanent virtual address of the region
    *
@@ -116,26 +117,16 @@ private:
    * on the region of the global variables.
    *
    * */
-  void* permanent_addr_;
+  void* permanent_addr_ = nullptr;
 
   Buffer flat_data_;
   ChunkedData page_numbers_;
-  std::vector<RegionSnapshot> privatized_regions_;
+  std::vector<std::unique_ptr<RegionSnapshot>> privatized_regions_;
 
 public:
-  RegionSnapshot()
-      : region_type_(UnknownRegion)
-      , storage_type_(StorageType::NoData)
-      , object_info_(nullptr)
-      , start_addr_(nullptr)
-      , size_(0)
-      , permanent_addr_(nullptr)
-  {
-  }
+  RegionSnapshot() {}
   RegionSnapshot(RegionType type, void* start_addr, void* permanent_addr, size_t size)
       : region_type_(type)
-      , storage_type_(StorageType::NoData)
-      , object_info_(nullptr)
       , start_addr_(start_addr)
       , size_(size)
       , permanent_addr_(permanent_addr)
@@ -195,34 +186,13 @@ public:
     privatized_regions_.clear();
   }
 
-  void flat_data(Buffer data)
-  {
-    storage_type_ = StorageType::Flat;
-    flat_data_    = std::move(data);
-    page_numbers_.clear();
-    privatized_regions_.clear();
-  }
   const Buffer& flat_data() const { return flat_data_; }
   Buffer& flat_data() { return flat_data_; }
 
-  void page_data(ChunkedData&& page_data)
-  {
-    storage_type_ = StorageType::Chunked;
-    flat_data_.clear();
-    page_numbers_ = std::move(page_data);
-    privatized_regions_.clear();
-  }
   ChunkedData const& page_data() const { return page_numbers_; }
 
-  void privatized_data(std::vector<RegionSnapshot> data)
-  {
-    storage_type_ = StorageType::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_; }
+  std::vector<std::unique_ptr<RegionSnapshot>> const& privatized_data() const { return privatized_regions_; }
+  std::vector<std::unique_ptr<RegionSnapshot>>& privatized_data() { return privatized_regions_; }
 
   simgrid::mc::ObjectInformation* object_info() const { return object_info_; }
   void object_info(simgrid::mc::ObjectInformation* info) { object_info_ = info; }
@@ -239,10 +209,20 @@ public:
   bool contain(RemotePtr<void> p) const { return p >= start() && p < end(); }
 };
 
-RegionSnapshot privatized_region(RegionType region_type, void* start_addr, void* permanent_addr, std::size_t size);
-RegionSnapshot dense_region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
-simgrid::mc::RegionSnapshot sparse_region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
-simgrid::mc::RegionSnapshot region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
+class RegionDense : public RegionSnapshot {
+public:
+  RegionDense(RegionType type, void* start_addr, void* data_addr, std::size_t size);
+};
+class RegionSparse : public RegionSnapshot {
+public:
+  RegionSparse(RegionType type, void* start_addr, void* data_addr, std::size_t size);
+};
+class RegionPrivatized : public RegionSnapshot {
+public:
+  RegionPrivatized(RegionType type, void* start_addr, void* data_addr, std::size_t size);
+};
+
+RegionSnapshot* region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
 
 } // namespace mc
 } // namespace simgrid