X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/780bbdb2c378a9b0ac1f70606d17cba7ec1e3941..8173f52406580284c8ec5feab41784a8f4aed8ce:/src/mc/mc_process.cpp

diff --git a/src/mc/mc_process.cpp b/src/mc/mc_process.cpp
index 1ebc9a7fce..5372a63071 100644
--- a/src/mc/mc_process.cpp
+++ b/src/mc/mc_process.cpp
@@ -27,7 +27,7 @@
 
 #include "mc_process.h"
 #include "mc_object_info.h"
-#include "mc_address_space.h"
+#include "AddressSpace.hpp"
 #include "mc_unw.h"
 #include "mc_snapshot.h"
 #include "mc_ignore.h"
@@ -50,21 +50,17 @@ static mc_process_t MC_process_get_process(mc_process_t p) {
   return p;
 }
 
-static const s_mc_address_space_class_t mc_process_class = {
-  (mc_address_space_class_read_callback_t) &MC_process_read,
-  (mc_address_space_class_get_process_callback_t) MC_process_get_process
-};
-
-bool MC_is_process(mc_address_space_t p)
-{
-  return p->address_space_class == &mc_process_class;
 }
 
 // ***** mc_process
 
-void MC_process_init(mc_process_t process, pid_t pid, int sockfd)
+namespace simgrid {
+namespace mc {
+
+Process::Process(pid_t pid, int sockfd)
 {
-  process->address_space.address_space_class = &mc_process_class;
+  Process* process = this;
+
   process->process_flags = MC_PROCESS_NO_FLAG;
   process->socket = sockfd;
   process->pid = pid;
@@ -87,9 +83,9 @@ void MC_process_init(mc_process_t process, pid_t pid, int sockfd)
     xbt_die("No heap information in the target process");
   if(!std_heap_var->address)
     xbt_die("No constant address for this variable");
-  MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+  MC_process_read(process, simgrid::mc::AddressSpace::Normal,
     &process->heap_address, std_heap_var->address, sizeof(struct mdesc*),
-    MC_PROCESS_INDEX_DISABLED);
+    simgrid::mc::ProcessIndexDisabled);
 
   process->smx_process_infos = MC_smx_process_info_list_new();
   process->smx_old_process_infos = MC_smx_process_info_list_new();
@@ -106,9 +102,10 @@ void MC_process_init(mc_process_t process, pid_t pid, int sockfd)
   }
 }
 
-void MC_process_clear(mc_process_t process)
+Process::~Process()
 {
-  process->address_space.address_space_class = NULL;
+  Process* process = this;
+
   process->process_flags = MC_PROCESS_NO_FLAG;
   process->pid = 0;
 
@@ -153,6 +150,11 @@ void MC_process_clear(mc_process_t process)
   process->heap_info = NULL;
 }
 
+}
+}
+
+extern "C" {
+
 void MC_process_refresh_heap(mc_process_t process)
 {
   xbt_assert(mc_mode == MC_MODE_SERVER);
@@ -161,9 +163,9 @@ void MC_process_refresh_heap(mc_process_t process)
   if (!process->heap) {
     process->heap = (struct mdesc*) malloc(sizeof(struct mdesc));
   }
-  MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+  MC_process_read(process, simgrid::mc::AddressSpace::Normal,
     process->heap, process->heap_address, sizeof(struct mdesc),
-    MC_PROCESS_INDEX_DISABLED
+    simgrid::mc::ProcessIndexDisabled
     );
   process->cache_flags |= MC_PROCESS_CACHE_FLAG_HEAP;
 }
@@ -178,10 +180,10 @@ void MC_process_refresh_malloc_info(mc_process_t process)
   size_t malloc_info_bytesize =
     (process->heap->heaplimit + 1) * sizeof(malloc_info);
   process->heap_info = (malloc_info*) realloc(process->heap_info, malloc_info_bytesize);
-  MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE,
+  MC_process_read(process, simgrid::mc::AddressSpace::Normal,
     process->heap_info,
     process->heap->heapinfo, malloc_info_bytesize,
-    MC_PROCESS_INDEX_DISABLED);
+    simgrid::mc::ProcessIndexDisabled);
   process->cache_flags |= MC_PROCESS_CACHE_FLAG_MALLOC_INFO;
 }
 
@@ -417,8 +419,8 @@ void MC_process_read_variable(mc_process_t process, const char* name, void* targ
   if ((size_t) var->type->full_type->byte_size != size)
     xbt_die("Unexpected size for %s (expected %zi, was %zi)",
       name, size, (size_t) var->type->full_type->byte_size);
-  MC_process_read(process, MC_ADDRESS_SPACE_READ_FLAGS_NONE, target, var->address, size,
-    MC_PROCESS_INDEX_ANY);
+  MC_process_read(process, simgrid::mc::AddressSpace::Normal, target, var->address, size,
+    simgrid::mc::ProcessIndexAny);
 }
 
 char* MC_process_read_string(mc_process_t process, void* address)
@@ -518,44 +520,46 @@ static ssize_t pwrite_whole(int fd, const void *buf, size_t count, off_t offset)
   return real_count;
 }
 
-const void* MC_process_read(mc_process_t process, adress_space_read_flags_t flags,
-  void* local, const void* remote, size_t len,
-  int process_index)
+}
+
+namespace simgrid {
+namespace mc {
+
+const void *Process::read_bytes(void* buffer, std::size_t size,
+  std::uint64_t address, int process_index,
+  AddressSpace::ReadMode mode)
 {
-  if (process_index != MC_PROCESS_INDEX_DISABLED) {
-    mc_object_info_t info = MC_process_find_object_info_rw(process, remote);
+  if (process_index != simgrid::mc::ProcessIndexDisabled) {
+    mc_object_info_t info = MC_process_find_object_info_rw(this, (void*)address);
     // Segment overlap is not handled.
     if (MC_object_info_is_privatized(info)) {
       if (process_index < 0)
         xbt_die("Missing process index");
       // Address translation in the privaization segment:
-      size_t offset = (const char*) remote - info->start_rw;
-      remote = (const char*) remote - offset;
+      // TODO, fix me (broken)
+      size_t offset = address - (std::uint64_t)info->start_rw;
+      address = address - offset;
     }
   }
 
-  if (MC_process_is_self(process)) {
-    if (flags & MC_ADDRESS_SPACE_READ_FLAGS_LAZY)
-      return remote;
+  if (MC_process_is_self(this)) {
+    if (mode == simgrid::mc::AddressSpace::Lazy)
+      return (void*)address;
     else {
-      memcpy(local, remote, len);
-      return local;
+      memcpy(buffer, (void*)address, size);
+      return buffer;
     }
   } else {
-    if (pread_whole(process->memory_file, local, len, (off_t) remote) < 0)
-      xbt_die("Read from process %lli failed", (long long) process->pid);
-    return local;
+    if (pread_whole(this->memory_file, buffer, size, (off_t) address) < 0)
+      xbt_die("Read from process %lli failed", (long long) this->pid);
+    return buffer;
   }
 }
 
-const void* MC_process_read_simple(mc_process_t process,
-  void* local, const void* remote, size_t len)
-{
-  adress_space_read_flags_t flags = MC_ADDRESS_SPACE_READ_FLAGS_NONE;
-  int index = MC_PROCESS_INDEX_ANY;
-   MC_process_read(process, flags, local, remote, len, index);
-   return local;
 }
+}
+
+extern "C" {
 
 const void* MC_process_read_dynar_element(mc_process_t process,
   void* local, const void* remote_dynar, size_t i, size_t len)