Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[SMPI] Added explanation of what smpi_data_exe_size==0 means
[simgrid.git] / src / smpi / internals / smpi_memory.cpp
index f96a486..7b02774 100644 (file)
 #include <sys/mman.h>
 #include <unistd.h>
 
+#include "src/internal_config.h"
 #include "src/xbt/memory_map.hpp"
 
-#include "private.h"
 #include "private.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_memory, smpi, "Memory layout support for SMPI");
 
-int smpi_loaded_page = -1;
-char* smpi_start_data_exe = nullptr;
-int smpi_size_data_exe = 0;
+int smpi_loaded_page      = -1;
+char* smpi_data_exe_start = nullptr;
+int smpi_data_exe_size    = 0;
 int smpi_privatize_global_variables;
+static char* smpi_data_exe_copy;
+smpi_privatization_region_t smpi_privatization_regions;
+// static std::set smpi_privatization_regions;
 
 static const int PROT_RWX = (PROT_READ | PROT_WRITE | PROT_EXEC);
 static const int PROT_RW  = (PROT_READ | PROT_WRITE );
@@ -51,15 +54,15 @@ void smpi_get_executable_global_size()
 
     // File backed RW entry:
     if (i->pathname == full_name && (i->prot & PROT_RWX) == PROT_RW) {
-      smpi_start_data_exe = (char*) i->start_addr;
-      smpi_size_data_exe = i->end_addr - i->start_addr;
+      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. */
-      if (i != map.end() && i->pathname.empty() && (i->prot & PROT_RWX) == PROT_RW
-          && (char*)i->start_addr ==  smpi_start_data_exe + smpi_size_data_exe) {
-        smpi_size_data_exe = (char*)i->end_addr - smpi_start_data_exe;
+      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;
       }
       return;
     }
@@ -68,12 +71,9 @@ void smpi_get_executable_global_size()
 }
 #endif
 
-#if !defined(__has_feature)
-#define __has_feature(x) 0
-#endif
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#if HAVE_SANITIZE_ADDRESS
 #include <sanitizer/asan_interface.h>
-void* safe_memcpy(void* dest, void* src, size_t n)
+static void* asan_safe_memcpy(void* dest, void* src, size_t n)
 {
   char* psrc  = static_cast<char*>(src);
   char* pdest = static_cast<char*>(dest);
@@ -90,7 +90,7 @@ void* safe_memcpy(void* dest, void* src, size_t n)
   return dest;
 }
 #else
-#define safe_memcpy(dest, src, n) memcpy(dest, src, n)
+#define asan_safe_memcpy(dest, src, n) memcpy(dest, src, n)
 #endif
 
 /** Map a given SMPI privatization segment (make a SMPI process active) */
@@ -109,22 +109,20 @@ void smpi_switch_data_segment(int dest) {
  */
 void smpi_really_switch_data_segment(int dest)
 {
-  if(smpi_size_data_exe == 0)//no need to switch
+  if (smpi_data_exe_size == 0) // no need to switch
     return;
 
 #if HAVE_PRIVATIZATION
-  if(smpi_loaded_page==-1){//initial switch, do the copy from the real page here
-    for (int i=0; i< smpi_process_count(); i++){
-      safe_memcpy(smpi_privatization_regions[i].address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
-    }
+  if (smpi_loaded_page == -1) { // initial switch, do the copy from the real page here
+    asan_safe_memcpy(smpi_data_exe_copy, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
   }
 
   // FIXME, cross-process support (mmap across process when necessary)
   int current = smpi_privatization_regions[dest].file_descriptor;
   XBT_DEBUG("Switching data frame to the one of process %d", dest);
   void* tmp =
-      mmap(TOPAGE(smpi_start_data_exe), smpi_size_data_exe, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
-  if (tmp != TOPAGE(smpi_start_data_exe))
+      mmap(TOPAGE(smpi_data_exe_start), smpi_data_exe_size, PROT_READ | PROT_WRITE, 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 = dest;
 #endif
@@ -138,19 +136,19 @@ int smpi_is_privatization_file(char* file)
 
 void smpi_initialize_global_memory_segments()
 {
-
 #if HAVE_PRIVATIZATION
   smpi_get_executable_global_size();
 
-  XBT_DEBUG ("bss+data segment found : size %d starting at %p", smpi_size_data_exe, smpi_start_data_exe );
+  XBT_DEBUG("bss+data segment found : size %d starting at %p", smpi_data_exe_size, smpi_data_exe_start);
 
-  if (smpi_size_data_exe == 0){//no need to switch
+  if (smpi_data_exe_size == 0) { // no need to switch as global variables don't exist
     smpi_privatize_global_variables=false;
     return;
   }
 
-  smpi_privatization_regions = static_cast<smpi_privatization_region_t>(
-      xbt_malloc(smpi_process_count() * sizeof(struct s_smpi_privatization_region)));
+  smpi_data_exe_copy = (char*)malloc(smpi_data_exe_size);
+  asan_safe_memcpy(smpi_data_exe_copy, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
+  smpi_privatization_regions = new s_smpi_privatization_region_t[smpi_process_count()];
 
   for (int i=0; i< smpi_process_count(); i++){
     // create SIMIX_process_count() mappings of this size with the same data inside
@@ -182,12 +180,12 @@ Ask the Internet about tutorials on how to increase the files limit such as: htt
       xbt_die("Impossible to create temporary file for memory mapping: %s", strerror(errno));
     }
 
-    status = ftruncate(file_descriptor, smpi_size_data_exe);
+    status = ftruncate(file_descriptor, smpi_data_exe_size);
     if (status)
       xbt_die("Impossible to set the size of the temporary file for memory mapping");
 
     /* Ask for a free region */
-    address = mmap(nullptr, smpi_size_data_exe, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
+    address = mmap(nullptr, smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
     if (address == MAP_FAILED)
       xbt_die("Couldn't find a free region for memory mapping");
 
@@ -196,7 +194,7 @@ Ask the Internet about tutorials on how to increase the files limit such as: htt
       xbt_die("Impossible to unlink temporary file for memory mapping");
 
     // initialize the values
-    safe_memcpy(address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
+    asan_safe_memcpy(address, smpi_data_exe_copy, smpi_data_exe_size);
 
     // store the address of the mapping for further switches
     smpi_privatization_regions[i].file_descriptor = file_descriptor;
@@ -210,15 +208,15 @@ Ask the Internet about tutorials on how to increase the files limit such as: htt
 }
 
 void smpi_destroy_global_memory_segments(){
-  if (smpi_size_data_exe == 0)//no need to switch
+  if (smpi_data_exe_size == 0) // no need to switch
     return;
 #if HAVE_PRIVATIZATION
   for (int i=0; i< smpi_process_count(); i++) {
-    if (munmap(smpi_privatization_regions[i].address, smpi_size_data_exe) < 0)
+    if (munmap(smpi_privatization_regions[i].address, smpi_data_exe_size) < 0)
       XBT_WARN("Unmapping of fd %d failed: %s", smpi_privatization_regions[i].file_descriptor, strerror(errno));
     close(smpi_privatization_regions[i].file_descriptor);
   }
-  xbt_free(smpi_privatization_regions);
+  delete[] smpi_privatization_regions;
 #endif
 }