X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b8df87e176f27b25534f27d7e240defa32ca35bc..721ce3a9bda40b178bb97e61f831056bb050ac51:/src/smpi/internals/smpi_global.cpp

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 92e4e750d0..c8253eecab 100644
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -37,7 +37,7 @@
 # define HAVE_WORKING_MMAP 1
 #endif
 
-#if HAVE_SENDFILE
+#if SG_HAVE_SENDFILE
 #include <sys/sendfile.h>
 #endif
 
@@ -59,7 +59,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_kernel, smpi, "Logging specific to SMPI (ke
  * See https://www.akkadia.org/drepper/dsohowto.pdf
  * and https://lists.freebsd.org/pipermail/freebsd-current/2016-March/060284.html
 */
-#if !defined(RTLD_DEEPBIND) || HAVE_SANITIZER_ADDRESS || HAVE_SANITIZER_THREAD
+#if !RTLD_DEEPBIND || HAVE_SANITIZER_ADDRESS || HAVE_SANITIZER_THREAD
 #define WANT_RTLD_DEEPBIND 0
 #else
 #define WANT_RTLD_DEEPBIND RTLD_DEEPBIND
@@ -168,7 +168,7 @@ static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks,
 void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size)
 {
   simgrid::kernel::activity::CommImplPtr comm =
-      boost::dynamic_pointer_cast<simgrid::kernel::activity::CommImpl>(synchro);
+      boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(synchro);
   int src_shared                        = 0;
   int dst_shared                        = 0;
   size_t src_offset                     = 0;
@@ -184,8 +184,8 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
     src_private_blocks.clear();
     src_private_blocks.push_back(std::make_pair(0, buff_size));
   }
-  if((dst_shared=smpi_is_shared((char*)comm->dst_buff, dst_private_blocks, &dst_offset))) {
-    XBT_DEBUG("Receiver %p is shared. Let's ignore it.", (char*)comm->dst_buff);
+  if ((dst_shared = smpi_is_shared((char*)comm->dst_buff_, dst_private_blocks, &dst_offset))) {
+    XBT_DEBUG("Receiver %p is shared. Let's ignore it.", (char*)comm->dst_buff_);
     dst_private_blocks = shift_and_frame_private_blocks(dst_private_blocks, dst_offset, buff_size);
   }
   else {
@@ -201,18 +201,19 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
       (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(comm->src_proc->iface());
+    smpi_switch_data_segment(comm->src_actor_->iface());
     tmpbuff = static_cast<void*>(xbt_malloc(buff_size));
     memcpy_private(tmpbuff, buff, private_blocks);
   }
 
-  if ((smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) && ((char*)comm->dst_buff >= smpi_data_exe_start) &&
-      ((char*)comm->dst_buff < smpi_data_exe_start + smpi_data_exe_size)) {
+  if ((smpi_privatize_global_variables == SmpiPrivStrategies::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(comm->dst_proc->iface());
+    smpi_switch_data_segment(comm->dst_actor_->iface());
   }
-  XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff,comm->dst_buff);
-  memcpy_private(comm->dst_buff, tmpbuff, private_blocks);
+  XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff, comm->dst_buff_);
+  memcpy_private(comm->dst_buff_, tmpbuff, private_blocks);
 
   if (comm->detached) {
     // if this is a detached send, the source buffer was duplicated by SMPI
@@ -220,7 +221,7 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
     xbt_free(buff);
     //It seems that the request is used after the call there this should be free somewhere else but where???
     //xbt_free(comm->comm.src_data);// inside SMPI the request is kept inside the user data and should be free
-    comm->src_buff = nullptr;
+    comm->src_buff_ = nullptr;
   }
   if (tmpbuff != buff)
     xbt_free(tmpbuff);
@@ -323,17 +324,15 @@ void smpi_global_init()
 
         int event_code   = PAPI_NULL;
         char* event_name = const_cast<char*>((*events_it).c_str());
-        if (PAPI_event_name_to_code(event_name, &event_code) == PAPI_OK) {
-          if (PAPI_add_event(event_set, event_code) != PAPI_OK) {
-            XBT_ERROR("Could not add PAPI event '%s'. Skipping.", event_name);
-            continue;
-          } else {
-            XBT_DEBUG("Successfully added PAPI event '%s' to the event set.", event_name);
-          }
-        } else {
+        if (PAPI_event_name_to_code(event_name, &event_code) != PAPI_OK) {
           XBT_CRITICAL("Could not find PAPI event '%s'. Skipping.", event_name);
           continue;
         }
+        if (PAPI_add_event(event_set, event_code) != PAPI_OK) {
+          XBT_ERROR("Could not add PAPI event '%s'. Skipping.", event_name);
+          continue;
+        }
+        XBT_DEBUG("Successfully added PAPI event '%s' to the event set.", event_name);
 
         counters2values.push_back(
             // We cannot just pass *events_it, as this is of type const basic_string
@@ -489,7 +488,7 @@ static smpi_entry_point_type smpi_resolve_function(void* handle)
   return smpi_entry_point_type();
 }
 
-static void smpi_copy_file(std::string src, std::string target, off_t fdin_size)
+static void smpi_copy_file(const std::string& src, const std::string& target, off_t fdin_size)
 {
   int fdin = open(src.c_str(), O_RDONLY);
   xbt_assert(fdin >= 0, "Cannot read from %s. Please make sure that the file exists and is executable.", src.c_str());
@@ -497,31 +496,32 @@ static void smpi_copy_file(std::string src, std::string target, off_t fdin_size)
   xbt_assert(fdout >= 0, "Cannot write into %s", target.c_str());
 
   XBT_DEBUG("Copy %" PRIdMAX " bytes into %s", static_cast<intmax_t>(fdin_size), target.c_str());
-  bool slow_copy = true;
-#if HAVE_SENDFILE
+#if SG_HAVE_SENDFILE
   ssize_t sent_size = sendfile(fdout, fdin, NULL, fdin_size);
-  if (sent_size == fdin_size)
-    slow_copy = false;
-  else if (sent_size != -1 || errno != ENOSYS)
+  if (sent_size == fdin_size) {
+    close(fdin);
+    close(fdout);
+    return;
+  } else if (sent_size != -1 || errno != ENOSYS) {
     xbt_die("Error while copying %s: only %zd bytes copied instead of %" PRIdMAX " (errno: %d -- %s)", target.c_str(),
             sent_size, static_cast<intmax_t>(fdin_size), errno, strerror(errno));
+  }
 #endif
-  if (slow_copy) {
-    const int bufsize = 1024 * 1024 * 4;
-    char buf[bufsize];
-    while (int got = read(fdin, buf, bufsize)) {
-      if (got == -1) {
-        xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
-      } else {
-        char* p  = buf;
-        int todo = got;
-        while (int done = write(fdout, p, todo)) {
-          if (done == -1) {
-            xbt_assert(errno == EINTR, "Cannot write into %s", target.c_str());
-          } else {
-            p += done;
-            todo -= done;
-          }
+  // If this point is reached, sendfile() actually is not available.  Copy file by hand.
+  const int bufsize = 1024 * 1024 * 4;
+  char buf[bufsize];
+  while (int got = read(fdin, buf, bufsize)) {
+    if (got == -1) {
+      xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
+    } else {
+      char* p  = buf;
+      int todo = got;
+      while (int done = write(fdout, p, todo)) {
+        if (done == -1) {
+          xbt_assert(errno == EINTR, "Cannot write into %s", target.c_str());
+        } else {
+          p += done;
+          todo -= done;
         }
       }
     }
@@ -550,7 +550,6 @@ static void smpi_init_privatization_dlopen(const std::string& executable)
   struct stat fdin_stat;
   stat(executable.c_str(), &fdin_stat);
   off_t fdin_size         = fdin_stat.st_size;
-  static std::size_t rank = 0;
 
   std::string libnames = simgrid::config::get_value<std::string>("smpi/privatize-libs");
   if (not libnames.empty()) {
@@ -580,6 +579,7 @@ static void smpi_init_privatization_dlopen(const std::string& executable)
 
   simix_global->default_function = [executable, fdin_size](std::vector<std::string> args) {
     return std::function<void()>([executable, fdin_size, args] {
+      static std::size_t rank = 0;
       // Copy the dynamic library:
       std::string target_executable =
           executable + "_" + std::to_string(getpid()) + "_" + std::to_string(rank) + ".so";