} 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,
MC_REGION_STORAGE_TYPE_PRIVATIZED = 3
} mc_region_storage_type_t;
+namespace simgrid {
+namespace mc {
+
+class PerPageCopy {
+ PageStore* store_;
+ std::vector<std::size_t> pagenos_;
+public:
+ PerPageCopy() : store_(nullptr) {}
+ PerPageCopy(PerPageCopy const& that)
+ {
+ store_ = that.store_;
+ pagenos_ = that.pagenos_;
+ for (std::size_t pageno : pagenos_)
+ store_->ref_page(pageno);
+ }
+ void clear()
+ {
+ for (std::size_t pageno : pagenos_)
+ store_->unref_page(pageno);
+ pagenos_.clear();
+ }
+ ~PerPageCopy() {
+ clear();
+ }
+
+ PerPageCopy(PerPageCopy&& that)
+ {
+ store_ = that.store_;
+ that.store_ = nullptr;
+ pagenos_ = std::move(that.pagenos_);
+ that.pagenos_.clear();
+ }
+ PerPageCopy& operator=(PerPageCopy const& that)
+ {
+ this->clear();
+ store_ = that.store_;
+ pagenos_ = that.pagenos_;
+ for (std::size_t pageno : pagenos_)
+ store_->ref_page(pageno);
+ return *this;
+ }
+ PerPageCopy& operator=(PerPageCopy && that)
+ {
+ this->clear();
+ store_ = that.store_;
+ that.store_ = nullptr;
+ pagenos_ = std::move(that.pagenos_);
+ that.pagenos_.clear();
+ return *this;
+ }
+
+ std::size_t page_count() const
+ {
+ return pagenos_.size();
+ }
+
+ std::size_t pageno(std::size_t i) const
+ {
+ return pagenos_[i];
+ }
+
+ const void* page(std::size_t i) const
+ {
+ return store_->get_page(pagenos_[i]);
+ }
+
+ PerPageCopy(PageStore& store, AddressSpace& as,
+ remote_ptr<void> addr, std::size_t page_count);
+};
+
/** @brief Copy/snapshot of a given memory region
*
* Different types of region snapshot storage types exist:
* * an anonymous enum is used to distinguish the relevant types for
* each type.
*/
-typedef struct s_mc_mem_region s_mc_mem_region_t, *mc_mem_region_t;
-
-struct s_mc_mem_region {
- mc_region_type_t region_type;
- mc_region_storage_type_t storage_type;
- mc_object_info_t object_info;
+class RegionSnapshot {
+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
*
* on the region of the global variables.
*
* */
- void *permanent_addr;
-
- union {
- struct {
- /** @brief Copy of the snapshot for flat snapshots regions (NULL otherwise) */
- void *data;
- } flat;
- struct {
- /** @brief Pages indices in the page store for per-page snapshots (NULL otherwise) */
- size_t* page_numbers;
- } chunked;
- struct {
- size_t regions_count;
- mc_mem_region_t* regions;
- } privatized;
- };
+ void *permanent_addr_;
+
+ std::vector<char> flat_data_;
+ PerPageCopy page_numbers_;
+ 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)
+ {}
+ 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&) = 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();
+ }
};
-MC_SHOULD_BE_INTERNAL mc_mem_region_t mc_region_new_sparse(
+}
+}
+
+typedef class simgrid::mc::RegionSnapshot s_mc_mem_region_t, *mc_mem_region_t;
+
+MC_SHOULD_BE_INTERNAL simgrid::mc::RegionSnapshot MC_region_sparse(
mc_region_type_t type, void *start_addr, void* data_addr, size_t size);
-MC_SHOULD_BE_INTERNAL void MC_region_destroy(mc_mem_region_t reg);
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(uintptr_t addr, mc_mem_region_t region)
+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 snapshot_pageno = region->chunked.page_numbers[pageno];
+ size_t pageno = mc_page_number((void*)region->start().address(), (void*) addr);
const void* snapshot_page =
- mc_model_checker->page_store().get_page(snapshot_pageno);
+ region->page_data().page(pageno);
return (char*) snapshot_page + mc_page_offset((void*) addr);
}
-XBT_INTERNAL mc_mem_region_t mc_get_snapshot_region(
- const void* addr, const s_mc_snapshot_t *snapshot, int process_index);
-
-/** \brief Translate a pointer from process address space to snapshot address space
- *
- * The address space contains snapshot of the main/application memory:
- * this function finds the address in a given snaphot for a given
- * real/application address.
- *
- * For read only memory regions and other regions which are not int the
- * snapshot, the address is not changed.
- *
- * \param addr Application address
- * \param snapshot The snapshot of interest (if NULL no translation is done)
- * \return Translated address in the snapshot address space
- * */
static inline __attribute__((always_inline))
-void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot, int process_index)
+void* mc_translate_address_region(uintptr_t addr, mc_mem_region_t region, int process_index)
{
-
- // If not in a process state/clone:
- if (!snapshot) {
- return (uintptr_t *) addr;
- }
-
- mc_mem_region_t region = mc_get_snapshot_region((void*) addr, snapshot, process_index);
-
- xbt_assert(mc_region_contain(region, (void*) addr), "Trying to read out of the region boundary.");
-
- if (!region) {
- return (void *) addr;
- }
-
- 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 + 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:
- return mc_translate_address_region(addr, region);
+ return mc_translate_address_region_chunked(addr, region);
case MC_REGION_STORAGE_TYPE_PRIVATIZED:
{
xbt_assert(process_index >=0,
"Missing process index for privatized region");
- xbt_assert((size_t) process_index < region->privatized.regions_count,
+ 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];
- xbt_assert(subregion, "Missing memory region for process %i", process_index);
- return mc_translate_address(addr, snapshot, process_index);
+ simgrid::mc::RegionSnapshot& subregion= region->privatized_data()[process_index];
+ return mc_translate_address_region(addr, &subregion, process_index);
}
}
}
+XBT_INTERNAL mc_mem_region_t mc_get_snapshot_region(
+ const void* addr, const s_mc_snapshot_t *snapshot, int process_index);
+
// ***** MC Snapshot
/** Ignored data
~Snapshot();
const void* read_bytes(void* buffer, std::size_t size,
remote_ptr<void> address, int process_index = ProcessIndexAny,
- ReadMode mode = Normal) const override;
+ ReadMode mode = Normal) const MC_OVERRIDE;
public: // To be private
mc_process_t process;
int num_state;
XBT_INTERNAL mc_snapshot_t MC_take_snapshot(int num_state);
XBT_INTERNAL void MC_restore_snapshot(mc_snapshot_t);
-XBT_INTERNAL size_t* mc_take_page_snapshot_region(mc_process_t process,
- void* data, size_t page_count);
-XBT_INTERNAL void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count);
XBT_INTERNAL void mc_restore_page_snapshot_region(
mc_process_t process,
- void* start_addr, size_t page_count, size_t* pagenos);
+ void* start_addr, simgrid::mc::PerPageCopy const& pagenos);
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);
const void* addr1, mc_snapshot_t snapshot1,
const void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size);
-static inline __attribute__ ((always_inline))
-const void* MC_snapshot_read_pointer(mc_snapshot_t snapshot, const void* addr, int process_index)
-{
- void* res;
- return *(const void**) MC_snapshot_read(snapshot, simgrid::mc::AddressSpace::Lazy,
- &res, addr, sizeof(void*), process_index);
-}
-
static inline __attribute__ ((always_inline))
const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot)
{
{
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 + offset;
+ return (char*) region->flat_data().data() + offset;
case MC_REGION_STORAGE_TYPE_CHUNKED:
{
void* end = (char*) addr + size - 1;
if (mc_same_page(addr, end) ) {
// The memory is contained in a single page:
- return mc_translate_address_region((uintptr_t) addr, region);
+ return mc_translate_address_region_chunked((uintptr_t) addr, region);
} else {
// The memory spans several pages:
return MC_region_read_fragmented(region, target, addr, size);
