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

diff --git a/src/smpi/internals/smpi_global.cpp b/src/smpi/internals/smpi_global.cpp
index 4834e848a1..d578f01ff2 100644
--- a/src/smpi/internals/smpi_global.cpp
+++ b/src/smpi/internals/smpi_global.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2020. 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. */
@@ -128,17 +128,18 @@ void smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, s
   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);
+    saved_callback(comm, buff, size);
   };
 }
 
-static void memcpy_private(void* dest, const void* src, std::vector<std::pair<size_t, size_t>>& private_blocks)
+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);
 }
 
-static void check_blocks(std::vector<std::pair<size_t, size_t>> &private_blocks, size_t buff_size) {
+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.");
 }
@@ -163,7 +164,7 @@ void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, v
   XBT_DEBUG("Copy the data over");
   if(smpi_is_shared(buff, src_private_blocks, &src_offset)) {
     src_private_blocks = shift_and_frame_private_blocks(src_private_blocks, src_offset, buff_size);
-    if (src_private_blocks.size()==0){//simple shared malloc ... return.
+    if (src_private_blocks.empty()) { // simple shared malloc ... return.
       XBT_VERB("Sender is shared. Let's ignore it.");
       smpi_cleanup_comm_after_copy(comm, buff);
       return;
@@ -171,11 +172,11 @@ void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, v
   }
   else {
     src_private_blocks.clear();
-    src_private_blocks.push_back(std::make_pair(0, buff_size));
+    src_private_blocks.emplace_back(0, buff_size);
   }
   if (smpi_is_shared((char*)comm->dst_buff_, dst_private_blocks, &dst_offset)) {
     dst_private_blocks = shift_and_frame_private_blocks(dst_private_blocks, dst_offset, buff_size);
-    if (dst_private_blocks.size()==0){//simple shared malloc ... return.
+    if (dst_private_blocks.empty()) { // simple shared malloc ... return.
       XBT_VERB("Receiver is shared. Let's ignore it.");
       smpi_cleanup_comm_after_copy(comm, buff);
       return;
@@ -183,7 +184,7 @@ void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, v
   }
   else {
     dst_private_blocks.clear();
-    dst_private_blocks.push_back(std::make_pair(0, buff_size));
+    dst_private_blocks.emplace_back(0, buff_size);
   }
   check_blocks(src_private_blocks, buff_size);
   check_blocks(dst_private_blocks, buff_size);
@@ -195,7 +196,7 @@ void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, v
       (static_cast<char*>(buff) < smpi_data_exe_start + smpi_data_exe_size)) {
     XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !");
     smpi_switch_data_segment(comm->src_actor_->iface());
-    tmpbuff = static_cast<void*>(xbt_malloc(buff_size));
+    tmpbuff = xbt_malloc(buff_size);
     memcpy_private(tmpbuff, buff, private_blocks);
   }
 
@@ -261,7 +262,7 @@ static void smpi_init_papi()
       // first. Hence, we start at ++(events.begin())!
       for (Tokenizer::iterator events_it = ++(event_tokens.begin()); events_it != event_tokens.end(); ++events_it) {
         int event_code   = PAPI_NULL;
-        char* event_name = const_cast<char*>((*events_it).c_str());
+        auto* event_name = const_cast<char*>((*events_it).c_str());
         if (PAPI_event_name_to_code(event_name, &event_code) != PAPI_OK) {
           XBT_CRITICAL("Could not find PAPI event '%s'. Skipping.", event_name);
           continue;
@@ -296,7 +297,7 @@ template <typename F>
 static int smpi_run_entry_point(const F& entry_point, const std::string& executable_path, std::vector<std::string> args)
 {
   // copy C strings, we need them writable
-  std::vector<char*>* args4argv = new std::vector<char*>(args.size());
+  auto* args4argv = new std::vector<char*>(args.size());
   std::transform(begin(args), end(args), begin(*args4argv), [](const std::string& s) { return xbt_strdup(s.c_str()); });
 
   // set argv[0] to executable_path
@@ -341,7 +342,7 @@ static int smpi_run_entry_point(const F& entry_point, const std::string& executa
 // TODO, remove the number of functions involved here
 static smpi_entry_point_type smpi_resolve_function(void* handle)
 {
-  smpi_fortran_entry_point_type entry_point_fortran = (smpi_fortran_entry_point_type)dlsym(handle, "user_main_");
+  auto* entry_point_fortran = reinterpret_cast<smpi_fortran_entry_point_type>(dlsym(handle, "user_main_"));
   if (entry_point_fortran != nullptr) {
     return [entry_point_fortran](int, char**) {
       entry_point_fortran();
@@ -349,7 +350,7 @@ static smpi_entry_point_type smpi_resolve_function(void* handle)
     };
   }
 
-  smpi_c_entry_point_type entry_point = (smpi_c_entry_point_type)dlsym(handle, "main");
+  auto* entry_point = reinterpret_cast<smpi_c_entry_point_type>(dlsym(handle, "main"));
   if (entry_point != nullptr) {
     return entry_point;
   }
@@ -366,7 +367,7 @@ static void smpi_copy_file(const std::string& src, const std::string& target, of
 
   XBT_DEBUG("Copy %" PRIdMAX " bytes into %s", static_cast<intmax_t>(fdin_size), target.c_str());
 #if SG_HAVE_SENDFILE
-  ssize_t sent_size = sendfile(fdout, fdin, NULL, fdin_size);
+  ssize_t sent_size = sendfile(fdout, fdin, nullptr, fdin_size);
   if (sent_size == fdin_size) {
     close(fdin);
     close(fdout);
@@ -378,12 +379,12 @@ static void smpi_copy_file(const std::string& src, const std::string& target, of
 #endif
   // If this point is reached, sendfile() actually is not available.  Copy file by hand.
   const int bufsize = 1024 * 1024 * 4;
-  char* buf         = new char[bufsize];
+  auto* buf         = new char[bufsize];
   while (int got = read(fdin, buf, bufsize)) {
     if (got == -1) {
       xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
     } else {
-      char* p  = buf;
+      const char* p = buf;
       int todo = got;
       while (int done = write(fdout, p, todo)) {
         if (done == -1) {
@@ -403,7 +404,7 @@ static void smpi_copy_file(const std::string& src, const std::string& target, of
 #if not defined(__APPLE__) && not defined(__HAIKU__)
 static int visit_libs(struct dl_phdr_info* info, size_t, void* data)
 {
-  char* libname = (char*)(data);
+  auto* libname    = static_cast<char*>(data);
   const char *path = info->dlpi_name;
   if(strstr(path, libname)){
     strncpy(libname, path, 512);
@@ -440,12 +441,12 @@ static void smpi_init_privatization_dlopen(const std::string& executable)
 #else
       xbt_die("smpi/privatize-libs is not (yet) compatible with OSX nor with Haiku");
 #endif
-      privatize_libs_paths.push_back(fullpath);
+      privatize_libs_paths.emplace_back(fullpath);
       dlclose(libhandle);
     }
   }
 
-  simix_global->default_function = [executable, fdin_size](std::vector<std::string> args) {
+  simgrid::s4u::Engine::get_instance()->register_default([executable, fdin_size](std::vector<std::string> args) {
     return std::function<void()>([executable, fdin_size, args] {
       static std::size_t rank = 0;
       // Copy the dynamic library:
@@ -500,7 +501,7 @@ static void smpi_init_privatization_dlopen(const std::string& executable)
       xbt_assert(entry_point, "Could not resolve entry point");
       smpi_run_entry_point(entry_point, executable, args);
     });
-  };
+  });
 }
 
 static void smpi_init_privatization_no_dlopen(const std::string& executable)
@@ -519,10 +520,10 @@ static void smpi_init_privatization_no_dlopen(const std::string& executable)
     smpi_backup_global_memory_segment();
 
   // Execute the same entry point for each simulated process:
-  simix_global->default_function = [entry_point, executable](std::vector<std::string> args) {
+  simgrid::s4u::Engine::get_instance()->register_default([entry_point, executable](std::vector<std::string> args) {
     return std::function<void()>(
         [entry_point, executable, args] { smpi_run_entry_point(entry_point, executable, args); });
-  };
+  });
 }
 
 int smpi_main(const char* executable, int argc, char* argv[])
@@ -535,7 +536,7 @@ int smpi_main(const char* executable, int argc, char* argv[])
   
   SMPI_switch_data_segment = &smpi_switch_data_segment;
   smpi_init_options();
-  TRACE_global_init();
+  simgrid::instr::init();
   SIMIX_global_init(&argc, argv);
 
   auto engine              = simgrid::s4u::Engine::get_instance();
@@ -557,7 +558,7 @@ int smpi_main(const char* executable, int argc, char* argv[])
 
   /* This is a ... heavy way to count the MPI ranks */
   int rank_counts = 0;
-  simgrid::s4u::Actor::on_creation.connect([&rank_counts](simgrid::s4u::Actor& actor) {
+  simgrid::s4u::Actor::on_creation.connect([&rank_counts](const simgrid::s4u::Actor& actor) {
     if (not actor.is_daemon())
       rank_counts++;
   });
@@ -639,3 +640,7 @@ void smpi_mpi_init() {
   if(smpi_init_sleep > 0)
     simgrid::s4u::this_actor::sleep_for(smpi_init_sleep);
 }
+
+void SMPI_thread_create() {
+  TRACE_smpi_init(simgrid::s4u::this_actor::get_pid(), __func__);
+}