-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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 "private.hpp"
#include "simgrid/s4u/Host.hpp"
#include "simgrid/s4u/Mailbox.hpp"
+#include "simgrid/s4u/forward.hpp"
#include "smpi_coll.hpp"
#include "smpi_comm.hpp"
#include "smpi_group.hpp"
};
#endif
+using simgrid::s4u::Actor;
+using simgrid::s4u::ActorPtr;
std::unordered_map<std::string, double> location2speedup;
-simgrid::smpi::Process **process_data = nullptr;
+static std::map</*process_id*/ ActorPtr, simgrid::smpi::Process*> process_data;
int process_count = 0;
int smpi_universe_size = 0;
-int* index_to_process_data = nullptr;
extern double smpi_total_benched_time;
xbt_os_timer_t global_timer;
/**
* "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 (basically, the one their SMPI instance uses).
+ * different communicators (the one their SMPI instance uses).
*
* See smpi_comm.cpp and the functions therein for details.
*/
simgrid::smpi::Process* smpi_process()
{
- smx_actor_t me = SIMIX_process_self();
+ 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->userdata);
+ simgrid::msg::ActorExt* msgExt = static_cast<simgrid::msg::ActorExt*>(me->getImpl()->userdata);
return static_cast<simgrid::smpi::Process*>(msgExt->data);
}
-simgrid::smpi::Process* smpi_process_remote(int index)
+simgrid::smpi::Process* smpi_process_remote(ActorPtr actor)
{
- return process_data[index_to_process_data[index]];
+ return process_data.at(actor);
}
MPI_Comm smpi_process_comm_self(){
}
int smpi_process_index(){
- return smpi_process()->index();
+ return simgrid::s4u::Actor::self()->getPid();
}
void * smpi_process_get_user_data(){
(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(
- static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->src_proc->userdata)->data))
- ->index());
+ smpi_switch_data_segment(Actor::self()->getPid());
tmpbuff = static_cast<void*>(xbt_malloc(buff_size));
memcpy_private(tmpbuff, buff, private_blocks);
}
if ((smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP) && ((char*)comm->dst_buff >= smpi_data_exe_start) &&
((char*)comm->dst_buff < smpi_data_exe_start + smpi_data_exe_size)) {
XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment");
- smpi_switch_data_segment(
- static_cast<simgrid::smpi::Process*>((static_cast<simgrid::msg::ActorExt*>(comm->dst_proc->userdata)->data))
- ->index());
+ smpi_switch_data_segment(Actor::self()->getPid());
}
XBT_DEBUG("Copying %zu bytes from %p to %p", buff_size, tmpbuff,comm->dst_buff);
memcpy_private(comm->dst_buff, tmpbuff, private_blocks);
}
int smpi_enabled() {
- return process_data != nullptr;
+ return not process_data.empty();
}
void smpi_global_init()
}
}
#endif
-
- if (index_to_process_data == nullptr) {
- index_to_process_data = new int[SIMIX_process_count()];
- }
-
- bool smpirun = 0;
- if (process_count == 0) { // The program has been dispatched but no other
- // SMPI instances have been registered. We're using smpirun.
- smpirun = true;
- SMPI_app_instance_register(smpi_default_instance_name, nullptr,
- SIMIX_process_count()); // This call has a side effect on process_count...
- MPI_COMM_WORLD = *smpi_deployment_comm_world(smpi_default_instance_name);
- }
- smpi_universe_size = process_count;
- process_data = new simgrid::smpi::Process*[process_count];
- for (int i = 0; i < process_count; i++) {
- if (smpirun) {
- process_data[i] = new simgrid::smpi::Process(i, smpi_deployment_finalization_barrier(smpi_default_instance_name));
- smpi_deployment_register_process(smpi_default_instance_name, i, i);
- } else {
- // TODO We can pass a nullptr here because Process::set_data() assigns the
- // barrier from the instance anyway. This is ugly and should be changed
- process_data[i] = new simgrid::smpi::Process(i, nullptr);
- }
- }
}
void smpi_global_destroy()
smpi_bench_destroy();
smpi_shared_destroy();
smpi_deployment_cleanup_instances();
- int count = smpi_process_count();
- for (int i = 0; i < count; i++) {
- if(process_data[i]->comm_self()!=MPI_COMM_NULL){
- simgrid::smpi::Comm::destroy(process_data[i]->comm_self());
+ for (auto& pair : process_data) {
+ auto& process = pair.second;
+ if (process->comm_self() != MPI_COMM_NULL) {
+ simgrid::smpi::Comm::destroy(process->comm_self());
}
- if(process_data[i]->comm_intra()!=MPI_COMM_NULL){
- simgrid::smpi::Comm::destroy(process_data[i]->comm_intra());
+ if (process->comm_intra() != MPI_COMM_NULL) {
+ simgrid::smpi::Comm::destroy(process->comm_intra());
}
- xbt_os_timer_free(process_data[i]->timer());
- xbt_mutex_destroy(process_data[i]->mailboxes_mutex());
- delete process_data[i];
+ delete process;
}
- delete[] process_data;
- process_data = nullptr;
+ process_data.clear();
if (simgrid::smpi::Colls::smpi_coll_cleanup_callback != nullptr)
simgrid::smpi::Colls::smpi_coll_cleanup_callback();
xbt_os_timer_free(global_timer);
}
- delete[] index_to_process_data;
if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP)
smpi_destroy_global_memory_segments();
smpi_free_static();
}
-extern "C" {
-
-static void smpi_init_logs(){
-
- /* Connect log categories. See xbt/log.c */
-
- XBT_LOG_CONNECT(smpi); /* Keep this line as soon as possible in this function: xbt_log_appender_file.c depends on it
- DO NOT connect this in XBT or so, or it will be useless to xbt_log_appender_file.c */
- XBT_LOG_CONNECT(instr_smpi);
- XBT_LOG_CONNECT(smpi_bench);
- XBT_LOG_CONNECT(smpi_coll);
- XBT_LOG_CONNECT(smpi_colls);
- XBT_LOG_CONNECT(smpi_comm);
- XBT_LOG_CONNECT(smpi_datatype);
- XBT_LOG_CONNECT(smpi_dvfs);
- XBT_LOG_CONNECT(smpi_group);
- XBT_LOG_CONNECT(smpi_host);
- XBT_LOG_CONNECT(smpi_kernel);
- XBT_LOG_CONNECT(smpi_mpi);
- XBT_LOG_CONNECT(smpi_memory);
- XBT_LOG_CONNECT(smpi_op);
- XBT_LOG_CONNECT(smpi_pmpi);
- XBT_LOG_CONNECT(smpi_process);
- XBT_LOG_CONNECT(smpi_request);
- XBT_LOG_CONNECT(smpi_replay);
- XBT_LOG_CONNECT(smpi_rma);
- XBT_LOG_CONNECT(smpi_shared);
- XBT_LOG_CONNECT(smpi_utils);
-}
-}
-
static void smpi_init_options(){
// return if already called
if (smpi_cpu_threshold > -1)
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?
simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
host.extension_set(new simgrid::smpi::SmpiHost(&host));
});
SIMIX_comm_set_copy_data_callback(smpi_comm_copy_buffer_callback);
smpi_init_options();
-
if (smpi_privatize_global_variables == SMPI_PRIVATIZE_DLOPEN) {
std::string executable_copy = executable;
}
+ SMPI_init();
SIMIX_launch_application(argv[2]);
+ SMPI_app_instance_register(smpi_default_instance_name, nullptr,
+ SIMIX_process_count()); // This call has a side effect on process_count...
+ MPI_COMM_WORLD = *smpi_deployment_comm_world(smpi_default_instance_name);
+ smpi_universe_size = process_count;
- SMPI_init();
/* Clean IO before the run */
fflush(stdout);
}
}
int ret = 0;
- int count = smpi_process_count();
- for (int i = 0; i < count; i++) {
- if(process_data[i]->return_value()!=0){
- ret=process_data[i]->return_value();//return first non 0 value
+ for (auto& pair : process_data) {
+ auto& smpi_process = pair.second;
+ if (smpi_process->return_value() != 0) {
+ ret = smpi_process->return_value(); // return first non 0 value
break;
}
}
// Called either directly from the user code, or from the code called by smpirun
void SMPI_init(){
- smpi_init_logs();
+ simgrid::s4u::Actor::onCreation.connect([](simgrid::s4u::ActorPtr actor) {
+ process_data.insert({actor, new simgrid::smpi::Process(actor, nullptr)});
+ });
smpi_init_options();
smpi_global_init();
smpi_check_options();
