[mc] RegionSnapshot, make all fields private

diff --git a/src/mc/mc_checkpoint.cpp b/src/mc/mc_checkpoint.cpp
index 071caa8..9a1285b 100644 (file)
--- a/src/mc/mc_checkpoint.cpp
+++ b/src/mc/mc_checkpoint.cpp
@@ -129,15 +129,15 @@ static mc_mem_region_t MC_region_new(
  */
 static void MC_region_restore(mc_mem_region_t region)
 {
-  switch(region->storage_type) {
+  switch(region->storage_type()) {
   case MC_REGION_STORAGE_TYPE_NONE:
   default:
     xbt_die("Storage type not supported");
     break;
 
   case MC_REGION_STORAGE_TYPE_FLAT:
-    mc_model_checker->process().write_bytes(region->flat_data().data(), region->size,
-      remote(region->permanent_addr));
+    mc_model_checker->process().write_bytes(region->flat_data().data(),
+      region->size(), region->permanent_address());
     break;
 
   case MC_REGION_STORAGE_TYPE_CHUNKED:
@@ -197,7 +197,7 @@ static void MC_snapshot_add_region(int index, mc_snapshot_t snapshot, mc_region_
   else
     region = MC_region_new(type, start_addr, permanent_addr, size);
 
-  region->object_info = object_info;
+  region->object_info(object_info);
   snapshot->snapshot_regions[index] = region;
   return;
 }

diff --git a/src/mc/mc_compare.cpp b/src/mc/mc_compare.cpp
index a5a0bc7..73b4b34 100644 (file)
--- a/src/mc/mc_compare.cpp
+++ b/src/mc/mc_compare.cpp
@@ -268,9 +268,9 @@ static int compare_global_variables(mc_object_info_t object_info,
   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;
     }
 
@@ -289,9 +289,9 @@ static int compare_global_variables(mc_object_info_t object_info,
     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;
 
@@ -589,15 +589,14 @@ int snapshot_compare(void *state1, void *state2)
     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)
@@ -607,7 +606,7 @@ int snapshot_compare(void *state1, void *state2)
 
     /* 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);
 

diff --git a/src/mc/mc_diff.cpp b/src/mc/mc_diff.cpp
index d14424b..e64d3a9 100644 (file)
--- a/src/mc/mc_diff.cpp
+++ b/src/mc/mc_diff.cpp
@@ -421,7 +421,7 @@ mc_mem_region_t MC_get_heap_region(mc_snapshot_t snapshot)
   size_t n = snapshot->snapshot_regions_count;
   for (size_t i=0; i!=n; ++i) {
     mc_mem_region_t region = snapshot->snapshot_regions[i];
-    if (region->region_type == MC_REGION_TYPE_HEAP)
+    if (region->region_type() == MC_REGION_TYPE_HEAP)
       return region;
   }
   xbt_die("No heap region");

diff --git a/src/mc/mc_page_snapshot.cpp b/src/mc/mc_page_snapshot.cpp
index cc75c46..f0fb2c1 100644 (file)
--- a/src/mc/mc_page_snapshot.cpp
+++ b/src/mc/mc_page_snapshot.cpp
@@ -106,11 +106,11 @@ mc_mem_region_t mc_region_new_sparse(mc_region_type_t region_type,
 
 void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg)
 {
-  xbt_assert((((uintptr_t)reg->permanent_addr) & (xbt_pagesize-1)) == 0,
+  xbt_assert(((reg->permanent_address().address()) & (xbt_pagesize-1)) == 0,
     "Not at the beginning of a page");
-  xbt_assert(mc_page_count(reg->size) == reg->page_data().page_count());
+  xbt_assert(mc_page_count(reg->size()) == reg->page_data().page_count());
   mc_restore_page_snapshot_region(process,
-    reg->permanent_addr, reg->page_data());
+    (void*) reg->permanent_address().address(), reg->page_data());
 }
 
 }

diff --git a/src/mc/mc_snapshot.cpp b/src/mc/mc_snapshot.cpp
index f0f36b1..89f5c56 100644 (file)
--- a/src/mc/mc_snapshot.cpp
+++ b/src/mc/mc_snapshot.cpp
@@ -32,7 +32,7 @@ mc_mem_region_t mc_get_snapshot_region(
     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) {
@@ -114,8 +114,8 @@ int MC_snapshot_region_memcmp(
   // 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);

diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h
index 0a46b74..7b9fa10 100644 (file)
--- a/src/mc/mc_snapshot.h
+++ b/src/mc/mc_snapshot.h
@@ -127,16 +127,16 @@ public:
  *      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
    *
@@ -147,36 +147,37 @@ public:
    * 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();
@@ -184,7 +185,7 @@ public:
   
   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();
@@ -193,7 +194,7 @@ public:
 
   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();
@@ -202,7 +203,7 @@ public:
 
   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);
@@ -211,6 +212,23 @@ public:
   {
     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();
+  }
 };
 
 }
@@ -225,14 +243,13 @@ XBT_INTERNAL void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t
 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);
@@ -241,14 +258,14 @@ void* mc_translate_address_region_chunked(uintptr_t addr, mc_mem_region_t region
 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);
     }
 
@@ -416,12 +433,12 @@ const void* MC_region_read(mc_mem_region_t region, void* target, const void* add
 {
   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");