Align the behavior of MC and MC_replay in SMPI, so that replay actually works

[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 84c80df..3994112 100644 (file)
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2021. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2022. The SimGrid Team. All rights reserved.          */
 
 /* 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. */
@@ -13,6 +13,7 @@
 #include "smpi_host.hpp"
 #include "src/kernel/EngineImpl.hpp"
 #include "src/kernel/activity/CommImpl.hpp"
+#include "src/mc/mc_replay.hpp"
 #include "src/smpi/include/smpi_actor.hpp"
 #include "xbt/config.hpp"
 #include "xbt/file.hpp"
@@ -91,8 +92,8 @@ static simgrid::config::Flag<int> smpi_np("smpi/np", "Number of processes to be
 
 static simgrid::config::Flag<int> smpi_map("smpi/map", "Display the mapping between nodes and processes", 0);
 
-void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl*, void*,
-                                     size_t) = &smpi_comm_copy_buffer_callback;
+std::function<void(simgrid::kernel::activity::CommImpl*, void*, size_t)> smpi_comm_copy_data_callback =
+    &smpi_comm_copy_buffer_callback;
 
 simgrid::smpi::ActorExt* smpi_process()
 {
@@ -120,7 +121,7 @@ MPI_Info smpi_process_info_env(){
 }
 
 void * smpi_process_get_user_data(){
-  return simgrid::s4u::Actor::self()->get_data();
+  return simgrid::s4u::Actor::self()->get_data<void>();
 }
 
 void smpi_process_set_user_data(void *data){
@@ -129,27 +130,23 @@ void smpi_process_set_user_data(void *data){
 
 void smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t))
 {
-  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(comm, buff, size);
-  };
+  smpi_comm_copy_data_callback = callback;
 }
 
 static void memcpy_private(void* dest, const void* src, const std::vector<std::pair<size_t, size_t>>& private_blocks)
 {
-  for (auto const& block : private_blocks)
-    memcpy((uint8_t*)dest+block.first, (uint8_t*)src+block.first, block.second-block.first);
+  for (auto const& [block_begin, block_end] : private_blocks)
+    memcpy((uint8_t*)dest + block_begin, (uint8_t*)src + block_begin, block_end - block_begin);
 }
 
 static void check_blocks(const std::vector<std::pair<size_t, size_t>>& private_blocks, size_t buff_size)
 {
-  for (auto const& block : private_blocks)
-    xbt_assert(block.first <= block.second && block.second <= buff_size, "Oops, bug in shared malloc.");
+  for (auto const& [block_begin, block_end] : private_blocks)
+    xbt_assert(block_begin <= block_end && block_end <= buff_size, "Oops, bug in shared malloc.");
 }
 
 static void smpi_cleanup_comm_after_copy(simgrid::kernel::activity::CommImpl* comm, void* buff){
-  if (comm->detached()) {
+  if (comm->is_detached()) {
     // if this is a detached send, the source buffer was duplicated by SMPI
     // sender to make the original buffer available to the application ASAP
     xbt_free(buff);
@@ -217,10 +214,6 @@ void smpi_comm_null_copy_buffer_callback(simgrid::kernel::activity::CommImpl*, v
   /* nothing done in this version */
 }
 
-int smpi_enabled() {
-  return MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED;
-}
-
 static void smpi_init_papi()
 {
 #if HAVE_PAPI
@@ -282,7 +275,7 @@ static void smpi_init_papi()
     std::string unit_name    = *(event_tokens.begin());
     papi_process_data config = {.counter_data = std::move(counters2values), .event_set = event_set};
 
-    units2papi_setup.insert(std::make_pair(unit_name, std::move(config)));
+    units2papi_setup.try_emplace(unit_name, std::move(config));
   }
 #endif
 }
@@ -329,16 +322,14 @@ static int smpi_run_entry_point(const F& entry_point, const std::string& executa
 
 static smpi_entry_point_type smpi_resolve_function(void* handle)
 {
-  auto* entry_point_fortran = reinterpret_cast<smpi_fortran_entry_point_type>(dlsym(handle, "user_main_"));
-  if (entry_point_fortran != nullptr) {
+  if (auto* entry_point_fortran = reinterpret_cast<smpi_fortran_entry_point_type>(dlsym(handle, "user_main_"))) {
     return [entry_point_fortran](int, char**) {
       entry_point_fortran();
       return 0;
     };
   }
 
-  auto* entry_point = reinterpret_cast<smpi_c_entry_point_type>(dlsym(handle, "main"));
-  if (entry_point != nullptr) {
+  if (auto* entry_point = reinterpret_cast<smpi_c_entry_point_type>(dlsym(handle, "main"))) {
     return entry_point;
   }
 
@@ -393,11 +384,11 @@ static int visit_libs(struct dl_phdr_info* info, size_t, void* data)
 {
   auto* libname    = static_cast<std::string*>(data);
   std::string path = info->dlpi_name;
-  if (path.find(*libname) != std::string::npos) {
-    *libname = std::move(path);
-    return 1;
-  }
-  return 0;
+  if (path.find(*libname) == std::string::npos)
+    return 0;
+
+  *libname = std::move(path);
+  return 1;
 }
 #endif
 
@@ -408,8 +399,7 @@ static void smpi_init_privatization_dlopen(const std::string& executable)
   stat(executable.c_str(), &fdin_stat);
   off_t fdin_size         = fdin_stat.st_size;
 
-  std::string libnames = simgrid::config::get_value<std::string>("smpi/privatize-libs");
-  if (not libnames.empty()) {
+  if (std::string libnames = simgrid::config::get_value<std::string>("smpi/privatize-libs"); not libnames.empty()) {
     // split option
     std::vector<std::string> privatize_libs;
     boost::split(privatize_libs, libnames, boost::is_any_of(";"));
@@ -575,14 +565,11 @@ int smpi_main(const char* executable, int argc, char* argv[])
   fflush(stdout);
   fflush(stderr);
 
-  if (MC_is_active()) {
-    MC_run();
-  } else {
-    engine.get_impl()->run(-1);
+  engine.get_impl()->run(-1);
+
+  xbt_os_walltimer_stop(global_timer);
+  simgrid::smpi::utils::print_time_analysis(xbt_os_timer_elapsed(global_timer));
 
-    xbt_os_walltimer_stop(global_timer);
-    simgrid::smpi::utils::print_time_analysis(xbt_os_timer_elapsed(global_timer));
-  }
   SMPI_finalize();
 
 #if SMPI_IFORT
@@ -593,6 +580,11 @@ int smpi_main(const char* executable, int argc, char* argv[])
   return smpi_exit_status;
 }
 
+int SMPI_is_inited()
+{
+  return MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED;
+}
+
 // Called either directly from the user code, or from the code called by smpirun
 void SMPI_init(){
   smpi_init_options_internal(false);
@@ -639,7 +631,7 @@ void smpi_mpi_init() {
   smpi_init_fortran_types();
   if(_smpi_init_sleep > 0)
     simgrid::s4u::this_actor::sleep_for(_smpi_init_sleep);
-  if (not MC_is_active()) {
+  if (not MC_is_active() && not MC_record_replay_is_active()) {
     smpi_deployment_startup_barrier(smpi_process()->get_instance_id());
   }
 }