cleaning the actor twice seems somewhat overplayed

[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 c8253ee..70def16 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -30,11 +30,11 @@
 # ifndef MAC_OS_X_VERSION_10_12
 #   define MAC_OS_X_VERSION_10_12 101200
 # endif
-# define HAVE_WORKING_MMAP (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_12)
+constexpr bool HAVE_WORKING_MMAP = (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_12);
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-# define HAVE_WORKING_MMAP 0
+constexpr bool HAVE_WORKING_MMAP = false;
 #else
-# define HAVE_WORKING_MMAP 1
+constexpr bool HAVE_WORKING_MMAP = true;
 #endif
 
 #if SG_HAVE_SENDFILE
@@ -102,7 +102,8 @@ static const std::string smpi_default_instance_name("smpirun");
 static simgrid::config::Flag<double> smpi_init_sleep(
   "smpi/init", "Time to inject inside a call to MPI_Init", 0.0);
 
-void (*smpi_comm_copy_data_callback) (smx_activity_t, void*, size_t) = &smpi_comm_copy_buffer_callback;
+void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl*, void*,
+                                     size_t) = &smpi_comm_copy_buffer_callback;
 
 int smpi_process_count()
 {
@@ -151,7 +152,11 @@ int smpi_global_size()
 
 void smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t))
 {
-  smpi_comm_copy_data_callback = callback;
+  static void (*saved_callback)(smx_activity_t, void*, size_t);
+  saved_callback               = callback;
+  smpi_comm_copy_data_callback = [](simgrid::kernel::activity::CommImpl* comm, void* buff, size_t size) {
+    saved_callback(smx_activity_t(comm), buff, size);
+  };
 }
 
 static void memcpy_private(void* dest, const void* src, std::vector<std::pair<size_t, size_t>>& private_blocks)
@@ -165,10 +170,8 @@ static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks,
     xbt_assert(block.first <= block.second && block.second <= buff_size, "Oops, bug in shared malloc.");
 }
 
-void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t buff_size)
+void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, void* buff, size_t buff_size)
 {
-  simgrid::kernel::activity::CommImplPtr comm =
-      boost::static_pointer_cast<simgrid::kernel::activity::CommImpl>(synchro);
   int src_shared                        = 0;
   int dst_shared                        = 0;
   size_t src_offset                     = 0;
@@ -227,7 +230,7 @@ void smpi_comm_copy_buffer_callback(smx_activity_t synchro, void *buff, size_t b
     xbt_free(tmpbuff);
 }
 
-void smpi_comm_null_copy_buffer_callback(smx_activity_t comm, void *buff, size_t buff_size)
+void smpi_comm_null_copy_buffer_callback(simgrid::kernel::activity::CommImpl*, void*, size_t)
 {
   /* nothing done in this version */
 }
@@ -395,12 +398,10 @@ static void smpi_init_options(){
     XBT_DEBUG("Running without smpi_main(); disable smpi/privatization.");
     smpi_privatize_global_variables = SmpiPrivStrategies::NONE;
   }
-#if !HAVE_WORKING_MMAP
-  if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+  if (not HAVE_WORKING_MMAP && smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
     XBT_INFO("mmap privatization is broken on this platform, switching to dlopen privatization instead.");
     smpi_privatize_global_variables = SmpiPrivStrategies::DLOPEN;
   }
-#endif
 
   if (smpi_cpu_threshold < 0)
     smpi_cpu_threshold = DBL_MAX;
@@ -422,7 +423,7 @@ typedef std::function<int(int argc, char *argv[])> smpi_entry_point_type;
 typedef int (* smpi_c_entry_point_type)(int argc, char **argv);
 typedef void (*smpi_fortran_entry_point_type)();
 
-static int smpi_run_entry_point(smpi_entry_point_type entry_point, const std::string& executable_path,
+static int smpi_run_entry_point(const smpi_entry_point_type& entry_point, const std::string& executable_path,
                                 std::vector<std::string> args)
 {
   // copy C strings, we need them writable
@@ -660,8 +661,6 @@ static void smpi_init_privatization_no_dlopen(const std::string& executable)
 
 int smpi_main(const char* executable, int argc, char* argv[])
 {
-  srand(SMPI_RAND_SEED);
-
   if (getenv("SMPI_PRETEND_CC") != nullptr) {
     /* Hack to ensure that smpicc can pretend to be a simple compiler. Particularly handy to pass it to the
      * configuration tools */