X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/f42358a7200f087c9047de7c7eaca0ad7d907c5c..7f80c96356063a741966f244c8d00eaaf6f17fc0:/src/mc/mc_snapshot.h

diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h
index 1d0f9b0937..b8f5f58c1e 100644
--- a/src/mc/mc_snapshot.h
+++ b/src/mc/mc_snapshot.h
@@ -10,125 +10,70 @@
 #include <sys/types.h> // off_t
 #include <stdint.h> // size_t
 
+#include <vector>
+#include <set>
+#include <memory>
+
 #include <simgrid_config.h>
 #include "../xbt/mmalloc/mmprivate.h"
 #include <xbt/asserts.h>
 #include <xbt/dynar.h>
 
 #include "mc_forward.h"
-#include "mc_model_checker.h"
-#include "mc_page_store.h"
+#include "ModelChecker.hpp"
+#include "PageStore.hpp"
 #include "mc_mmalloc.h"
+#include "mc/AddressSpace.hpp"
+#include "mc_unw.h"
+#include "RegionSnapshot.hpp"
 
 SG_BEGIN_DECL()
 
-void mc_softdirty_reset(void);
-
 // ***** Snapshot region
 
-#define NB_REGIONS 3 /* binary data (data + BSS) (type = 2), libsimgrid data (data + BSS) (type = 1), std_heap (type = 0)*/
-
-/** @brief Copy/snapshot of a given memory region
- *
- *  Two types of region snapshots exist:
- *  <ul>
- *    <li>flat/dense snapshots are a simple copy of the region;</li>
- *    <li>sparse/per-page snapshots are snaapshots which shared
- *    identical pages.</li>
- *  </ul>
- */
-typedef struct s_mc_mem_region{
-  /** @brief  Virtual address of the region in the simulated process */
-  void *start_addr;
-
-  /** @brief Permanent virtual address of the region
-   *
-   * This is usually the same address as the simuilated process address.
-   * However, when using SMPI privatization of global variables,
-   * each SMPI process has its own set of global variables stored
-   * at a different virtual address. The scheduler maps those region
-   * on the region of the global variables.
-   *
-   * */
-  void *permanent_addr;
-
-  /** @brief Copy of the snapshot for flat snapshots regions (NULL otherwise) */
-  void *data;
-
-  /** @brief Size of the data region in bytes */
-  size_t size;
-
-  /** @brief Pages indices in the page store for per-page snapshots (NULL otherwise) */
-  size_t* page_numbers;
-
-} s_mc_mem_region_t, *mc_mem_region_t;
-
-mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, void* data_addr, size_t size, mc_mem_region_t ref_reg);
-void MC_region_destroy(mc_mem_region_t reg);
-void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg);
-
-static inline  __attribute__ ((always_inline))
-bool mc_region_contain(mc_mem_region_t region, void* p)
-{
-  return p >= region->start_addr &&
-    p < (void*)((char*) region->start_addr + region->size);
-}
+XBT_INTERNAL void mc_region_restore_sparse(mc_process_t process, mc_mem_region_t reg);
 
 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->page_numbers[pageno];
-    const void* snapshot_page = mc_page_store_get_page(mc_model_checker->pages, snapshot_pageno);
-    return (char*) snapshot_page + mc_page_offset((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);
 }
 
-mc_mem_region_t mc_get_snapshot_region(void* addr, 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)
 {
+  switch (region->storage_type()) {
+  case simgrid::mc::StorageType::NoData:
+  default:
+    xbt_die("Storage type not supported");
+
+  case simgrid::mc::StorageType::Flat:
+    {
+      uintptr_t offset = (uintptr_t) addr - (uintptr_t) region->start().address();
+      return (void *) ((uintptr_t) region->flat_data().data() + offset);
+    }
 
-  // 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;
-  }
-
-  // Flat snapshot:
-  else if (region->data) {
-    uintptr_t offset = addr - (uintptr_t) region->start_addr;
-    return (void *) ((uintptr_t) region->data + offset);
+  case simgrid::mc::StorageType::Chunked:
+    return mc_translate_address_region_chunked(addr, region);
+
+  case simgrid::mc::StorageType::Privatized:
+    {
+      xbt_assert(process_index >=0,
+        "Missing process index for privatized region");
+      xbt_assert((size_t) process_index < region->privatized_data().size(),
+        "Out of range process index");
+      simgrid::mc::RegionSnapshot& subregion= region->privatized_data()[process_index];
+      return mc_translate_address_region(addr, &subregion, process_index);
+    }
   }
+}
 
-  // Per-page snapshot:
-  else if (region->page_numbers) {
-    return mc_translate_address_region(addr, region);
-  }
+XBT_INTERNAL mc_mem_region_t mc_get_snapshot_region(
+  const void* addr, const s_mc_snapshot_t *snapshot, int process_index);
 
-  else {
-    xbt_die("No data for this memory region");
-  }
 }
 
 // ***** MC Snapshot
@@ -140,53 +85,16 @@ void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot, int process_i
  * */
 typedef struct s_mc_snapshot_ignored_data {
   void* start;
-  size_t size;
-  void* data;
+  std::vector<char> data;
 } s_mc_snapshot_ignored_data_t, *mc_snapshot_ignored_data_t;
 
 typedef struct s_fd_infos{
-  char *filename;
+  std::string filename;
   int number;
   off_t current_position;
   int flags;
 }s_fd_infos_t, *fd_infos_t;
 
-struct s_mc_snapshot{
-  size_t heap_bytes_used;
-  mc_mem_region_t regions[NB_REGIONS];
-  xbt_dynar_t enabled_processes;
-  mc_mem_region_t* privatization_regions;
-  int privatization_index;
-  size_t *stack_sizes;
-  xbt_dynar_t stacks;
-  xbt_dynar_t to_ignore;
-  uint64_t hash;
-  xbt_dynar_t ignored_data;
-  int total_fd;
-  fd_infos_t *current_fd;
-};
-
-/** @brief Process index used when no process is available
- *
- *  The expected behaviour is that if a process index is needed it will fail.
- * */
-#define MC_NO_PROCESS_INDEX -1
-
-/** @brief Process index when any process is suitable
- *
- * We could use a special negative value in the future.
- */
-#define MC_ANY_PROCESS_INDEX 0
-
-static inline __attribute__ ((always_inline))
-mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, int process_index, mc_mem_region_t region)
-{
-  if (mc_region_contain(region, addr))
-    return region;
-  else
-    return mc_get_snapshot_region(addr, snapshot, process_index);
-}
-
 /** Information about a given stack frame
  *
  */
@@ -201,69 +109,97 @@ typedef struct s_mc_stack_frame {
   unw_cursor_t unw_cursor;
 } s_mc_stack_frame_t, *mc_stack_frame_t;
 
+typedef struct s_local_variable{
+  dw_frame_t subprogram;
+  unsigned long ip;
+  std::string name;
+  dw_type_t type;
+  void *address;
+  int region;
+} s_local_variable_t, *local_variable_t;
+
 typedef struct s_mc_snapshot_stack{
   xbt_dynar_t local_variables;
+  mc_unw_context_t context;
   xbt_dynar_t stack_frames; // mc_stack_frame_t
   int process_index;
 }s_mc_snapshot_stack_t, *mc_snapshot_stack_t;
 
-typedef struct s_mc_global_t{
+typedef struct s_mc_global_t {
   mc_snapshot_t snapshot;
-  int raw_mem_set;
   int prev_pair;
   char *prev_req;
   int initial_communications_pattern_done;
-  int comm_deterministic;
+  int recv_deterministic;
   int send_deterministic;
+  char *send_diff;
+  char *recv_diff;
 }s_mc_global_t, *mc_global_t;
 
-typedef struct s_mc_checkpoint_ignore_region{
-  void *addr;
-  size_t size;
-}s_mc_checkpoint_ignore_region_t, *mc_checkpoint_ignore_region_t;
+namespace simgrid {
+namespace mc {
+
+class Snapshot : public AddressSpace {
+public:
+  Snapshot();
+  ~Snapshot();
+  const void* read_bytes(void* buffer, std::size_t size,
+    remote_ptr<void> address, int process_index = ProcessIndexAny,
+    ReadMode mode = Normal) const MC_OVERRIDE;
+public: // To be private
+  mc_process_t process;
+  int num_state;
+  size_t heap_bytes_used;
+  std::vector<std::unique_ptr<s_mc_mem_region_t>> snapshot_regions;
+  std::set<pid_t> enabled_processes;
+  int privatization_index;
+  std::vector<size_t> stack_sizes;
+  xbt_dynar_t stacks;
+  std::vector<s_mc_heap_ignore_region_t> to_ignore;
+  uint64_t hash;
+  std::vector<s_mc_snapshot_ignored_data> ignored_data;
+  std::vector<s_fd_infos_t> current_fds;
+};
 
-static void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot);
+}
+}
 
-mc_snapshot_t MC_take_snapshot(int num_state);
-void MC_restore_snapshot(mc_snapshot_t);
-void MC_free_snapshot(mc_snapshot_t);
+extern "C" {
 
-int mc_important_snapshot(mc_snapshot_t snapshot);
+static inline __attribute__ ((always_inline))
+mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, int process_index, mc_mem_region_t region)
+{
+  if (region->contain(simgrid::mc::remote(addr)))
+    return region;
+  else
+    return mc_get_snapshot_region(addr, snapshot, process_index);
+}
 
-size_t* mc_take_page_snapshot_region(void* data, size_t page_count, uint64_t* pagemap, size_t* reference_pages);
-void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count);
-void mc_restore_page_snapshot_region(void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos);
+static const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot);
 
-static inline __attribute__((always_inline))
-bool mc_snapshot_region_linear(mc_mem_region_t region) {
-  return !region || !region->data;
-}
+XBT_INTERNAL mc_snapshot_t MC_take_snapshot(int num_state);
+XBT_INTERNAL void MC_restore_snapshot(mc_snapshot_t);
 
-void* mc_snapshot_read_fragmented(void* addr, mc_mem_region_t region, void* target, size_t size);
+XBT_INTERNAL void mc_restore_page_snapshot_region(
+  mc_process_t process,
+  void* start_addr, simgrid::mc::PerPageCopy const& pagenos);
 
-void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, int process_index, void* target, size_t size);
-int mc_snapshot_region_memcmp(
-  void* addr1, mc_mem_region_t region1,
-  void* addr2, mc_mem_region_t region2, size_t size);
-int mc_snapshot_memcmp(
-  void* addr1, mc_snapshot_t snapshot1,
-  void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size);
+MC_SHOULD_BE_INTERNAL const void* MC_region_read_fragmented(
+  mc_mem_region_t region, void* target, const void* addr, size_t size);
 
-static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index);
+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);
+XBT_INTERNAL int MC_snapshot_memcmp(
+  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))
-void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index)
+const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot)
 {
-  void* res;
-  return *(void**) mc_snapshot_read(addr, snapshot, process_index, &res, sizeof(void*));
-}
-
-static inline __attribute__ ((always_inline))
-  void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot) {
   if(snapshot==NULL)
       xbt_die("snapshot is NULL");
-  void** addr = &(std_heap->breakval);
-  return mc_snapshot_read_pointer(addr, snapshot, MC_ANY_PROCESS_INDEX);
+  return mc_model_checker->process().get_heap()->breakval;
 }
 
 /** @brief Read memory from a snapshot region
@@ -275,46 +211,54 @@ static inline __attribute__ ((always_inline))
  *  @return Pointer where the data is located (target buffer of original location)
  */
 static inline __attribute__((always_inline))
-void* mc_snapshot_read_region(void* addr, mc_mem_region_t region, void* target, size_t size)
+const void* MC_region_read(mc_mem_region_t region, void* target, const void* addr, size_t size)
 {
-  if (region==NULL)
-    return addr;
+  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),
+  xbt_assert(region->contain(simgrid::mc::remote(addr)),
     "Trying to read out of the region boundary.");
 
-  // Linear memory region:
-  if (region->data) {
-    return (char*) region->data + offset;
-  }
-
-  // Fragmented memory region:
-  else if (region->page_numbers) {
-    // Last byte of the region:
-    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);
-    } else {
-      // The memory spans several pages:
-      return mc_snapshot_read_fragmented(addr, region, target, size);
+  switch (region->storage_type()) {
+  case simgrid::mc::StorageType::NoData:
+  default:
+    xbt_die("Storage type not supported");
+
+  case simgrid::mc::StorageType::Flat:
+    return (char*) region->flat_data().data() + offset;
+
+  case simgrid::mc::StorageType::Chunked:
+    {
+      // Last byte of the region:
+      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_chunked((uintptr_t) addr, region);
+      } else {
+        // The memory spans several pages:
+        return MC_region_read_fragmented(region, target, addr, size);
+      }
     }
-  }
 
-  else {
-    xbt_die("No data available for this region");
+  // We currently do not pass the process_index to this function so we assume
+  // that the privatized region has been resolved in the callers:
+  case simgrid::mc::StorageType::Privatized:
+    xbt_die("Storage type not supported");
   }
 }
 
 static inline __attribute__ ((always_inline))
-void* mc_snapshot_read_pointer_region(void* addr, mc_mem_region_t region)
+void* MC_region_read_pointer(mc_mem_region_t region, const void* addr)
 {
   void* res;
-  return *(void**) mc_snapshot_read_region(addr, region, &res, sizeof(void*));
+  return *(void**) MC_region_read(region, &res, addr, sizeof(void*));
 }
 
 SG_END_DECL()
 
+XBT_INTERNAL int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2,
+                          std::vector<s_mc_heap_ignore_region_t>* i1,
+                          std::vector<s_mc_heap_ignore_region_t>* i2);
+
 #endif