1 /* Copyright (c) 2007-2015. The SimGrid Team.
2 * All rights reserved. */
4 /* This program is free software; you can redistribute it and/or modify it
5 * under the terms of the license (GNU LGPL) which comes with this package. */
7 #ifndef SIMGRID_MC_REGION_SNAPSHOT_HPP
8 #define SIMGRID_MC_REGION_SNAPSHOT_HPP
18 #include "src/mc/remote_ptr.hpp"
19 #include "src/mc/PageStore.hpp"
20 #include "src/mc/AddressSpace.hpp"
21 #include "src/mc/ChunkedData.hpp"
26 enum class RegionType {
32 // TODO, use Boost.Variant instead of this
33 enum class StorageType {
50 data_deleter() : type_(Free) {}
51 data_deleter(Type type, std::size_t size) : type_(type), size_(size) {}
52 void operator()(void* p) const;
55 typedef std::unique_ptr<char[], data_deleter> unique_data_ptr;
57 /** A copy/snapshot of a given memory region
59 * Different types of region snapshot storage types exist:
61 * * flat/dense snapshots are a simple copy of the region;
63 * * sparse/per-page snapshots are snaapshots which shared
66 * * privatized (SMPI global variable privatisation).
68 * This is handled with a variant based approch:
70 * * `storage_type` identified the type of storage;
72 * * an anonymous enum is used to distinguish the relevant types for
75 class RegionSnapshot {
77 static const RegionType UnknownRegion = RegionType::Unknown;
78 static const RegionType HeapRegion = RegionType::Heap;
79 static const RegionType DataRegion = RegionType::Data;
81 typedef unique_data_ptr flat_data_ptr;
83 RegionType region_type_;
84 StorageType storage_type_;
85 simgrid::mc::ObjectInformation* object_info_;
87 /** @brief Virtual address of the region in the simulated process */
90 /** @brief Size of the data region in bytes */
93 /** @brief Permanent virtual address of the region
95 * This is usually the same address as the simuilated process address.
96 * However, when using SMPI privatization of global variables,
97 * each SMPI process has its own set of global variables stored
98 * at a different virtual address. The scheduler maps those region
99 * on the region of the global variables.
102 void *permanent_addr_;
104 flat_data_ptr flat_data_;
105 ChunkedData page_numbers_;
106 std::vector<RegionSnapshot> privatized_regions_;
109 region_type_(UnknownRegion),
110 storage_type_(StorageType::NoData),
111 object_info_(nullptr),
112 start_addr_(nullptr),
114 permanent_addr_(nullptr)
116 RegionSnapshot(RegionType type, void *start_addr, void* permanent_addr, size_t size) :
118 storage_type_(StorageType::NoData),
119 object_info_(nullptr),
120 start_addr_(start_addr),
122 permanent_addr_(permanent_addr)
125 RegionSnapshot(RegionSnapshot const&) = default;
126 RegionSnapshot& operator=(RegionSnapshot const&) = default;
127 RegionSnapshot(RegionSnapshot&& that)
129 region_type_ = that.region_type_;
130 storage_type_ = that.storage_type_;
131 object_info_ = that.object_info_;
132 start_addr_ = that.start_addr_;
134 permanent_addr_ = that.permanent_addr_;
135 flat_data_ = std::move(that.flat_data_);
136 page_numbers_ = std::move(that.page_numbers_);
137 privatized_regions_ = std::move(that.privatized_regions_);
140 RegionSnapshot& operator=(RegionSnapshot&& that)
142 region_type_ = that.region_type_;
143 storage_type_ = that.storage_type_;
144 object_info_ = that.object_info_;
145 start_addr_ = that.start_addr_;
147 permanent_addr_ = that.permanent_addr_;
148 flat_data_ = std::move(that.flat_data_);
149 page_numbers_ = std::move(that.page_numbers_);
150 privatized_regions_ = std::move(that.privatized_regions_);
159 region_type_ = UnknownRegion;
160 storage_type_ = StorageType::NoData;
161 privatized_regions_.clear();
162 page_numbers_.clear();
164 object_info_ = nullptr;
165 start_addr_ = nullptr;
167 permanent_addr_ = nullptr;
172 storage_type_ = StorageType::NoData;
174 page_numbers_.clear();
175 privatized_regions_.clear();
178 void flat_data(flat_data_ptr data)
180 storage_type_ = StorageType::Flat;
181 flat_data_ = std::move(data);
182 page_numbers_.clear();
183 privatized_regions_.clear();
185 const char* flat_data() const { return flat_data_.get(); }
187 void page_data(ChunkedData page_data)
189 storage_type_ = StorageType::Chunked;
191 page_numbers_ = std::move(page_data);
192 privatized_regions_.clear();
194 ChunkedData const& page_data() const { return page_numbers_; }
196 void privatized_data(std::vector<RegionSnapshot> data)
198 storage_type_ = StorageType::Privatized;
200 page_numbers_.clear();
201 privatized_regions_ = std::move(data);
203 std::vector<RegionSnapshot> const& privatized_data() const
205 return privatized_regions_;
207 std::vector<RegionSnapshot>& privatized_data()
209 return privatized_regions_;
212 simgrid::mc::ObjectInformation* object_info() const { return object_info_; }
213 void object_info(simgrid::mc::ObjectInformation* info) { object_info_ = info; }
217 remote_ptr<void> start() const { return remote(start_addr_); }
218 remote_ptr<void> end() const { return remote((char*)start_addr_ + size_); }
219 remote_ptr<void> permanent_address() const { return remote(permanent_addr_); }
220 std::size_t size() const { return size_; }
221 StorageType storage_type() const { return storage_type_; }
222 RegionType region_type() const { return region_type_; }
224 bool contain(remote_ptr<void> p) const
226 return p >= start() && p < end();
230 RegionSnapshot privatized_region(
231 RegionType region_type, void *start_addr, void* permanent_addr,
232 std::size_t size, const RegionSnapshot* ref_region);
233 RegionSnapshot dense_region(
234 RegionType type, void *start_addr, void* data_addr, std::size_t size);
235 simgrid::mc::RegionSnapshot sparse_region(
236 RegionType type, void *start_addr, void* data_addr, std::size_t size,
237 RegionSnapshot const* ref_region);
238 simgrid::mc::RegionSnapshot region(
239 RegionType type, void *start_addr, void* data_addr, std::size_t size,
240 RegionSnapshot const* ref_region);
245 typedef class simgrid::mc::RegionSnapshot s_mc_mem_region_t, *mc_mem_region_t;