disable dlopen when under sanitizers

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

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 091dcb2..0c1a3b7 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -6,6 +6,7 @@
 #include "SmpiHost.hpp"
 #include "mc/mc.h"
 #include "private.hpp"
+#include "simgrid/s4u/Engine.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "simgrid/s4u/Mailbox.hpp"
 #include "simgrid/s4u/forward.hpp"
@@ -57,6 +58,7 @@ std::unordered_map<std::string, double> location2speedup;
 
 static std::map</*process_id*/ ActorPtr, simgrid::smpi::Process*> process_data;
 int process_count = 0;
+static int smpi_exit_status = 0;
 int smpi_universe_size = 0;
 extern double smpi_total_benched_time;
 xbt_os_timer_t global_timer;
@@ -344,18 +346,6 @@ void smpi_global_destroy()
   smpi_bench_destroy();
   smpi_shared_destroy();
   smpi_deployment_cleanup_instances();
-  for (auto& pair : process_data) {
-    auto& process = pair.second;
-    if (process->comm_self() != MPI_COMM_NULL) {
-      simgrid::smpi::Comm::destroy(process->comm_self());
-    }
-    if (process->comm_intra() != MPI_COMM_NULL) {
-      simgrid::smpi::Comm::destroy(process->comm_intra());
-    }
-    xbt_os_timer_free(process->timer());
-    xbt_mutex_destroy(process->mailboxes_mutex());
-  }
-  process_data.clear();
 
   if (simgrid::smpi::Colls::smpi_coll_cleanup_callback != nullptr)
     simgrid::smpi::Colls::smpi_coll_cleanup_callback();
@@ -393,11 +383,18 @@ static void smpi_init_options(){
 
 #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.");
+      XBT_INFO("mmap privatization is broken on FreeBSD, switching to dlopen privatization instead.");
       smpi_privatize_global_variables = SMPI_PRIVATIZE_DLOPEN;
     }
 #endif
 
+#if defined(HAVE_SANITIZER)
+    if (smpi_privatize_global_variables == SMPI_PRIVATIZE_DLOPEN) {
+      XBT_INFO("Sanitizers don't like dlopen, switching to mmap privatization instead.");
+      smpi_privatize_global_variables = SMPI_PRIVATIZE_MMAP;
+    }
+#endif
+
     if (smpi_cpu_threshold < 0)
       smpi_cpu_threshold = DBL_MAX;
 
@@ -430,7 +427,8 @@ static int smpi_run_entry_point(smpi_entry_point_type entry_point, std::vector<s
   int res = entry_point(argc, argv.get());
   if (res != 0){
     XBT_WARN("SMPI process did not return 0. Return value : %d", res);
-    smpi_process()->set_return_value(res);
+    if (smpi_exit_status == 0)
+      smpi_exit_status = res;
   }
   return 0;
 }
@@ -503,7 +501,8 @@ int smpi_main(const char* executable, int argc, char *argv[])
           + "_" + 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());
+        xbt_assert(fdin >= 0, "Cannot read from %s. Please make sure that the file exists and is executable.",
+                   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());
 
@@ -555,7 +554,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
   else {
 
     // Load the dynamic library and resolve the entry point:
-    void* handle = dlopen(executable, RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
+    void* handle = dlopen(executable, RTLD_LAZY | RTLD_LOCAL);
     if (handle == nullptr)
       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);
@@ -575,7 +574,7 @@ int smpi_main(const char* executable, int argc, char *argv[])
   SMPI_init();
   SIMIX_launch_application(argv[2]);
   SMPI_app_instance_register(smpi_default_instance_name, nullptr,
-                               SIMIX_process_count()); // This call has a side effect on process_count...
+                             process_data.size()); // This call has a side effect on process_count...
   MPI_COMM_WORLD = *smpi_deployment_comm_world(smpi_default_instance_name);
   smpi_universe_size = process_count;
 
@@ -603,30 +602,25 @@ int smpi_main(const char* executable, int argc, char *argv[])
       "You may want to use sampling functions or trace replay to reduce this.");
     }
   }
-  int ret   = 0;
-  for (auto& pair : process_data) {
-    auto& smpi_process = pair.second;
-    if (smpi_process->return_value() != 0) {
-      ret = smpi_process->return_value(); // return first non 0 value
-      break;
-    }
-  }
   smpi_global_destroy();
 
   TRACE_end();
 
-  return ret;
+  return smpi_exit_status;
 }
 
 // Called either directly from the user code, or from the code called by smpirun
 void SMPI_init(){
   simgrid::s4u::Actor::onCreation.connect([](simgrid::s4u::ActorPtr actor) {
-    process_data.insert({actor, new simgrid::smpi::Process(actor, nullptr)});
+    if (not actor->isDaemon()) {
+      process_data.insert({actor, new simgrid::smpi::Process(actor, nullptr)});
+    }
   });
   simgrid::s4u::Actor::onDestruction.connect([](simgrid::s4u::ActorPtr actor) {
-    if (process_data.find(actor) != process_data.end()) {
-      delete process_data.at(actor);
-      process_data.erase(actor);
+    auto it = process_data.find(actor);
+    if (it != process_data.end()) {
+      delete it->second;
+      process_data.erase(it);
     }
   });
 
@@ -634,7 +628,7 @@ void SMPI_init(){
   smpi_global_init();
   smpi_check_options();
   TRACE_smpi_alloc();
-  simgrid::surf::surfExitCallbacks.connect(TRACE_smpi_release);
+  simgrid::s4u::onSimulationEnd.connect(TRACE_smpi_release);
   if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP)
     smpi_backup_global_memory_segment();
 }