X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4b1773e713af47a4917278519ab87386d1de48c5..a4c8f1898670317d0fa33bf1b1a904ea922b78cc:/src/smpi/internals/smpi_memory.cpp

diff --git a/src/smpi/internals/smpi_memory.cpp b/src/smpi/internals/smpi_memory.cpp
index 1b415473cb..de20019985 100644
--- a/src/smpi/internals/smpi_memory.cpp
+++ b/src/smpi/internals/smpi_memory.cpp
@@ -1,4 +1,4 @@
-/* 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. */
@@ -57,8 +57,7 @@ static void smpi_get_executable_global_size()
 {
   char buffer[PATH_MAX];
   char* full_name = realpath(xbt_binary_name, buffer);
-  if (full_name == nullptr)
-    xbt_die("Could not resolve binary file name");
+  xbt_assert(full_name != nullptr, "Could not resolve real path of binary file '%s'", xbt_binary_name);
 
   std::vector<simgrid::xbt::VmMap> map = simgrid::xbt::get_memory_map(getpid());
   for (auto i = map.begin(); i != map.end() ; ++i) {
@@ -75,11 +74,12 @@ static void smpi_get_executable_global_size()
       ++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) {
-        // 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;
+        // Only count the portion of this region not present in the initial map.
+        auto found = std::find_if(initial_vm_map.begin(), initial_vm_map.end(), [&i](const simgrid::xbt::VmMap& m) {
+          return i->start_addr <= m.start_addr && m.start_addr < i->end_addr;
+        });
+        auto end_addr      = (found == initial_vm_map.end() ? i->end_addr : found->start_addr);
+        smpi_data_exe_size = (char*)end_addr - smpi_data_exe_start;
       }
       return;
     }
@@ -110,23 +110,16 @@ static void* asan_safe_memcpy(void* dest, void* src, size_t n)
 #define asan_safe_memcpy(dest, src, n) memcpy(dest, src, n)
 #endif
 
-/** 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->get_pid()) // no need to switch, we've already loaded the one we want
-    return;
-
-  // So the job:
-  smpi_really_switch_data_segment(actor);
-}
-
-/** Map a given SMPI privatization segment (make a SMPI process active)  even if SMPI thinks it is already active
+/** Map a given SMPI privatization segment (make a SMPI process active)
  *
  *  When doing a state restoration, the state of the restored variables  might not be consistent with the state of the
  *  virtual memory. In this case, we to change the data segment.
  */
-void smpi_really_switch_data_segment(simgrid::s4u::ActorPtr actor)
+void smpi_switch_data_segment(simgrid::s4u::ActorPtr actor)
 {
+  if (smpi_loaded_page == actor->get_pid()) // no need to switch, we've already loaded the one we want
+    return;
+
   if (smpi_data_exe_size == 0) // no need to switch
     return;
 
@@ -142,12 +135,6 @@ void smpi_really_switch_data_segment(simgrid::s4u::ActorPtr actor)
 #endif
 }
 
-int smpi_is_privatization_file(char* file)
-{
-  const std::string buffer_path("/dev/shm/my-buffer-");
-  return buffer_path.compare(0, std::string::npos, file, buffer_path.length()) == 0;
-}
-
 /**
  * @brief Makes a backup of the segment in memory that stores the global variables of a process.
  *        This backup is then used to initialize the global variables for every single
@@ -184,10 +171,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\
@@ -243,52 +236,39 @@ void smpi_destroy_global_memory_segments(){
 #endif
 }
 
+static std::vector<unsigned char> sendbuffer;
+static std::vector<unsigned char> recvbuffer;
 
-//allocate a single buffer for all sends, and an other of all reads, for each actor.
-//buffer size is growing if needed
-
-typedef std::tuple</*buffer adress*/ char*, /*buffer size*/ int> buffer_tuple;
-static std::map<aid_t, buffer_tuple> sendbuffer_map;
-static std::map<aid_t, buffer_tuple> recvbuffer_map;
-static void* smpi_get_tmp_buffer(int size, std::map<aid_t, buffer_tuple> buffer_map)
+//allocate a single buffer for all sends, growing it if needed
+unsigned char* smpi_get_tmp_sendbuffer(size_t size)
 {
-  // Because this kind of process maintain is own list of buffers and call
-  // `smpi_free_tmp_buffer(void* buf)` to free them
   if (not smpi_process()->replaying())
-    return xbt_malloc(size);
-
-  // check if the process is registered
-  aid_t id = simgrid::s4u::this_actor::get_pid();
-  if (not (buffer_map.find(id) == buffer_map.end()))
-  {
-    // This tuple represents a buffer and his size
-    buffer_tuple buffer_tuple(nullptr, 0);
-    buffer_map[id] = buffer_tuple;
-  }
-  if (std::get<1>(buffer_map[id]) < size){
-      std::get<0>(buffer_map[id]) = static_cast<char*>(xbt_realloc(std::get<0>(buffer_map[id]), size));
-      std::get<1>(buffer_map[id]) = size;
-  }
-  return std::get<0>(buffer_map[id]);
+    return new unsigned char[size];
+  // FIXME: a resize() may invalidate a previous pointer. Maybe we need to handle a queue of buffers with a reference
+  // counter. The same holds for smpi_get_tmp_recvbuffer.
+  if (sendbuffer.size() < size)
+    sendbuffer.resize(size);
+  return sendbuffer.data();
 }
 
-void* smpi_get_tmp_sendbuffer(int size)
+//allocate a single buffer for all recv
+unsigned char* smpi_get_tmp_recvbuffer(size_t size)
 {
-    return smpi_get_tmp_buffer(size, sendbuffer_map);
+  if (not smpi_process()->replaying())
+    return new unsigned char[size];
+  if (recvbuffer.size() < size)
+    recvbuffer.resize(size);
+  return recvbuffer.data();
 }
 
-void* smpi_get_tmp_recvbuffer(int size)
+void smpi_free_tmp_buffer(const unsigned char* buf)
 {
-    return smpi_get_tmp_buffer(size, recvbuffer_map);
-}
-
-void smpi_free_tmp_buffer(void* buf){
   if (not smpi_process()->replaying())
-    xbt_free(buf);
+    delete[] buf;
 }
 
-void smpi_free_replay_tmp_buffers(){
-  aid_t id = simgrid::s4u::this_actor::get_pid();
-  xbt_free(std::get<0>(recvbuffer_map[id]));
-  xbt_free(std::get<0>(sendbuffer_map[id]));
+void smpi_free_replay_tmp_buffers()
+{
+  std::vector<unsigned char>().swap(sendbuffer);
+  std::vector<unsigned char>().swap(recvbuffer);
 }