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

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 4a7ef4f2bf..769c00900d 100644
--- 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,17 +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());
-    }
-    delete process;
-  }
-  process_data.clear();
 
   if (simgrid::smpi::Colls::smpi_coll_cleanup_callback != nullptr)
     simgrid::smpi::Colls::smpi_coll_cleanup_callback();
@@ -392,7 +383,7 @@ 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
@@ -429,7 +420,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;
 }
@@ -502,7 +494,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());
 
@@ -554,7 +547,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);
@@ -574,7 +567,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;
 
@@ -602,31 +595,33 @@ 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) {
+    auto it = process_data.find(actor);
+    if (it != process_data.end()) {
+      delete it->second;
+      process_data.erase(it);
+    }
   });
+
   smpi_init_options();
   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();
 }