X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/165f0d8397015d910184a9869d045037af0b2edc..16bda2500ecf72bb920f4131e431b9f802ffc15a:/src/smpi/smpi_global.cpp?ds=sidebyside diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp index 7d5fa45b96..f11aae6f66 100644 --- a/src/smpi/smpi_global.cpp +++ b/src/smpi/smpi_global.cpp @@ -3,10 +3,13 @@ /* 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. */ +#include +#include #include +#include +#include #include #include -#include #include "mc/mc.h" #include "private.h" @@ -18,6 +21,7 @@ #include "src/mc/mc_replay.h" #include "src/msg/msg_private.h" #include "src/simix/smx_private.h" +#include "src/surf/surf_interface.hpp" #include "surf/surf.h" #include "xbt/replay.hpp" #include @@ -294,14 +298,16 @@ void smpi_global_init() #endif int smpirun = 0; + msg_bar_t finalization_barrier = nullptr; if (process_count == 0){ process_count = SIMIX_process_count(); smpirun=1; + finalization_barrier = MSG_barrier_init(process_count); } smpi_universe_size = process_count; process_data = new simgrid::smpi::Process*[process_count]; for (int i = 0; i < process_count; i++) { - process_data[i] = new simgrid::smpi::Process(i); + process_data[i] = new simgrid::smpi::Process(i, finalization_barrier); } //if the process was launched through smpirun script we generate a global mpi_comm_world //if not, we let MPI_COMM_NULL, and the comm world will be private to each mpi instance @@ -309,12 +315,9 @@ void smpi_global_init() group = new simgrid::smpi::Group(process_count); MPI_COMM_WORLD = new simgrid::smpi::Comm(group, nullptr); MPI_Attr_put(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, reinterpret_cast(process_count)); - msg_bar_t bar = MSG_barrier_init(process_count); - for (int i = 0; i < process_count; i++) { + for (int i = 0; i < process_count; i++) group->set_mapping(i, i); - process_data[i]->set_finalization_barrier(bar); - } } } @@ -498,19 +501,14 @@ int smpi_main(const char* executable, int argc, char *argv[]) * configuration tools */ return 0; } - smpi_init_logs(); TRACE_global_init(&argc, argv); - TRACE_add_start_function(TRACE_smpi_alloc); - TRACE_add_end_function(TRACE_smpi_release); SIMIX_global_init(&argc, argv); MSG_init(&argc,argv); SMPI_switch_data_segment = &smpi_switch_data_segment; - smpi_init_options(); - // parse the platform file: get the host list SIMIX_create_environment(argv[1]); SIMIX_comm_set_copy_data_callback(smpi_comm_copy_buffer_callback); @@ -520,24 +518,28 @@ int smpi_main(const char* executable, int argc, char *argv[]) if (smpi_privatize_global_variables == SMPI_PRIVATIZE_DLOPEN) { std::string executable_copy = executable; - simix_global->default_function = [executable_copy](std::vector args) { - return std::function([executable_copy, args] { + + // Prepare the copy of the binary (open the file and get its size) + // (fdin will remain open for the whole process execution. That's a sort of leak but we can live with it) + int fdin = open(executable_copy.c_str(), O_RDONLY); + xbt_assert(fdin >= 0, "Cannot read from %s", executable_copy.c_str()); + struct stat fdin_stat; + fstat(fdin, &fdin_stat); + off_t fdin_size = fdin_stat.st_size; + + simix_global->default_function = [executable_copy, fdin, fdin_size](std::vector args) { + return std::function([executable_copy, fdin, fdin_size, args] { // Copy the dynamic library: std::string target_executable = executable_copy + "_" + std::to_string(getpid()) + "_" + std::to_string(rank++) + ".so"; - // TODO, execute directly instead of relying on cp - const char* command1 [] = { - "cp", "--reflink=auto", "--", executable_copy.c_str(), target_executable.c_str(), - nullptr - }; - const char* command2 [] = { - "cp", "--", executable_copy.c_str(), target_executable.c_str(), - nullptr - }; - if (execute_command(command1) != 0 && execute_command(command2) != 0) - xbt_die("copy failed"); + + int fdout = open(target_executable.c_str(), O_WRONLY); + xbt_assert(fdout >= 0, "Cannot write into %s", target_executable.c_str()); + + sendfile(fdout, fdin, NULL, fdin_size); + close(fdout); // Load the copy and resolve the entry point: void* handle = dlopen(target_executable.c_str(), RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND); @@ -548,7 +550,7 @@ int smpi_main(const char* executable, int argc, char *argv[]) if (!entry_point) xbt_die("Could not resolve entry point"); - smpi_run_entry_point(entry_point, args); + smpi_run_entry_point(entry_point, args); }); }; @@ -575,12 +577,7 @@ int smpi_main(const char* executable, int argc, char *argv[]) SIMIX_launch_application(argv[2]); - smpi_global_init(); - - smpi_check_options(); - - if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) - smpi_initialize_global_memory_segments(); + SMPI_init(); /* Clean IO before the run */ fflush(stdout); @@ -620,15 +617,14 @@ int smpi_main(const char* executable, int argc, char *argv[]) return ret; } -// This function can be called from extern file, to initialize logs, options, and processes of smpi -// without the need of smpirun +// Called either directly from the user code, or from the code called by smpirun void SMPI_init(){ smpi_init_logs(); smpi_init_options(); smpi_global_init(); smpi_check_options(); - if (TRACE_is_enabled() && TRACE_is_configured()) - TRACE_smpi_alloc(); + TRACE_smpi_alloc(); + simgrid::surf::surfExitCallbacks.connect(TRACE_smpi_release); if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) smpi_initialize_global_memory_segments(); }