-/* Copyright (c) 2007-2020. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2021. 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. */
#include "mc/mc.h"
-#include "simgrid/s4u/Engine.hpp"
#include "simgrid/plugins/file_system.h"
+#include "simgrid/s4u/Engine.hpp"
#include "smpi_coll.hpp"
+#include "smpi_config.hpp"
#include "smpi_f2c.hpp"
#include "smpi_host.hpp"
-#include "smpi_config.hpp"
+#include "src/kernel/EngineImpl.hpp"
#include "src/kernel/activity/CommImpl.hpp"
#include "src/simix/smx_private.hpp"
#include "src/smpi/include/smpi_actor.hpp"
#include "xbt/file.hpp"
#include <algorithm>
+#include <array>
#include <boost/algorithm/string.hpp> /* split */
#include <boost/tokenizer.hpp>
+#include <cerrno>
#include <cinttypes>
#include <cstdint> /* intmax_t */
+#include <cstring> /* strerror */
#include <dlfcn.h>
#include <fcntl.h>
#include <fstream>
#endif
#if HAVE_PAPI
-std::string papi_default_config_name = "default";
-std::map</* computation unit name */ std::string, papi_process_data> units2papi_setup;
+std::map</* computation unit name */ std::string, papi_process_data, std::less<>> units2papi_setup;
#endif
std::unordered_map<std::string, double> location2speedup;
static int smpi_exit_status = 0;
-extern double smpi_total_benched_time;
xbt_os_timer_t global_timer;
static std::vector<std::string> privatize_libs_paths;
-/**
- * Setting MPI_COMM_WORLD to MPI_COMM_UNINITIALIZED (it's a variable)
- * is important because the implementation of MPI_Comm checks
- * "this == MPI_COMM_UNINITIALIZED"? If yes, it uses smpi_process()->comm_world()
- * instead of "this".
- * This is basically how we only have one global variable but all processes have
- * different communicators (the one their SMPI instance uses).
- *
- * See smpi_comm.cpp and the functions therein for details.
- */
-MPI_Comm MPI_COMM_WORLD = MPI_COMM_UNINITIALIZED;
+
// No instance gets manually created; check also the smpirun.in script as
// this default name is used there as well (when the <actor> tag is generated).
static const std::string smpi_default_instance_name("smpirun");
}
XBT_DEBUG("Successfully added PAPI event '%s' to the event set.", event_name);
- counters2values.push_back(
- // We cannot just pass *events_it, as this is of type const basic_string
- std::make_pair(std::string(*events_it), 0LL));
+ counters2values.emplace_back(*events_it, 0LL);
}
std::string unit_name = *(event_tokens.begin());
{
int fdin = open(src.c_str(), O_RDONLY);
xbt_assert(fdin >= 0, "Cannot read from %s. Please make sure that the file exists and is executable.", src.c_str());
- int fdout = open(target.c_str(), O_CREAT | O_RDWR, S_IRWXU);
- xbt_assert(fdout >= 0, "Cannot write into %s", target.c_str());
+ xbt_assert(unlink(target.c_str()) == 0 || errno == ENOENT, "Failed to unlink file %s: %s", target.c_str(),
+ strerror(errno));
+ int fdout = open(target.c_str(), O_CREAT | O_RDWR | O_EXCL, S_IRWXU);
+ xbt_assert(fdout >= 0, "Cannot write into %s: %s", target.c_str(), strerror(errno));
XBT_DEBUG("Copy %" PRIdMAX " bytes into %s", static_cast<intmax_t>(fdin_size), target.c_str());
#if SG_HAVE_SENDFILE
close(fdin);
close(fdout);
return;
- } else if (sent_size != -1 || errno != ENOSYS) {
- xbt_die("Error while copying %s: only %zd bytes copied instead of %" PRIdMAX " (errno: %d -- %s)", target.c_str(),
- sent_size, static_cast<intmax_t>(fdin_size), errno, strerror(errno));
}
+ xbt_assert(sent_size == -1 && errno == ENOSYS,
+ "Error while copying %s: only %zd bytes copied instead of %" PRIdMAX " (errno: %d -- %s)", target.c_str(),
+ sent_size, static_cast<intmax_t>(fdin_size), errno, strerror(errno));
#endif
// If this point is reached, sendfile() actually is not available. Copy file by hand.
- const int bufsize = 1024 * 1024 * 4;
- auto* buf = new char[bufsize];
- while (int got = read(fdin, buf, bufsize)) {
+ std::vector<unsigned char> buf(1024 * 1024 * 4);
+ while (ssize_t got = read(fdin, buf.data(), buf.size())) {
if (got == -1) {
xbt_assert(errno == EINTR, "Cannot read from %s", src.c_str());
} else {
- const char* p = buf;
- int todo = got;
- while (int done = write(fdout, p, todo)) {
+ const unsigned char* p = buf.data();
+ ssize_t todo = got;
+ while (ssize_t done = write(fdout, p, todo)) {
if (done == -1) {
xbt_assert(errno == EINTR, "Cannot write into %s", target.c_str());
} else {
}
}
}
- delete[] buf;
close(fdin);
close(fdout);
}
for (auto const& libname : privatize_libs) {
// load the library once to add it to the local libs, to get the absolute path
void* libhandle = dlopen(libname.c_str(), RTLD_LAZY);
- xbt_assert(libhandle != nullptr,
- "Cannot dlopen %s - check your settings in smpi/privatize-libs", libname.c_str());
+ xbt_assert(libhandle != nullptr, "Cannot dlopen %s - check your settings in smpi/privatize-libs",
+ libname.c_str());
// get library name from path
std::string fullpath = libname;
#if not defined(__APPLE__) && not defined(__HAIKU__)
- xbt_assert(0 != dl_iterate_phdr(visit_libs, &fullpath),
+ xbt_assert(dl_iterate_phdr(visit_libs, &fullpath) != 0,
"Can't find a linked %s - check your settings in smpi/privatize-libs", fullpath.c_str());
XBT_DEBUG("Extra lib to privatize '%s' found", fullpath.c_str());
#else
// Copy the dynamic library, the new name must be the same length as the old one
// just replace the name with 7 digits for the rank and the rest of the name.
- unsigned int pad = 7;
- if (libname.length() < pad)
- pad = libname.length();
- std::string target_lib = simgrid::config::get_value<std::string>("smpi/tmpdir") + "/" +
- std::string(pad - std::to_string(rank).length(), '0') + std::to_string(rank) + libname.substr(pad);
+ auto pad = std::min<unsigned>(7, libname.length());
+ std::string target_libname = std::string(pad - std::to_string(rank).length(), '0') + std::to_string(rank) + libname.substr(pad);
+ std::string target_lib = simgrid::config::get_value<std::string>("smpi/tmpdir") + "/" + target_libname;
target_libs.push_back(target_lib);
XBT_DEBUG("copy lib %s to %s, with size %lld", libpath.c_str(), target_lib.c_str(), (long long)fdin_size2);
smpi_copy_file(libpath, target_lib, fdin_size2);
- std::string sedcommand = "sed -i -e 's/" + libname + "/" + target_lib + "/g' " + target_executable;
+ std::string sedcommand = "sed -i -e 's/" + libname + "/" + target_libname + "/g' " + target_executable;
int status = system(sedcommand.c_str());
xbt_assert(status == 0, "error while applying sed command %s \n", sedcommand.c_str());
}
for (const std::string& target_lib : target_libs)
unlink(target_lib.c_str());
}
- xbt_assert(handle != nullptr, "dlopen failed: %s (errno: %d -- %s)", dlerror(), saved_errno,
- strerror(saved_errno));
+ xbt_assert(handle != nullptr,
+ "dlopen failed: %s (errno: %d -- %s).\nError: Did you compile the program with a SMPI-specific "
+ "compiler (spmicc or friends)?",
+ dlerror(), saved_errno, strerror(saved_errno));
smpi_entry_point_type entry_point = smpi_resolve_function(handle);
- xbt_assert(entry_point, "Could not resolve entry point");
+ xbt_assert(entry_point, "Could not resolve entry point. Does your program contain a main() function?");
smpi_run_entry_point(entry_point, executable, args);
});
});
sg_storage_file_system_init();
// parse the platform file: get the host list
engine->load_platform(argv[1]);
- SIMIX_comm_set_copy_data_callback(smpi_comm_copy_buffer_callback);
+ simgrid::kernel::activity::CommImpl::set_copy_data_callback(smpi_comm_copy_buffer_callback);
if (smpi_cfg_privatization() == SmpiPrivStrategies::DLOPEN)
smpi_init_privatization_dlopen(executable);
if (MC_is_active()) {
MC_run();
} else {
- SIMIX_run();
+ simgrid::kernel::EngineImpl::get_instance()->run();
xbt_os_walltimer_stop(global_timer);
- if (simgrid::config::get_value<bool>("smpi/display-timing")) {
- double global_time = xbt_os_timer_elapsed(global_timer);
- XBT_INFO("Simulated time: %g seconds. \n\n"
- "The simulation took %g seconds (after parsing and platform setup)\n"
- "%g seconds were actual computation of the application",
- SIMIX_get_clock(), global_time , smpi_total_benched_time);
-
- if (smpi_total_benched_time/global_time>=0.75)
- XBT_INFO("More than 75%% of the time was spent inside the application code.\n"
- "You may want to use sampling functions or trace replay to reduce this.");
- }
+ simgrid::smpi::utils::print_time_analysis(xbt_os_timer_elapsed(global_timer));
}
SMPI_finalize();
if (smpi_cfg_privatization() == SmpiPrivStrategies::MMAP)
smpi_destroy_global_memory_segments();
- if (simgrid::smpi::F2C::lookup() != nullptr)
- simgrid::smpi::F2C::delete_lookup();
+
+ simgrid::smpi::utils::print_memory_analysis();
}
void smpi_mpi_init() {
void SMPI_thread_create() {
TRACE_smpi_init(simgrid::s4u::this_actor::get_pid(), __func__);
+ smpi_process()->mark_as_initialized();
}
