xbt_assert(r1 && r2, "Missing region.");
#ifdef HAVE_SMPI
- if (r1->storage_type == MC_REGION_STORAGE_TYPE_PRIVATIZED) {
+ if (r1->storage_type() == MC_REGION_STORAGE_TYPE_PRIVATIZED) {
xbt_assert(process_index >= 0);
- if (r2->storage_type != MC_REGION_STORAGE_TYPE_PRIVATIZED) {
+ if (r2->storage_type() != MC_REGION_STORAGE_TYPE_PRIVATIZED) {
return 1;
}
return 0;
}
#else
- xbt_assert(r1->storage_type != MC_REGION_STORAGE_TYPE_PRIVATIZED);
+ xbt_assert(r1->storage_type() != MC_REGION_STORAGE_TYPE_PRIVATIZED);
#endif
- xbt_assert(r2->storage_type != MC_REGION_STORAGE_TYPE_PRIVATIZED);
+ xbt_assert(r2->storage_type() != MC_REGION_STORAGE_TYPE_PRIVATIZED);
struct mc_compare_state state;
mc_mem_region_t region2 = s2->snapshot_regions[k];
// Preconditions:
- if (region1->region_type != MC_REGION_TYPE_DATA)
+ if (region1->region_type() != MC_REGION_TYPE_DATA)
continue;
- xbt_assert(region1->region_type == region2->region_type);
- xbt_assert(region1->object_info == region2->object_info);
+ xbt_assert(region1->region_type() == region2->region_type());
+ xbt_assert(region1->object_info() == region2->object_info());
+ xbt_assert(region1->object_info());
- xbt_assert(region1->object_info);
-
- const char* name = region1->object_info->file_name;
+ const char* name = region1->object_info()->file_name;
#ifdef MC_DEBUG
if (is_diff == 0)
/* Compare global variables */
is_diff =
- compare_global_variables(region1->object_info, simgrid::mc::AddressSpace::Normal,
+ compare_global_variables(region1->object_info( ), simgrid::mc::AddressSpace::Normal,
region1, region2,
s1, s2);
if (!(region && mc_region_contain(region, addr)))
continue;
- if (region->storage_type == MC_REGION_STORAGE_TYPE_PRIVATIZED) {
+ if (region->storage_type() == MC_REGION_STORAGE_TYPE_PRIVATIZED) {
#ifdef HAVE_SMPI
// Use the current process index of the snapshot:
if (process_index == simgrid::mc::ProcessIndexDisabled) {
// Using alloca() for large allocations may trigger stack overflow:
// use malloc if the buffer is too big.
bool stack_alloc = size < 64;
- const bool region1_need_buffer = region1==NULL || region1->storage_type==MC_REGION_STORAGE_TYPE_FLAT;
- const bool region2_need_buffer = region2==NULL || region2->storage_type==MC_REGION_STORAGE_TYPE_FLAT;
+ const bool region1_need_buffer = region1==NULL || region1->storage_type()==MC_REGION_STORAGE_TYPE_FLAT;
+ const bool region2_need_buffer = region2==NULL || region2->storage_type()==MC_REGION_STORAGE_TYPE_FLAT;
void* buffer1a = region1_need_buffer ? NULL : stack_alloc ? alloca(size) : malloc(size);
void* buffer2a = region2_need_buffer ? NULL : stack_alloc ? alloca(size) : malloc(size);
const void* buffer1 = MC_region_read(region1, buffer1a, addr1, size);
* 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
*
* on the region of the global variables.
*
* */
- void *permanent_addr;
+ void *permanent_addr_;
-private:
std::vector<char> flat_data_;
PerPageCopy page_numbers_;
std::vector<std::unique_ptr<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)
+ 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;
+ // Data
+
void clear_data()
{
- storage_type = MC_REGION_STORAGE_TYPE_NONE;
+ 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;
+ storage_type_ = MC_REGION_STORAGE_TYPE_FLAT;
flat_data_ = std::move(data);
page_numbers_.clear();
privatized_regions_.clear();
void page_data(PerPageCopy page_data)
{
- storage_type = MC_REGION_STORAGE_TYPE_CHUNKED;
+ storage_type_ = MC_REGION_STORAGE_TYPE_CHUNKED;
flat_data_.clear();
page_numbers_ = std::move(page_data);
privatized_regions_.clear();
void privatized_data(std::vector<std::unique_ptr<RegionSnapshot>> data)
{
- storage_type = MC_REGION_STORAGE_TYPE_PRIVATIZED;
+ storage_type_ = MC_REGION_STORAGE_TYPE_PRIVATIZED;
flat_data_.clear();
page_numbers_.clear();
privatized_regions_ = std::move(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();
+ }
};
}
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_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;
+ uintptr_t offset = (uintptr_t) addr - (uintptr_t) region->start().address();
return (void *) ((uintptr_t) region->flat_data().data() + offset);
}
{
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");