[SMPI] Renamed smpi_*_data_exe as a first step for overhaul of the privatization

We will introduce a smpi_data_exe_copy variable soon and
we want more uniform names; having the (size|copy|start) at the end makes it much
simpler for us to grep for these variables.

diff --git a/src/smpi/include/private.h b/src/smpi/include/private.h
index 0b713be..f17eccb 100644 (file)
--- a/src/smpi/include/private.h
+++ b/src/smpi/include/private.h
@@ -82,8 +82,8 @@ XBT_PRIVATE void smpi_mpi_init();
 // utilities
 extern XBT_PRIVATE double smpi_cpu_threshold;
 extern XBT_PRIVATE double smpi_host_speed;
-extern XBT_PRIVATE char* smpi_start_data_exe; //start of the data+bss segment of the executable
-extern XBT_PRIVATE int smpi_size_data_exe; //size of the data+bss segment of the executable
+extern XBT_PRIVATE char* smpi_data_exe_start; // start of the data+bss segment of the executable
+extern XBT_PRIVATE int smpi_data_exe_size;    // size of the data+bss segment of the executable
 
 typedef enum { shmalloc_none, shmalloc_local, shmalloc_global } shared_malloc_type;
 extern XBT_PRIVATE shared_malloc_type smpi_cfg_shared_malloc; // Whether to activate shared malloc

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 1ccc8bf..866f17f 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -173,24 +173,23 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
   auto private_blocks = merge_private_blocks(src_private_blocks, dst_private_blocks);
   check_blocks(private_blocks, buff_size);
   void* tmpbuff=buff;
-  if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && (static_cast<char*>(buff) >= smpi_start_data_exe)
-      && (static_cast<char*>(buff) < smpi_start_data_exe + smpi_size_data_exe )
-    ){
-       XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !");
-
-       smpi_switch_data_segment(
-           static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->src_proc->userdata)->data))
-               ->index());
-       tmpbuff = static_cast<void*>(xbt_malloc(buff_size));
-       memcpy_private(tmpbuff, buff, private_blocks);
+  if ((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && (static_cast<char*>(buff) >= smpi_data_exe_start) &&
+      (static_cast<char*>(buff) < smpi_data_exe_start + smpi_data_exe_size)) {
+    XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !");
+
+    smpi_switch_data_segment(
+        static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->src_proc->userdata)->data))
+            ->index());
+    tmpbuff = static_cast<void*>(xbt_malloc(buff_size));
+    memcpy_private(tmpbuff, buff, private_blocks);
   }
 
-  if((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_start_data_exe)
-      && ((char*)comm->dst_buff < smpi_start_data_exe + smpi_size_data_exe )){
-       XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment");
-       smpi_switch_data_segment(
-           static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->dst_proc->userdata)->data))
-               ->index());
+  if ((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_data_exe_start) &&
+      ((char*)comm->dst_buff < smpi_data_exe_start + smpi_data_exe_size)) {
+    XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment");
+    smpi_switch_data_segment(
+        static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->dst_proc->userdata)->data))
+            ->index());
   }
   XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff,comm->dst_buff);
   memcpy_private(comm->dst_buff, tmpbuff, private_blocks);

diff --git a/src/smpi/internals/smpi_memory.cpp b/src/smpi/internals/smpi_memory.cpp
index fcc5cc2..a94b870 100644 (file)
--- a/src/smpi/internals/smpi_memory.cpp
+++ b/src/smpi/internals/smpi_memory.cpp
@@ -30,8 +30,8 @@
 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;
+char* smpi_data_exe_start = nullptr;
+int smpi_data_exe_size    = 0;
 int smpi_privatize_global_variables;
 
 static const int PROT_RWX = (PROT_READ | PROT_WRITE | PROT_EXEC);
@@ -52,15 +52,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;
     }
@@ -107,13 +107,13 @@ 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++){
-      asan_safe_memcpy(smpi_privatization_regions[i].address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
+      asan_safe_memcpy(smpi_privatization_regions[i].address, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
     }
   }
 
@@ -121,8 +121,8 @@ void smpi_really_switch_data_segment(int dest)
   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
@@ -140,9 +140,9 @@ 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
     smpi_privatize_global_variables=false;
     return;
   }
@@ -180,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");
 
@@ -194,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
-    asan_safe_memcpy(address, TOPAGE(smpi_start_data_exe), smpi_size_data_exe);
+    asan_safe_memcpy(address, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
 
     // store the address of the mapping for further switches
     smpi_privatization_regions[i].file_descriptor = file_descriptor;
@@ -208,11 +208,11 @@ 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);
   }

diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp
index b0c0af6..d490799 100644 (file)
--- a/src/smpi/mpi/smpi_request.cpp
+++ b/src/smpi/mpi/smpi_request.cpp
@@ -401,9 +401,8 @@ void Request::start()
       if (not(old_type_->flags() & DT_FLAG_DERIVED)) {
         oldbuf = buf_;
         if (not process->replaying() && oldbuf != nullptr && size_ != 0) {
-          if((smpi_privatize_global_variables != 0)
-            && (static_cast<char*>(buf_) >= smpi_start_data_exe)
-            && (static_cast<char*>(buf_) < smpi_start_data_exe + smpi_size_data_exe )){
+          if ((smpi_privatize_global_variables != 0) && (static_cast<char*>(buf_) >= smpi_data_exe_start) &&
+              (static_cast<char*>(buf_) < smpi_data_exe_start + smpi_data_exe_size)) {
             XBT_DEBUG("Privatization : We are sending from a zone inside global memory. Switch data segment ");
             smpi_switch_data_segment(src_);
           }
@@ -694,10 +693,10 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
         (datatype->flags() & DT_FLAG_DERIVED)) { // && (not smpi_is_shared(req->old_buf_))){
 
       if (not smpi_process()->replaying()) {
-        if( smpi_privatize_global_variables != 0 && (static_cast<char*>(req->old_buf_) >= smpi_start_data_exe)
-            && ((char*)req->old_buf_ < smpi_start_data_exe + smpi_size_data_exe )){
-            XBT_VERB("Privatization : We are unserializing to a zone in global memory  Switch data segment ");
-            smpi_switch_data_segment(smpi_process()->index());
+        if (smpi_privatize_global_variables != 0 && (static_cast<char*>(req->old_buf_) >= smpi_data_exe_start) &&
+            ((char*)req->old_buf_ < smpi_data_exe_start + smpi_data_exe_size)) {
+          XBT_VERB("Privatization : We are unserializing to a zone in global memory  Switch data segment ");
+          smpi_switch_data_segment(smpi_process()->index());
         }
       }