portability cheating: avoid the configurations that are known to be broken

[simgrid.git] / src / smpi / smpi_global.cpp

diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp
index 3d9c926..3770ba2 100644 (file)
--- a/src/smpi/smpi_global.cpp
+++ b/src/smpi/smpi_global.cpp
@@ -95,7 +95,10 @@ int smpi_process_count()
 
 simgrid::smpi::Process* smpi_process()
 {
-  simgrid::MsgActorExt* msgExt = static_cast<simgrid::MsgActorExt*>(SIMIX_process_self()->data);
+  smx_actor_t me = SIMIX_process_self();
+  if (me == nullptr) // This happens sometimes (eg, when linking against NS3 because it pulls openMPI...)
+    return nullptr;
+  simgrid::MsgActorExt* msgExt = static_cast<simgrid::MsgActorExt*>(me->data);
   return static_cast<simgrid::smpi::Process*>(msgExt->data);
 }
 
@@ -116,6 +119,14 @@ int smpi_process_index(){
   return smpi_process()->index();
 }
 
+void * smpi_process_get_user_data(){
+  return smpi_process()->get_user_data();
+}
+
+void smpi_process_set_user_data(void *data){
+  return smpi_process()->set_user_data(data);
+}
+
 
 int smpi_global_size()
 {
@@ -465,6 +476,13 @@ static void smpi_init_options(){
     else
       xbt_die("Invalid value for smpi/privatization: '%s'", smpi_privatize_option);
 
+#if defined(__FreeBSD__)
+    if (smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) {
+      XBT_INFO("Mixing mmap privatization is broken on FreeBSD, switching to dlopen privatization instead.");
+      smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN;
+    }
+#endif
+
     if (smpi_cpu_threshold < 0)
       smpi_cpu_threshold = DBL_MAX;
 
@@ -554,30 +572,31 @@ int smpi_main(const char* executable, int argc, char *argv[])
 
     std::string executable_copy = executable;
 
-    // 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());
+    // Prepare the copy of the binary (get its size)
     struct stat fdin_stat;
-    fstat(fdin, &fdin_stat);
+    stat(executable_copy.c_str(), &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] {
+    simix_global->default_function = [executable_copy, fdin_size](std::vector<std::string> args) {
+      return std::function<void()>([executable_copy, fdin_size, args] {
 
         // Copy the dynamic library:
         std::string target_executable = executable_copy
           + "_" + std::to_string(getpid())
           + "_" + std::to_string(rank++) + ".so";
 
+        int fdin = open(executable_copy.c_str(), O_RDONLY);
+        xbt_assert(fdin >= 0, "Cannot read from %s", executable_copy.c_str());
         int fdout = open(target_executable.c_str(), O_CREAT | O_RDWR, S_IRWXU);
         xbt_assert(fdout >= 0, "Cannot write into %s", target_executable.c_str());
 
 #if HAVE_SENDFILE
-        off_t offset = 0;
-        sendfile(fdout, fdin, &offset, fdin_size);
+        ssize_t sent_size = sendfile(fdout, fdin, NULL, fdin_size);
+        xbt_assert(sent_size == fdin_size,
+                   "Error while copying %s: only %zd bytes copied instead of %ld (errno: %d -- %s)",
+                   target_executable.c_str(), sent_size, fdin_size, errno, strerror(errno));
 #else
-        XBT_WARN("Copy %d bytes into %s", static_cast<int>(fdin_size), target_executable.c_str());
+        XBT_VERB("Copy %d bytes into %s", static_cast<int>(fdin_size), target_executable.c_str());
         const int bufsize = 1024 * 1024 * 4;
         char buf[bufsize];
         while (int got = read(fdin, buf, bufsize)) {
@@ -597,13 +616,15 @@ int smpi_main(const char* executable, int argc, char *argv[])
           }
         }
 #endif
+        close(fdin);
         close(fdout);
 
         // Load the copy and resolve the entry point:
         void* handle = dlopen(target_executable.c_str(), RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
-        unlink(target_executable.c_str());
+        if (xbt_cfg_get_boolean("smpi/keep-temps") == false)
+          unlink(target_executable.c_str());
         if (handle == nullptr)
-          xbt_die(bprintf("dlopen failed: %s (errno: %d -- %s)", dlerror(), errno, strerror(errno)));
+          xbt_die("dlopen failed: %s (errno: %d -- %s)", dlerror(), errno, strerror(errno));
         smpi_entry_point_type entry_point = smpi_resolve_function(handle);
         if (!entry_point)
           xbt_die("Could not resolve entry point");
@@ -618,7 +639,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
     // Load the dynamic library and resolve the entry point:
     void* handle = dlopen(executable, RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
     if (handle == nullptr)
-      xbt_die("dlopen failed for %s", executable);
+      xbt_die("dlopen failed for %s: %s (errno: %d -- %s)", executable, dlerror(), errno, strerror(errno));
     smpi_entry_point_type entry_point = smpi_resolve_function(handle);
     if (!entry_point)
       xbt_die("main not found in %s", executable);