1 /* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved. */
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. */
6 #ifndef SIMGRID_MC_REGION_SNAPSHOT_HPP
7 #define SIMGRID_MC_REGION_SNAPSHOT_HPP
17 #include "src/mc/AddressSpace.hpp"
18 #include "src/mc/remote/RemotePtr.hpp"
19 #include "src/mc/sosp/ChunkedData.hpp"
20 #include "src/mc/sosp/PageStore.hpp"
25 enum class RegionType { Unknown = 0, Heap = 1, Data = 2 };
27 enum class StorageType { NoData = 0, Flat = 1, Chunked = 2, Privatized = 3 };
31 void* data_ = nullptr;
34 Buffer(std::size_t size) : size_(size) { data_ = ::operator new(size_); }
36 Buffer(void* data, std::size_t size) : data_(data), size_(size) {}
42 ::operator delete(data_);
47 ~Buffer() noexcept { clear(); }
49 static Buffer malloc(std::size_t size) { return Buffer(size); }
52 Buffer(Buffer const& buffer) = delete;
53 Buffer& operator=(Buffer const& buffer) = delete;
56 Buffer(Buffer&& that) noexcept : data_(that.data_), size_(that.size_)
61 Buffer& operator=(Buffer&& that) noexcept
71 void* get() { return data_; }
72 const void* get() const { return data_; }
73 std::size_t size() const { return size_; }
76 /** A copy/snapshot of a given memory region
78 * Different types of region snapshot storage types exist:
80 * * flat/dense snapshots are a simple copy of the region;
82 * * sparse/per-page snapshots are snaapshots which shared
85 * * privatized (SMPI global variable privatization).
87 * This is handled with a variant based approach:
89 * * `storage_type` identified the type of storage;
91 * * an anonymous enum is used to distinguish the relevant types for
94 class RegionSnapshot {
96 static const RegionType UnknownRegion = RegionType::Unknown;
97 static const RegionType HeapRegion = RegionType::Heap;
98 static const RegionType DataRegion = RegionType::Data;
101 RegionType region_type_;
102 StorageType storage_type_;
103 simgrid::mc::ObjectInformation* object_info_;
105 /** @brief Virtual address of the region in the simulated process */
108 /** @brief Size of the data region in bytes */
111 /** @brief Permanent virtual address of the region
113 * This is usually the same address as the simuilated process address.
114 * However, when using SMPI privatization of global variables,
115 * each SMPI process has its own set of global variables stored
116 * at a different virtual address. The scheduler maps those region
117 * on the region of the global variables.
120 void* permanent_addr_;
123 ChunkedData page_numbers_;
124 std::vector<RegionSnapshot> privatized_regions_;
128 : region_type_(UnknownRegion)
129 , storage_type_(StorageType::NoData)
130 , object_info_(nullptr)
131 , start_addr_(nullptr)
133 , permanent_addr_(nullptr)
136 RegionSnapshot(RegionType type, void* start_addr, void* permanent_addr, size_t size)
138 , storage_type_(StorageType::NoData)
139 , object_info_(nullptr)
140 , start_addr_(start_addr)
142 , permanent_addr_(permanent_addr)
145 ~RegionSnapshot() = default;
146 RegionSnapshot(RegionSnapshot const&) = delete;
147 RegionSnapshot& operator=(RegionSnapshot const&) = delete;
148 RegionSnapshot(RegionSnapshot&& that)
149 : region_type_(that.region_type_)
150 , storage_type_(that.storage_type_)
151 , object_info_(that.object_info_)
152 , start_addr_(that.start_addr_)
154 , permanent_addr_(that.permanent_addr_)
155 , flat_data_(std::move(that.flat_data_))
156 , page_numbers_(std::move(that.page_numbers_))
157 , privatized_regions_(std::move(that.privatized_regions_))
161 RegionSnapshot& operator=(RegionSnapshot&& that)
163 region_type_ = that.region_type_;
164 storage_type_ = that.storage_type_;
165 object_info_ = that.object_info_;
166 start_addr_ = that.start_addr_;
168 permanent_addr_ = that.permanent_addr_;
169 flat_data_ = std::move(that.flat_data_);
170 page_numbers_ = std::move(that.page_numbers_);
171 privatized_regions_ = std::move(that.privatized_regions_);
180 region_type_ = UnknownRegion;
181 storage_type_ = StorageType::NoData;
182 privatized_regions_.clear();
183 page_numbers_.clear();
185 object_info_ = nullptr;
186 start_addr_ = nullptr;
188 permanent_addr_ = nullptr;
193 storage_type_ = StorageType::NoData;
195 page_numbers_.clear();
196 privatized_regions_.clear();
199 void flat_data(Buffer data)
201 storage_type_ = StorageType::Flat;
202 flat_data_ = std::move(data);
203 page_numbers_.clear();
204 privatized_regions_.clear();
206 const Buffer& flat_data() const { return flat_data_; }
207 Buffer& flat_data() { return flat_data_; }
209 void page_data(ChunkedData&& page_data)
211 storage_type_ = StorageType::Chunked;
213 page_numbers_ = std::move(page_data);
214 privatized_regions_.clear();
216 ChunkedData const& page_data() const { return page_numbers_; }
218 void privatized_data(std::vector<RegionSnapshot> data)
220 storage_type_ = StorageType::Privatized;
222 page_numbers_.clear();
223 privatized_regions_ = std::move(data);
225 std::vector<RegionSnapshot> const& privatized_data() const { return privatized_regions_; }
226 std::vector<RegionSnapshot>& privatized_data() { return privatized_regions_; }
228 simgrid::mc::ObjectInformation* object_info() const { return object_info_; }
229 void object_info(simgrid::mc::ObjectInformation* info) { object_info_ = info; }
233 RemotePtr<void> start() const { return remote(start_addr_); }
234 RemotePtr<void> end() const { return remote((char*)start_addr_ + size_); }
235 RemotePtr<void> permanent_address() const { return remote(permanent_addr_); }
236 std::size_t size() const { return size_; }
237 StorageType storage_type() const { return storage_type_; }
238 RegionType region_type() const { return region_type_; }
240 bool contain(RemotePtr<void> p) const { return p >= start() && p < end(); }
243 RegionSnapshot privatized_region(RegionType region_type, void* start_addr, void* permanent_addr, std::size_t size);
244 RegionSnapshot dense_region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
245 simgrid::mc::RegionSnapshot sparse_region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
246 simgrid::mc::RegionSnapshot region(RegionType type, void* start_addr, void* data_addr, std::size_t size);
249 } // namespace simgrid