[mc] Move heap_ignore to Process

[simgrid.git] / src / mc / Process.cpp

diff --git a/src/mc/Process.cpp b/src/mc/Process.cpp
index 125c722..665e29e 100644 (file)
--- a/src/mc/Process.cpp
+++ b/src/mc/Process.cpp
@@ -32,7 +32,6 @@
 #include "mc_snapshot.h"
 #include "mc_ignore.h"
 #include "mc_smx.h"
-#include "mc_server.h"
 
 #include "src/mc/Process.hpp"
 #include "src/mc/AddressSpace.hpp"
@@ -213,13 +212,12 @@ Process::Process(pid_t pid, int sockfd) : AddressSpace(this)
   process->socket_ = sockfd;
   process->pid_ = pid;
   process->running_ = true;
-  process->status_ = 0;
-  process->memory_map_ = get_memory_map(pid);
+  process->memory_map_ = simgrid::xbt::get_memory_map(pid);
   process->cache_flags = MC_PROCESS_CACHE_FLAG_NONE;
-  process->heap_info = NULL;
   process->init_memory_map_info();
   process->clear_refs_fd_ = -1;
   process->pagemap_fd_ = -1;
+  process->privatized_ = false;
 
   int fd = open_vm(process->pid_, O_RDWR);
   if (fd<0)
@@ -274,9 +272,6 @@ Process::~Process()
 
   process->cache_flags = MC_PROCESS_CACHE_FLAG_NONE;
 
-  free(process->heap_info);
-  process->heap_info = NULL;
-
   if (process->clear_refs_fd_ >= 0)
     close(process->clear_refs_fd_);
   if (process->pagemap_fd_ >= 0)
@@ -310,10 +305,10 @@ void Process::refresh_malloc_info()
   if (!(this->cache_flags & MC_PROCESS_CACHE_FLAG_HEAP))
     this->refresh_heap();
   // Refresh process->heapinfo:
-  size_t malloc_info_bytesize =
-    (this->heap->heaplimit + 1) * sizeof(malloc_info);
-  this->heap_info = (malloc_info*) realloc(this->heap_info, malloc_info_bytesize);
-  this->read_bytes(this->heap_info, malloc_info_bytesize,
+  size_t count = this->heap->heaplimit + 1;
+  if (this->heap_info.size() < count)
+    this->heap_info.resize(count);
+  this->read_bytes(this->heap_info.data(), count * sizeof(malloc_info),
     remote(this->heap->heapinfo), simgrid::mc::ProcessIndexDisabled);
   this->cache_flags |= MC_PROCESS_CACHE_FLAG_MALLOC_INFO;
 }
@@ -333,14 +328,14 @@ void Process::init_memory_map_info()
   if(regcomp(&res.so_re, SO_RE, 0) || regcomp(&res.version_re, VERSION_RE, 0))
     xbt_die(".so regexp did not compile");
 
-  std::vector<simgrid::mc::VmMap> const& maps = this->memory_map_;
+  std::vector<simgrid::xbt::VmMap> const& maps = this->memory_map_;
 
   const char* current_name = NULL;
 
   this->object_infos.resize(0);
 
   for (size_t i=0; i < maps.size(); i++) {
-    simgrid::mc::VmMap const& reg = maps[i];
+    simgrid::xbt::VmMap const& reg = maps[i];
     const char* pathname = maps[i].pathname.c_str();
 
     // Nothing to do
@@ -518,7 +513,7 @@ const void *Process::read_bytes(void* buffer, std::size_t size,
       this->find_object_info_rw((void*)address.address());
     // Segment overlap is not handled.
 #ifdef HAVE_SMPI
-    if (info.get() && info.get()->privatized()) {
+    if (info.get() && this->privatized(*info)) {
       if (process_index < 0)
         xbt_die("Missing process index");
       if (process_index >= (int) MC_smpi_process_count())
@@ -641,5 +636,67 @@ void Process::read_pagemap(uint64_t* pagemap, size_t page_start, size_t page_cou
     xbt_die("Could not read pagemap");
 }
 
+void Process::ignore_heap(IgnoredHeapRegion const& region)
+{
+  if (ignored_heap_.empty()) {
+    ignored_heap_.push_back(std::move(region));
+    return;
+  }
+
+  typedef std::vector<IgnoredHeapRegion>::size_type size_type;
+
+  size_type start = 0;
+  size_type end = ignored_heap_.size() - 1;
+
+  // Binary search the position of insertion:
+  size_type cursor;
+  while (start <= end) {
+    cursor = start + (end - start) / 2;
+    auto& current_region = ignored_heap_[cursor];
+    if (current_region.address == region.address)
+      return;
+    else if (current_region.address < region.address)
+      start = cursor + 1;
+    else if (cursor != 0)
+      end = cursor - 1;
+    // Avoid underflow:
+    else
+      break;
+  }
+
+  // Insert it mc_heap_ignore_region_t:
+  if (ignored_heap_[cursor].address < region.address)
+    ++cursor;
+  ignored_heap_.insert( ignored_heap_.begin() + cursor, region);
+}
+
+void Process::unignore_heap(void *address, size_t size)
+{
+  typedef std::vector<IgnoredHeapRegion>::size_type size_type;
+
+  size_type start = 0;
+  size_type end = ignored_heap_.size() - 1;
+
+  // Binary search:
+  size_type cursor;
+  while (start <= end) {
+    cursor = (start + end) / 2;
+    auto& region = ignored_heap_[cursor];
+    if (region.address == address) {
+      ignored_heap_.erase(ignored_heap_.begin() + cursor);
+      return;
+    } else if (region.address < address)
+      start = cursor + 1;
+    else if ((char *) region.address <= ((char *) address + size)) {
+      ignored_heap_.erase(ignored_heap_.begin() + cursor);
+      return;
+    } else if (cursor != 0)
+      end = cursor - 1;
+    // Avoid underflow:
+    else
+      break;
+  }
+}
+
 }
 }