/* 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 "smpi_host.hpp"
#include "mc/mc.h"
#include "simgrid/s4u/Engine.hpp"
#include "smpi_coll.hpp"
-#include "smpi_process.hpp"
-#include "src/msg/msg_private.hpp"
+#include "smpi_f2c.hpp"
+#include "smpi_host.hpp"
+#include "src/kernel/activity/CommImpl.hpp"
#include "src/simix/smx_private.hpp"
+#include "src/smpi/include/smpi_actor.hpp"
#include "xbt/config.hpp"
#include <cfloat> /* DBL_MAX */
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp> /* trim_right / trim_left */
+#if SMPI_IFORT
+ extern "C" void for_rtl_init_ (int *, char **);
+ extern "C" void for_rtl_finish_ ();
+#elif SMPI_FLANG
+ extern "C" void __io_set_argc(int);
+ extern "C" void __io_set_argv(char **);
+#elif SMPI_GFORTRAN
+ extern "C" void _gfortran_set_args(int, char **);
+#endif
+
#ifndef RTLD_DEEPBIND
/* RTLD_DEEPBIND is a bad idea of GNU ld that obviously does not exist on other platforms
* See https://www.akkadia.org/drepper/dsohowto.pdf
using simgrid::s4u::ActorPtr;
std::unordered_map<std::string, double> location2speedup;
-static std::map</*process_id*/ ActorPtr, simgrid::smpi::Process*> process_data;
+static std::map</*process_id*/ ActorPtr, simgrid::smpi::ActorExt*> process_data;
int process_count = 0;
static int smpi_exit_status = 0;
int smpi_universe_size = 0;
return process_count;
}
-simgrid::smpi::Process* smpi_process()
+simgrid::smpi::ActorExt* smpi_process()
{
ActorPtr me = Actor::self();
+
if (me == nullptr) // This happens sometimes (eg, when linking against NS3 because it pulls openMPI...)
return nullptr;
- simgrid::msg::ActorExt* msgExt = static_cast<simgrid::msg::ActorExt*>(me->get_impl()->get_user_data());
- return static_cast<simgrid::smpi::Process*>(msgExt->data);
+
+ return process_data.at(me);
}
-simgrid::smpi::Process* smpi_process_remote(ActorPtr actor)
+simgrid::smpi::ActorExt* smpi_process_remote(ActorPtr actor)
{
return process_data.at(actor);
}
}
void smpi_process_init(int *argc, char ***argv){
- simgrid::smpi::Process::init(argc, argv);
+ simgrid::smpi::ActorExt::init(argc, argv);
}
int smpi_process_index(){
}
void * smpi_process_get_user_data(){
- return smpi_process()->get_user_data();
+ return Actor::self()->get_impl()->get_user_data();
}
void smpi_process_set_user_data(void *data){
- return smpi_process()->set_user_data(data);
+ Actor::self()->get_impl()->set_user_data(data);
}
if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP)
smpi_destroy_global_memory_segments();
smpi_free_static();
+ if(simgrid::smpi::F2C::lookup() != nullptr)
+ simgrid::smpi::F2C::delete_lookup();
}
static void smpi_init_options(){
static int smpi_run_entry_point(smpi_entry_point_type entry_point, std::vector<std::string> args)
{
- char noarg[] = {'\0'};
- const int argc = args.size();
- std::unique_ptr<char*[]> argv(new char*[argc + 1]);
+ int argc = args.size();
+ char** argv = new char*[argc + 1];
for (int i = 0; i != argc; ++i)
- argv[i] = args[i].empty() ? noarg : &args[i].front();
+ argv[i] = xbt_strdup(args[i].c_str());
argv[argc] = nullptr;
+ simgrid::smpi::ActorExt::init(&argc, &argv);
+#if SMPI_IFORT
+ for_rtl_init_ (&argc, argv);
+#elif SMPI_FLANG
+ __io_set_argc(argc);
+ __io_set_argv(argv);
+#elif SMPI_GFORTRAN
+ _gfortran_set_args(argc, argv);
+#endif
+ int res = entry_point(argc, argv);
+
+#if SMPI_IFORT
+ for_rtl_finish_ ();
+#else
+ for (int i = 0; i != argc; ++i)
+ xbt_free(argv[i]);
+ delete[] argv;
+#endif
- int res = entry_point(argc, argv.get());
if (res != 0){
XBT_WARN("SMPI process did not return 0. Return value : %d", res);
if (smpi_exit_status == 0)
smpi_fortran_entry_point_type entry_point_fortran = (smpi_fortran_entry_point_type)dlsym(handle, "user_main_");
if (entry_point_fortran != nullptr) {
return [entry_point_fortran](int argc, char** argv) {
- smpi_process_init(&argc, &argv);
entry_point_fortran();
return 0;
};
}
TRACE_global_init();
-
SIMIX_global_init(&argc, argv);
- MSG_init(&argc, argv); // FIXME Remove this MSG call. Once it's removed, we can remove the msg header include as well
SMPI_switch_data_segment = &smpi_switch_data_segment;
// TODO This will not be executed in the case where smpi_main is not called,
// e.g., not for smpi_msg_masterslave. This should be moved to another location
- // that is always called -- maybe close to Actor::onCreation?
+ // that is always called -- maybe close to Actor::on_creation?
simgrid::s4u::Host::on_creation.connect(
[](simgrid::s4u::Host& host) { host.extension_set(new simgrid::smpi::Host(&host)); });
// parse the platform file: get the host list
- SIMIX_create_environment(argv[1]);
+ simgrid::s4u::Engine::get_instance()->load_platform(argv[1]);
SIMIX_comm_set_copy_data_callback(smpi_comm_copy_buffer_callback);
smpi_init_options();
smpi_init_privatization_no_dlopen(executable);
SMPI_init();
- SIMIX_launch_application(argv[2]);
+ simgrid::s4u::Engine::get_instance()->load_deployment(argv[2]);
SMPI_app_instance_register(smpi_default_instance_name.c_str(), nullptr,
process_data.size()); // This call has a side effect on process_count...
MPI_COMM_WORLD = *smpi_deployment_comm_world(smpi_default_instance_name);
void SMPI_init(){
simgrid::s4u::Actor::on_creation.connect([](simgrid::s4u::ActorPtr actor) {
if (not actor->is_daemon()) {
- process_data.insert({actor, new simgrid::smpi::Process(actor, nullptr)});
+ process_data.insert({actor, new simgrid::smpi::ActorExt(actor, nullptr)});
}
});
simgrid::s4u::Actor::on_destruction.connect([](simgrid::s4u::ActorPtr actor) {
smpi_init_options();
smpi_global_init();
smpi_check_options();
- simgrid::s4u::on_simulation_end.connect(TRACE_smpi_release);
}
void SMPI_finalize(){
}
void smpi_mpi_init() {
+ smpi_init_fortran_types();
if(smpi_init_sleep > 0)
simcall_process_sleep(smpi_init_sleep);
}