X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1340b2bc2a098a7e87fa45ff31591d32c864dc7a..370c7163c46a8966e3f13c28cc77d07b0dcc8fce:/src/smpi/internals/smpi_memory.cpp

diff --git a/src/smpi/internals/smpi_memory.cpp b/src/smpi/internals/smpi_memory.cpp
index e70482319a..49e4ab19b6 100644
--- a/src/smpi/internals/smpi_memory.cpp
+++ b/src/smpi/internals/smpi_memory.cpp
@@ -1,8 +1,9 @@
-/* Copyright (c) 2015-2018. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2015-2019. 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. */
 
+#include <algorithm>
 #include <cerrno>
 #include <climits>
 #include <cstdint>
@@ -23,27 +24,36 @@
 #include "src/xbt/memory_map.hpp"
 
 #include "private.hpp"
-#include "smpi_process.hpp"
+#include "src/smpi/include/smpi_actor.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_memory, smpi, "Memory layout support for SMPI");
 
 int smpi_loaded_page      = -1;
 char* smpi_data_exe_start = nullptr;
 int smpi_data_exe_size    = 0;
-int smpi_privatize_global_variables;
+SmpiPrivStrategies smpi_privatize_global_variables;
 static void* smpi_data_exe_copy;
 
+// Initialized by smpi_prepare_global_memory_segment().
+static std::vector<simgrid::xbt::VmMap> initial_vm_map;
+
 // We keep a copy of all the privatization regions: We can then delete everything easily by iterating over this
 // collection and nothing can be leaked. We could also iterate over all actors but we would have to be diligent when two
 // actors use the same privatization region (so, smart pointers would have to be used etc.)
 // Use a std::deque so that pointers remain valid after push_back().
 static std::deque<s_smpi_privatization_region_t> smpi_privatization_regions;
 
-static const int PROT_RWX = (PROT_READ | PROT_WRITE | PROT_EXEC);
-static const int PROT_RW  = (PROT_READ | PROT_WRITE );
-XBT_ATTRIB_UNUSED static const int PROT_RX  = (PROT_READ | PROT_EXEC );
+static constexpr int PROT_RWX = PROT_READ | PROT_WRITE | PROT_EXEC;
+static constexpr int PROT_RW  = PROT_READ | PROT_WRITE;
+
+/** Take a snapshot of the process' memory map.
+ */
+void smpi_prepare_global_memory_segment()
+{
+  initial_vm_map = simgrid::xbt::get_memory_map(getpid());
+}
 
-void smpi_get_executable_global_size()
+static void smpi_get_executable_global_size()
 {
   char buffer[PATH_MAX];
   char* full_name = realpath(xbt_binary_name, buffer);
@@ -59,13 +69,17 @@ void smpi_get_executable_global_size()
     if (i->pathname == full_name && (i->prot & PROT_RWX) == PROT_RW) {
       smpi_data_exe_start = (char*)i->start_addr;
       smpi_data_exe_size  = i->end_addr - i->start_addr;
-      ++i;
       /* Here we are making the assumption that a suitable empty region
          following the rw- area is the end of the data segment. It would
          be better to check with the size of the data segment. */
+      ++i;
       if (i != map.end() && i->pathname.empty() && (i->prot & PROT_RWX) == PROT_RW &&
           (char*)i->start_addr == smpi_data_exe_start + smpi_data_exe_size) {
-        smpi_data_exe_size = (char*)i->end_addr - smpi_data_exe_start;
+        // Only count this region if it was not already present in the initial map.
+        auto found = std::find_if(begin(initial_vm_map), end(initial_vm_map),
+                                  [&i](const simgrid::xbt::VmMap& m) { return m.start_addr == i->start_addr; });
+        if (found == end(initial_vm_map))
+          smpi_data_exe_size = (char*)i->end_addr - smpi_data_exe_start;
       }
       return;
     }
@@ -74,7 +88,7 @@ void smpi_get_executable_global_size()
 }
 #endif
 
-#if HAVE_SANITIZE_ADDRESS
+#if HAVE_SANITIZER_ADDRESS
 #include <sanitizer/asan_interface.h>
 static void* asan_safe_memcpy(void* dest, void* src, size_t n)
 {
@@ -99,7 +113,7 @@ static void* asan_safe_memcpy(void* dest, void* src, size_t n)
 /** Map a given SMPI privatization segment (make a SMPI process active) */
 void smpi_switch_data_segment(simgrid::s4u::ActorPtr actor)
 {
-  if (smpi_loaded_page == actor->getPid()) // no need to switch, we've already loaded the one we want
+  if (smpi_loaded_page == actor->get_pid()) // no need to switch, we've already loaded the one we want
     return;
 
   // So the job:
@@ -118,14 +132,13 @@ void smpi_really_switch_data_segment(simgrid::s4u::ActorPtr actor)
 
 #if HAVE_PRIVATIZATION
   // FIXME, cross-process support (mmap across process when necessary)
-  XBT_DEBUG("Switching data frame to the one of process %ld", actor->getPid());
-  simgrid::smpi::Process* process = smpi_process_remote(actor);
+  XBT_DEBUG("Switching data frame to the one of process %ld", actor->get_pid());
+  simgrid::smpi::ActorExt* process = smpi_process_remote(actor);
   int current                     = process->privatized_region()->file_descriptor;
-  void* tmp =
-      mmap(TOPAGE(smpi_data_exe_start), smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
+  void* tmp = mmap(TOPAGE(smpi_data_exe_start), smpi_data_exe_size, PROT_RW, MAP_FIXED | MAP_SHARED, current, 0);
   if (tmp != TOPAGE(smpi_data_exe_start))
     xbt_die("Couldn't map the new region (errno %d): %s", errno, strerror(errno));
-  smpi_loaded_page = actor->getPid();
+  smpi_loaded_page = actor->get_pid();
 #endif
 }
 
@@ -144,11 +157,13 @@ void smpi_backup_global_memory_segment()
 {
 #if HAVE_PRIVATIZATION
   smpi_get_executable_global_size();
+  initial_vm_map.clear();
+  initial_vm_map.shrink_to_fit();
 
   XBT_DEBUG("bss+data segment found : size %d starting at %p", smpi_data_exe_size, smpi_data_exe_start);
 
   if (smpi_data_exe_size == 0) { // no need to do anything as global variables don't exist
-    smpi_privatize_global_variables=false;
+    smpi_privatize_global_variables = SmpiPrivStrategies::NONE;
     return;
   }
 
@@ -157,9 +172,7 @@ void smpi_backup_global_memory_segment()
   // of the simulation and can be used to initialize a dynamically added, new process.
   asan_safe_memcpy(smpi_data_exe_copy, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
 #else /* ! HAVE_PRIVATIZATION */
-  smpi_privatize_global_variables = false;
   xbt_die("You are trying to use privatization on a system that does not support it. Don't.");
-  return;
 #endif
 }
 
@@ -171,10 +184,16 @@ smpi_privatization_region_t smpi_init_global_memory_segment_process()
   char path[24];
   int status;
 
-  do {
-    snprintf(path, sizeof(path), "/smpi-buffer-%06x", rand() % 0xffffffU);
+  constexpr unsigned VAL_MASK = 0xffffffU;
+  static unsigned prev_val    = VAL_MASK;
+  for (unsigned i = (prev_val + 1) & VAL_MASK; i != prev_val; i = (i + 1) & VAL_MASK) {
+    snprintf(path, sizeof(path), "/smpi-buffer-%06x", i);
     file_descriptor = shm_open(path, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
-  } while (file_descriptor == -1 && errno == EEXIST);
+    if (file_descriptor != -1 || errno != EEXIST) {
+      prev_val = i;
+      break;
+    }
+  }
   if (file_descriptor < 0) {
     if (errno == EMFILE) {
       xbt_die("Impossible to create temporary file for memory mapping: %s\n\
@@ -199,7 +218,7 @@ Ask the Internet about tutorials on how to increase the files limit such as: htt
     xbt_die("Impossible to set the size of the temporary file for memory mapping");
 
   /* Ask for a free region */
-  address = mmap(nullptr, smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
+  address = mmap(nullptr, smpi_data_exe_size, PROT_RW, MAP_SHARED, file_descriptor, 0);
   if (address == MAP_FAILED)
     xbt_die("Couldn't find a free region for memory mapping");