X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4ea83ea565b18593a9e6864b7e43d02fc8500f23..bff0c1c16b4447b3503aa48d11b15243154ed51a:/src/mc/mc_snapshot.h

diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h
index 0a46b747e9..c799698414 100644
--- a/src/mc/mc_snapshot.h
+++ b/src/mc/mc_snapshot.h
@@ -1,275 +1,83 @@
-/* Copyright (c) 2007-2014. The SimGrid Team.
+/* Copyright (c) 2007-2015. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#ifndef MC_SNAPSHOT_H
-#define MC_SNAPSHOT_H
+#ifndef SIMGRID_MC_SNAPSHOT_H
+#define SIMGRID_MC_SNAPSHOT_H
+
+#include <cstdint>
+#include <cstddef>
+
+#include <vector>
+#include <set>
+#include <string>
+#include <memory>
 
 #include <sys/types.h> // off_t
-#include <stdint.h> // size_t
 
 #include <simgrid_config.h>
-#include "../xbt/mmalloc/mmprivate.h"
+#include "src/xbt/mmalloc/mmprivate.h"
 #include <xbt/asserts.h>
-#include <xbt/dynar.h>
+#include <xbt/base.h>
 
-#include "mc_forward.h"
-#include "ModelChecker.hpp"
-#include "PageStore.hpp"
-#include "mc_mmalloc.h"
-#include "mc/AddressSpace.hpp"
-#include "mc_unw.h"
+#include "src/mc/mc_forward.hpp"
+#include "src/mc/ModelChecker.hpp"
+#include "src/mc/PageStore.hpp"
+#include "src/mc/AddressSpace.hpp"
+#include "src/mc/mc_unw.h"
+#include "src/mc/RegionSnapshot.hpp"
 
 SG_BEGIN_DECL()
 
 // ***** Snapshot region
 
-typedef enum e_mc_region_type_t {
-  MC_REGION_TYPE_UNKNOWN = 0,
-  MC_REGION_TYPE_HEAP = 1,
-  MC_REGION_TYPE_DATA = 2
-} mc_region_type_t;
-
-// TODO, use OO instead of this
-typedef enum e_mc_region_storeage_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:
- *  <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>
- *    <li>privatized (SMPI global variable privatisation).
- *  </ul>
- *
- *  This is handled with a variant based approch:
- *
- *    * `storage_type` identified the type of storage;
- *    * an anonymous enum is used to distinguish the relevant types for
- *      each type.
- */
-class RegionSnapshot {
-public:
-  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;
-
-  /** @brief Size of the data region in bytes */
-  size_t size;
-
-  /** @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;
-
-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)
-  {}
-  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&) = delete;
-  RegionSnapshot& operator=(RegionSnapshot const&) = delete;
-
-  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<std::unique_ptr<RegionSnapshot>> data)
-  {
-    storage_type = MC_REGION_STORAGE_TYPE_PRIVATIZED;
-    flat_data_.clear();
-    page_numbers_.clear();
-    privatized_regions_ = std::move(data);
-  }
-  std::vector<std::unique_ptr<RegionSnapshot>> const& privatized_data() const
-  {
-    return privatized_regions_;
-  }
-};
-
-}
-}
-
-typedef class simgrid::mc::RegionSnapshot s_mc_mem_region_t, *mc_mem_region_t;
-
-MC_SHOULD_BE_INTERNAL mc_mem_region_t mc_region_new_sparse(
-  mc_region_type_t type, void *start_addr, void* data_addr, size_t size);
-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);
-}
+XBT_PRIVATE void mc_region_restore_sparse(simgrid::mc::Process* process, mc_mem_region_t reg);
 
 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);
-  const void* snapshot_page =
-    region->page_data().page(pageno);
-  return (char*) snapshot_page + mc_page_offset((void*) addr);
+  auto split = simgrid::mc::mmu::split(addr - region->start().address());
+  auto pageno = split.first;
+  auto offset = split.second;
+  const void* snapshot_page = region->page_data().page(pageno);
+  return (char*) snapshot_page + offset;
 }
 
 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) {
-  case MC_REGION_STORAGE_TYPE_NONE:
+  switch (region->storage_type()) {
+  case simgrid::mc::StorageType::NoData:
   default:
     xbt_die("Storage type not supported");
 
-  case MC_REGION_STORAGE_TYPE_FLAT:
+  case simgrid::mc::StorageType::Flat:
     {
-      uintptr_t offset = addr - (uintptr_t) region->start_addr;
-      return (void *) ((uintptr_t) region->flat_data().data() + offset);
+      uintptr_t offset = (uintptr_t) addr - (uintptr_t) region->start().address();
+      return (void *) ((uintptr_t) region->flat_data().get() + offset);
     }
 
-  case MC_REGION_STORAGE_TYPE_CHUNKED:
+  case simgrid::mc::StorageType::Chunked:
     return mc_translate_address_region_chunked(addr, region);
 
-  case MC_REGION_STORAGE_TYPE_PRIVATIZED:
+  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");
-      mc_mem_region_t subregion = region->privatized_data()[process_index].get();
-      xbt_assert(subregion, "Missing memory region for process %i", process_index);
-      return mc_translate_address_region(addr, subregion, 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);
+XBT_PRIVATE mc_mem_region_t mc_get_snapshot_region(
+  const void* addr, const simgrid::mc::Snapshot *snapshot, int process_index);
+
+}
 
 // ***** MC Snapshot
 
@@ -280,44 +88,68 @@ XBT_INTERNAL mc_mem_region_t mc_get_snapshot_region(
  * */
 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;
 
-}
+/** Information about a given stack frame
+ *
+ */
+typedef struct s_mc_stack_frame {
+  /** Instruction pointer */
+  unw_word_t ip;
+  /** Stack pointer */
+  unw_word_t sp;
+  unw_word_t frame_base;
+  simgrid::mc::Frame* frame;
+  std::string frame_name;
+  unw_cursor_t unw_cursor;
+} s_mc_stack_frame_t, *mc_stack_frame_t;
+
+typedef struct s_local_variable{
+  simgrid::mc::Frame* subprogram;
+  unsigned long ip;
+  std::string name;
+  simgrid::mc::Type* type;
+  void *address;
+  int region;
+} s_local_variable_t, *local_variable_t;
+
+typedef struct XBT_PRIVATE s_mc_snapshot_stack {
+  std::vector<s_local_variable> local_variables;
+  simgrid::mc::UnwindContext context;
+  std::vector<s_mc_stack_frame_t> stack_frames;
+  int process_index;
+} s_mc_snapshot_stack_t, *mc_snapshot_stack_t;
 
 namespace simgrid {
 namespace mc {
 
-class Snapshot : public AddressSpace {
+class XBT_PRIVATE Snapshot final : public AddressSpace {
 public:
-  Snapshot();
+  Snapshot(Process* process);
   ~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;
+    RemotePtr<void> address, int process_index = ProcessIndexAny,
+    ReadOptions options = ReadOptions::none()) const override;
 public: // To be private
-  mc_process_t process;
   int num_state;
-  size_t heap_bytes_used;
-  mc_mem_region_t* snapshot_regions;
-  size_t snapshot_regions_count;
-  xbt_dynar_t enabled_processes;
+  std::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;
-  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;
+  std::vector<std::size_t> stack_sizes;
+  std::vector<s_mc_snapshot_stack_t> stacks;
+  std::vector<simgrid::mc::IgnoredHeapRegion> to_ignore;
+  std::uint64_t hash;
+  std::vector<s_mc_snapshot_ignored_data> ignored_data;
+  std::vector<s_fd_infos_t> current_fds;
 };
 
 }
@@ -326,80 +158,52 @@ public: // To be private
 extern "C" {
 
 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)
+mc_mem_region_t mc_get_region_hinted(void* addr, simgrid::mc::Snapshot* snapshot, int process_index, mc_mem_region_t region)
 {
-  if (mc_region_contain(region, addr))
+  if (region->contain(simgrid::mc::remote(addr)))
     return region;
   else
     return mc_get_snapshot_region(addr, snapshot, process_index);
 }
 
-/** Information about a given stack frame
- *
- */
-typedef struct s_mc_stack_frame {
-  /** Instruction pointer */
-  unw_word_t ip;
-  /** Stack pointer */
-  unw_word_t sp;
-  unw_word_t frame_base;
-  dw_frame_t frame;
-  char* frame_name;
-  unw_cursor_t unw_cursor;
-} s_mc_stack_frame_t, *mc_stack_frame_t;
+static const void* mc_snapshot_get_heap_end(simgrid::mc::Snapshot* snapshot);
 
-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 {
-  mc_snapshot_t snapshot;
-  int prev_pair;
-  char *prev_req;
-  int initial_communications_pattern_done;
-  int recv_deterministic;
-  int send_deterministic;
-  char *send_diff;
-  char *recv_diff;
-}s_mc_global_t, *mc_global_t;
-
-static const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot);
-
-XBT_INTERNAL mc_snapshot_t MC_take_snapshot(int num_state);
-XBT_INTERNAL void MC_restore_snapshot(mc_snapshot_t);
-
-XBT_INTERNAL void mc_restore_page_snapshot_region(
-  mc_process_t process,
-  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(
+#ifdef __cplusplus
+
+namespace simgrid {
+namespace mc {
+
+XBT_PRIVATE std::shared_ptr<simgrid::mc::Snapshot> take_snapshot(int num_state);
+XBT_PRIVATE void restore_snapshot(std::shared_ptr<simgrid::mc::Snapshot> snapshot);
+
+}
+}
+
+#endif
+
+extern "C" {
+
+XBT_PRIVATE void mc_restore_page_snapshot_region(
+  simgrid::mc::Process* process,
+  void* start_addr, simgrid::mc::ChunkedData const& pagenos);
+
+const void* MC_region_read_fragmented(
+  mc_mem_region_t region, void* target, const void* addr, std::size_t size);
+
+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);
+  const void* addr2, mc_mem_region_t region2, std::size_t size);
+XBT_PRIVATE int MC_snapshot_memcmp(
+  const void* addr1, simgrid::mc::Snapshot* snapshot1,
+  const void* addr2, simgrid::mc::Snapshot* snapshot2, int process_index, std::size_t size);
 
 static inline __attribute__ ((always_inline))
-const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot)
+const void* mc_snapshot_get_heap_end(simgrid::mc::Snapshot* snapshot)
 {
-  if(snapshot==NULL)
-      xbt_die("snapshot is NULL");
+  if(snapshot==nullptr)
+      xbt_die("snapshot is nullptr");
   return mc_model_checker->process().get_heap()->breakval;
 }
 
@@ -412,28 +216,30 @@ const void* mc_snapshot_get_heap_end(mc_snapshot_t snapshot)
  *  @return Pointer where the data is located (target buffer of original location)
  */
 static inline __attribute__((always_inline))
-const void* MC_region_read(mc_mem_region_t region, void* target, const void* addr, size_t size)
+const void* MC_region_read(
+  mc_mem_region_t region, void* target, const void* addr, std::size_t size)
 {
   xbt_assert(region);
 
-  uintptr_t offset = (char*) addr - (char*) region->start_addr;
+  std::uintptr_t offset =
+    (std::uintptr_t) addr - (std::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.");
 
-  switch (region->storage_type) {
-  case MC_REGION_STORAGE_TYPE_NONE:
+  switch (region->storage_type()) {
+  case simgrid::mc::StorageType::NoData:
   default:
     xbt_die("Storage type not supported");
 
-  case MC_REGION_STORAGE_TYPE_FLAT:
-    return (char*) region->flat_data().data() + offset;
+  case simgrid::mc::StorageType::Flat:
+    return (char*) region->flat_data().get() + offset;
 
-  case MC_REGION_STORAGE_TYPE_CHUNKED:
+  case simgrid::mc::StorageType::Chunked:
     {
       // Last byte of the region:
       void* end = (char*) addr + size - 1;
-      if (mc_same_page(addr, end) ) {
+      if (simgrid::mc::mmu::sameChunk((std::uintptr_t) addr, (std::uintptr_t) end) ) {
         // The memory is contained in a single page:
         return mc_translate_address_region_chunked((uintptr_t) addr, region);
       } else {
@@ -444,7 +250,7 @@ const void* MC_region_read(mc_mem_region_t region, void* target, const void* add
 
   // 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 MC_REGION_STORAGE_TYPE_PRIVATIZED:
+  case simgrid::mc::StorageType::Privatized:
     xbt_die("Storage type not supported");
   }
 }