X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b348b0d4cff528bb4562222aa9f7874b8d30626f..e303bc683c874808621082e409ec13bcc1b17247:/src/smpi/smpi_global.cpp

diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp
index 0da7f66a81..25518210f0 100644
--- a/src/smpi/smpi_global.cpp
+++ b/src/smpi/smpi_global.cpp
@@ -3,10 +3,12 @@
 /* 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 <dlfcn.h>
+#include <fcntl.h>
 #include <spawn.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <dlfcn.h>
 
 #include "mc/mc.h"
 #include "private.h"
@@ -18,6 +20,8 @@
 #include "src/mc/mc_replay.h"
 #include "src/msg/msg_private.h"
 #include "src/simix/smx_private.h"
+#include "src/surf/surf_interface.hpp"
+#include "src/smpi/SmpiHost.hpp"
 #include "surf/surf.h"
 #include "xbt/replay.hpp"
 #include <xbt/config.hpp>
@@ -33,6 +37,10 @@
 #include <vector>
 #include <memory>
 
+#if HAVE_SENDFILE
+#include <sys/sendfile.h>
+#endif
+
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_kernel, smpi, "Logging specific to SMPI (kernel)");
 #include <boost/tokenizer.hpp>
 #include <boost/algorithm/string.hpp> /* trim_right / trim_left */
@@ -497,18 +505,17 @@ int smpi_main(const char* executable, int argc, char *argv[])
      * configuration tools */
     return 0;
   }
-  smpi_init_logs();
 
   TRACE_global_init(&argc, argv);
-  TRACE_add_start_function(TRACE_smpi_alloc);
-  TRACE_add_end_function(TRACE_smpi_release);
 
   SIMIX_global_init(&argc, argv);
   MSG_init(&argc,argv);
 
   SMPI_switch_data_segment = &smpi_switch_data_segment;
 
-  smpi_init_options();
+  simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
+    host.extension_set(new simgrid::smpi::SmpiHost(&host));
+  });
 
   // parse the platform file: get the host list
   SIMIX_create_environment(argv[1]);
@@ -519,24 +526,49 @@ int smpi_main(const char* executable, int argc, char *argv[])
   if (smpi_privatize_global_variables == SMPI_PRIVATIZE_DLOPEN) {
 
     std::string executable_copy = executable;
-    simix_global->default_function = [executable_copy](std::vector<std::string> args) {
-      return std::function<void()>([executable_copy, args] {
+
+    // Prepare the copy of the binary (open the file and get its size)
+    // (fdin will remain open for the whole process execution. That's a sort of leak but we can live with it)
+    int fdin = open(executable_copy.c_str(), O_RDONLY);
+    xbt_assert(fdin >= 0, "Cannot read from %s", executable_copy.c_str());
+    struct stat fdin_stat;
+    fstat(fdin, &fdin_stat);
+    off_t fdin_size = fdin_stat.st_size;
+
+    simix_global->default_function = [executable_copy, fdin, fdin_size](std::vector<std::string> args) {
+      return std::function<void()>([executable_copy, fdin, fdin_size, args] {
 
         // Copy the dynamic library:
         std::string target_executable = executable_copy
           + "_" + std::to_string(getpid())
           + "_" + std::to_string(rank++) + ".so";
-        // TODO, execute directly instead of relying on cp
-        const char* command1 [] = {
-          "cp", "--reflink=auto", "--", executable_copy.c_str(), target_executable.c_str(),
-          nullptr
-        };
-        const char* command2 [] = {
-          "cp", "--", executable_copy.c_str(), target_executable.c_str(),
-          nullptr
-        };
-        if (execute_command(command1) != 0 && execute_command(command2) != 0)
-          xbt_die("copy failed");
+
+        int fdout = open(target_executable.c_str(), O_WRONLY);
+        xbt_assert(fdout >= 0, "Cannot write into %s", target_executable.c_str());
+
+#if HAVE_SENDFILE
+        sendfile(fdout, fdin, NULL, fdin_size);
+#else
+        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", executable_copy.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_executable.c_str());
+              } else {
+                p += done;
+                todo -= done;
+              }
+            }
+          }
+        }
+#endif
+        close(fdout);
 
         // Load the copy and resolve the entry point:
         void* handle = dlopen(target_executable.c_str(), RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
@@ -547,7 +579,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
         if (!entry_point)
           xbt_die("Could not resolve entry point");
 
-          smpi_run_entry_point(entry_point, args);
+        smpi_run_entry_point(entry_point, args);
       });
     };
 
@@ -574,12 +606,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
 
   SIMIX_launch_application(argv[2]);
 
-  smpi_global_init();
-
-  smpi_check_options();
-
-  if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP)
-    smpi_initialize_global_memory_segments();
+  SMPI_init();
 
   /* Clean IO before the run */
   fflush(stdout);
@@ -619,15 +646,14 @@ int smpi_main(const char* executable, int argc, char *argv[])
   return ret;
 }
 
-// This function can be called from extern file, to initialize logs, options, and processes of smpi
-// without the need of smpirun
+// Called either directly from the user code, or from the code called by smpirun
 void SMPI_init(){
   smpi_init_logs();
   smpi_init_options();
   smpi_global_init();
   smpi_check_options();
-  if (TRACE_is_enabled() && TRACE_is_configured())
-    TRACE_smpi_alloc();
+  TRACE_smpi_alloc();
+  simgrid::surf::surfExitCallbacks.connect(TRACE_smpi_release);
   if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP)
     smpi_initialize_global_memory_segments();
 }