-/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2010-2019. 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 "simgrid/s4u/Host.hpp"
-#include <climits>
-
-#include "src/simix/smx_private.h"
-#include "private.h"
-#include "private.hpp"
#include "smpi_comm.hpp"
#include "smpi_coll.hpp"
#include "smpi_datatype.hpp"
-#include "smpi_process.hpp"
#include "smpi_request.hpp"
-#include "smpi_status.hpp"
#include "smpi_win.hpp"
+#include "src/smpi/include/smpi_actor.hpp"
+#include "src/surf/HostImpl.hpp"
+
+#include <climits>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_comm, smpi, "Logging specific to SMPI (comm)");
- simgrid::smpi::Comm mpi_MPI_COMM_UNINITIALIZED;
+simgrid::smpi::Comm mpi_MPI_COMM_UNINITIALIZED;
MPI_Comm MPI_COMM_UNINITIALIZED=&mpi_MPI_COMM_UNINITIALIZED;
+using simgrid::s4u::ActorPtr;
+
/* Support for cartesian topology was added, but there are 2 other types of topology, graph et dist graph. In order to
* support them, we have to add a field SMPI_Topo_type, and replace the MPI_Topology field by an union. */
-static int smpi_compare_rankmap(const void *a, const void *b)
-{
- const int* x = static_cast<const int*>(a);
- const int* y = static_cast<const int*>(b);
-
- if (x[1] < y[1]) {
- return -1;
- }
- if (x[1] == y[1]) {
- if (x[0] < y[0]) {
- return -1;
- }
- if (x[0] == y[0]) {
- return 0;
- }
- return 1;
- }
- return 1;
-}
-
namespace simgrid{
namespace smpi{
std::unordered_map<int, smpi_key_elem> Comm::keyvals_;
int Comm::keyval_id_=0;
-Comm::Comm(MPI_Group group, MPI_Topology topo) : group_(group), topo_(topo)
+Comm::Comm(MPI_Group group, MPI_Topology topo, int smp) : group_(group), topo_(topo),is_smp_comm_(smp)
{
- refcount_=1;
- topoType_ = MPI_INVALID_TOPO;
- intra_comm_ = MPI_COMM_NULL;
- leaders_comm_ = MPI_COMM_NULL;
- is_uniform_=1;
+ refcount_ = 1;
+ topoType_ = MPI_INVALID_TOPO;
+ intra_comm_ = MPI_COMM_NULL;
+ leaders_comm_ = MPI_COMM_NULL;
+ is_uniform_ = 1;
non_uniform_map_ = nullptr;
- leaders_map_ = nullptr;
- is_blocked_=0;
+ leaders_map_ = nullptr;
+ is_blocked_ = 0;
}
void Comm::destroy(Comm* comm)
}
int Comm::dup(MPI_Comm* newcomm){
- if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables
- smpi_switch_data_segment(smpi_process()->index());
- }
+ if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+ // we need to switch as the called function may silently touch global variables
+ smpi_switch_data_segment(simgrid::s4u::Actor::self());
+ }
MPI_Group cp = new Group(this->group());
- (*newcomm) = new Comm(cp, this->topo());
- int ret = MPI_SUCCESS;
+ (*newcomm) = new Comm(cp, this->topo());
+ int ret = MPI_SUCCESS;
if (not attributes()->empty()) {
- int flag;
- void* value_out;
- for(auto it : *attributes()){
+ int flag=0;
+ void* value_out=nullptr;
+ for (auto const& it : *attributes()) {
smpi_key_elem elem = keyvals_.at(it.first);
- if (elem != nullptr && elem->copy_fn.comm_copy_fn != MPI_NULL_COPY_FN) {
- ret = elem->copy_fn.comm_copy_fn(this, it.first, nullptr, it.second, &value_out, &flag);
+ if (elem != nullptr){
+ if( elem->copy_fn.comm_copy_fn != MPI_NULL_COPY_FN &&
+ elem->copy_fn.comm_copy_fn != MPI_COMM_DUP_FN)
+ ret = elem->copy_fn.comm_copy_fn(this, it.first, elem->extra_state, it.second, &value_out, &flag);
+ else if ( elem->copy_fn.comm_copy_fn_fort != MPI_NULL_COPY_FN &&
+ *(int*)*elem->copy_fn.comm_copy_fn_fort != 1){
+ value_out=(int*)xbt_malloc(sizeof(int));
+ elem->copy_fn.comm_copy_fn_fort(this, it.first, elem->extra_state, it.second, value_out, &flag,&ret);
+ }
if (ret != MPI_SUCCESS) {
Comm::destroy(*newcomm);
*newcomm = MPI_COMM_NULL;
return ret;
}
- if (flag){
+ if (elem->copy_fn.comm_copy_fn == MPI_COMM_DUP_FN ||
+ ((elem->copy_fn.comm_copy_fn_fort != MPI_NULL_COPY_FN) && *(int*)*elem->copy_fn.comm_copy_fn_fort == 1)){
+ elem->refcount++;
+ (*newcomm)->attributes()->insert({it.first, it.second});
+ }else if (flag){
elem->refcount++;
(*newcomm)->attributes()->insert({it.first, value_out});
}
}
- }
}
+ }
return ret;
}
{
if (this == MPI_COMM_UNINITIALIZED)
return smpi_process()->comm_world()->rank();
- return group_->rank(smpi_process()->index());
+ return group_->rank(simgrid::s4u::Actor::self());
}
void Comm::get_name (char* name, int* len)
return;
}
if(this == MPI_COMM_WORLD) {
- strncpy(name, "WORLD",5);
+ strncpy(name, "WORLD", 6);
*len = 5;
} else {
*len = snprintf(name, MPI_MAX_NAME_STRING, "%p", this);
return is_blocked_;
}
+int Comm::is_smp_comm(){
+ if (this == MPI_COMM_UNINITIALIZED)
+ return smpi_process()->comm_world()->is_smp_comm();
+ return is_smp_comm_;
+}
+
MPI_Comm Comm::split(int color, int key)
{
if (this == MPI_COMM_UNINITIALIZED)
/* Do the actual job */
if(rank == 0) {
MPI_Group* group_snd = xbt_new(MPI_Group, size);
- int* rankmap = xbt_new(int, 2 * size);
+ std::vector<std::pair<int, int>> rankmap;
+ rankmap.reserve(size);
for (int i = 0; i < size; i++) {
if (recvbuf[2 * i] != MPI_UNDEFINED) {
- int count = 0;
+ rankmap.clear();
for (int j = i + 1; j < size; j++) {
if(recvbuf[2 * i] == recvbuf[2 * j]) {
recvbuf[2 * j] = MPI_UNDEFINED;
- rankmap[2 * count] = j;
- rankmap[2 * count + 1] = recvbuf[2 * j + 1];
- count++;
+ rankmap.push_back({recvbuf[2 * j + 1], j});
}
}
/* Add self in the group */
recvbuf[2 * i] = MPI_UNDEFINED;
- rankmap[2 * count] = i;
- rankmap[2 * count + 1] = recvbuf[2 * i + 1];
- count++;
- qsort(rankmap, count, 2 * sizeof(int), &smpi_compare_rankmap);
- group_out = new Group(count);
+ rankmap.push_back({recvbuf[2 * i + 1], i});
+ std::sort(begin(rankmap), end(rankmap));
+ group_out = new Group(rankmap.size());
if (i == 0) {
group_root = group_out; /* Save root's group */
}
- for (int j = 0; j < count; j++) {
- int index = group->index(rankmap[2 * j]);
- group_out->set_mapping(index, j);
+ for (unsigned j = 0; j < rankmap.size(); j++) {
+ ActorPtr actor = group->actor(rankmap[j].second);
+ group_out->set_mapping(actor, j);
}
- MPI_Request* requests = xbt_new(MPI_Request, count);
+ MPI_Request* requests = xbt_new(MPI_Request, rankmap.size());
int reqs = 0;
- for (int j = 0; j < count; j++) {
- if(rankmap[2 * j] != 0) {
+ for (auto const& rank : rankmap) {
+ if (rank.second != 0) {
group_snd[reqs]=new Group(group_out);
- requests[reqs] = Request::isend(&(group_snd[reqs]), 1, MPI_PTR, rankmap[2 * j], system_tag, this);
+ requests[reqs] = Request::isend(&(group_snd[reqs]), 1, MPI_PTR, rank.second, system_tag, this);
reqs++;
}
}
}
}
xbt_free(recvbuf);
- xbt_free(rankmap);
xbt_free(group_snd);
group_out = group_root; /* exit with root's group */
} else {
Comm::unref(intra_comm_);
if (leaders_comm_ != MPI_COMM_NULL)
Comm::unref(leaders_comm_);
- if (non_uniform_map_ != nullptr)
- xbt_free(non_uniform_map_);
- if (leaders_map_ != nullptr)
- xbt_free(leaders_map_);
+ xbt_free(non_uniform_map_);
+ delete[] leaders_map_;
}
void Comm::unref(Comm* comm){
}
}
-static int compare_ints (const void *a, const void *b)
-{
- const int *da = static_cast<const int *>(a);
- const int *db = static_cast<const int *>(b);
-
- return static_cast<int>(*da > *db) - static_cast<int>(*da < *db);
-}
-
void Comm::init_smp(){
int leader = -1;
// tell SimGrid we are not in replay for a while, because we need the buffers to be copied for the following calls
bool replaying = false; //cache data to set it back again after
if(smpi_process()->replaying()){
- replaying=true;
- smpi_process()->set_replaying(false);
+ replaying = true;
+ smpi_process()->set_replaying(false);
}
- if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables
- smpi_switch_data_segment(smpi_process()->index());
- }
+ if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+ // we need to switch as the called function may silently touch global variables
+ smpi_switch_data_segment(simgrid::s4u::Actor::self());
+ }
//identify neighbours in comm
- //get the indexes of all processes sharing the same simix host
- xbt_swag_t process_list = sg_host_self()->extension<simgrid::simix::Host>()->process_list;
- int intra_comm_size = 0;
- int min_index = INT_MAX; // the minimum index will be the leader
- smx_actor_t actor = nullptr;
- xbt_swag_foreach(actor, process_list)
- {
- int index = actor->pid - 1;
-
- if (this->group()->rank(index) != MPI_UNDEFINED) {
- intra_comm_size++;
- // the process is in the comm
- if (index < min_index)
- min_index = index;
- }
+ //get the indices of all processes sharing the same simix host
+ auto& process_list = sg_host_self()->pimpl_->process_list_;
+ int intra_comm_size = 0;
+ int min_index = INT_MAX; // the minimum index will be the leader
+ for (auto& actor : process_list) {
+ int index = actor.pid_;
+ if (this->group()->rank(actor.iface()) != MPI_UNDEFINED) { // Is this process in the current group?
+ intra_comm_size++;
+ if (index < min_index)
+ min_index = index;
+ }
}
XBT_DEBUG("number of processes deployed on my node : %d", intra_comm_size);
MPI_Group group_intra = new Group(intra_comm_size);
int i = 0;
- actor = nullptr;
- xbt_swag_foreach(actor, process_list) {
- int index = actor->pid -1;
- if(this->group()->rank(index)!=MPI_UNDEFINED){
- group_intra->set_mapping(index, i);
+ for (auto& actor : process_list) {
+ if (this->group()->rank(actor.iface()) != MPI_UNDEFINED) {
+ group_intra->set_mapping(actor.iface(), i);
i++;
}
}
- MPI_Comm comm_intra = new Comm(group_intra, nullptr);
+ MPI_Comm comm_intra = new Comm(group_intra, nullptr, 1);
leader=min_index;
- int * leaders_map= static_cast<int*>(xbt_malloc0(sizeof(int)*comm_size));
- int * leader_list= static_cast<int*>(xbt_malloc0(sizeof(int)*comm_size));
- for(i=0; i<comm_size; i++){
- leader_list[i]=-1;
- }
+ int* leaders_map = new int[comm_size];
+ int* leader_list = new int[comm_size];
+ std::fill_n(leaders_map, comm_size, 0);
+ std::fill_n(leader_list, comm_size, -1);
- Coll_allgather_mpich::allgather(&leader, 1, MPI_INT , leaders_map, 1, MPI_INT, this);
+ Coll_allgather_ring::allgather(&leader, 1, MPI_INT , leaders_map, 1, MPI_INT, this);
- if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables
- smpi_switch_data_segment(smpi_process()->index());
- }
+ if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+ // we need to switch as the called function may silently touch global variables
+ smpi_switch_data_segment(simgrid::s4u::Actor::self());
+ }
if(leaders_map_==nullptr){
leaders_map_= leaders_map;
}else{
- xbt_free(leaders_map);
+ delete[] leaders_map;
}
- int j=0;
int leader_group_size = 0;
for(i=0; i<comm_size; i++){
- int already_done=0;
- for(j=0;j<leader_group_size; j++){
- if(leaders_map_[i]==leader_list[j]){
- already_done=1;
- }
- }
- if(already_done==0){
- leader_list[leader_group_size]=leaders_map_[i];
- leader_group_size++;
+ int already_done = 0;
+ for (int j = 0; j < leader_group_size; j++) {
+ if (leaders_map_[i] == leader_list[j]) {
+ already_done = 1;
}
+ }
+ if (already_done == 0) {
+ leader_list[leader_group_size] = leaders_map_[i];
+ leader_group_size++;
+ }
}
- qsort(leader_list, leader_group_size, sizeof(int),compare_ints);
+ std::sort(leader_list, leader_list + leader_group_size);
MPI_Group leaders_group = new Group(leader_group_size);
if(MPI_COMM_WORLD!=MPI_COMM_UNINITIALIZED && this!=MPI_COMM_WORLD){
//create leader_communicator
for (i=0; i< leader_group_size;i++)
- leaders_group->set_mapping(leader_list[i], i);
- leader_comm = new Comm(leaders_group, nullptr);
+ leaders_group->set_mapping(simgrid::s4u::Actor::by_pid(leader_list[i]), i);
+ leader_comm = new Comm(leaders_group, nullptr,1);
this->set_leaders_comm(leader_comm);
this->set_intra_comm(comm_intra);
- //create intracommunicator
+ // create intracommunicator
}else{
for (i=0; i< leader_group_size;i++)
- leaders_group->set_mapping(leader_list[i], i);
+ leaders_group->set_mapping(simgrid::s4u::Actor::by_pid(leader_list[i]), i);
if(this->get_leaders_comm()==MPI_COMM_NULL){
- leader_comm = new Comm(leaders_group, nullptr);
+ leader_comm = new Comm(leaders_group, nullptr,1);
this->set_leaders_comm(leader_comm);
}else{
leader_comm=this->get_leaders_comm();
if(comm_intra->rank()==0) {
int is_uniform = 1;
int* non_uniform_map = xbt_new0(int,leader_group_size);
- Coll_allgather_mpich::allgather(&my_local_size, 1, MPI_INT,
+ Coll_allgather_ring::allgather(&my_local_size, 1, MPI_INT,
non_uniform_map, 1, MPI_INT, leader_comm);
for(i=0; i < leader_group_size; i++) {
if(non_uniform_map[0] != non_uniform_map[i]) {
}
}
if(is_uniform==0 && this->is_uniform()!=0){
- non_uniform_map_= non_uniform_map;
+ non_uniform_map_ = non_uniform_map;
}else{
- xbt_free(non_uniform_map);
+ xbt_free(non_uniform_map);
}
is_uniform_=is_uniform;
}
- Coll_bcast_mpich::bcast(&(is_uniform_),1, MPI_INT, 0, comm_intra );
+ Coll_bcast_scatter_LR_allgather::bcast(&(is_uniform_),1, MPI_INT, 0, comm_intra );
- if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){ //we need to switch as the called function may silently touch global variables
- smpi_switch_data_segment(smpi_process()->index());
- }
+ if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+ // we need to switch as the called function may silently touch global variables
+ smpi_switch_data_segment(simgrid::s4u::Actor::self());
+ }
// Are the ranks blocked ? = allocated contiguously on the SMP nodes
int is_blocked=1;
- int prev=this->group()->rank(comm_intra->group()->index(0));
- for (i=1; i<my_local_size; i++){
- int that=this->group()->rank(comm_intra->group()->index(i));
- if(that!=prev+1){
- is_blocked=0;
- break;
- }
- prev = that;
+ int prev=this->group()->rank(comm_intra->group()->actor(0));
+ for (i = 1; i < my_local_size; i++) {
+ int that = this->group()->rank(comm_intra->group()->actor(i));
+ if (that != prev + 1) {
+ is_blocked = 0;
+ break;
+ }
+ prev = that;
}
int global_blocked;
if(MPI_COMM_WORLD==MPI_COMM_UNINITIALIZED || this==MPI_COMM_WORLD){
if(this->rank()==0){
- is_blocked_=global_blocked;
+ is_blocked_ = global_blocked;
}
}else{
is_blocked_=global_blocked;
}
- xbt_free(leader_list);
+ delete[] leader_list;
if(replaying)
smpi_process()->set_replaying(true);
} else if(id==0){
return MPI_COMM_WORLD;
} else if(F2C::f2c_lookup() != nullptr && id >= 0) {
- char key[KEY_SIZE];
- MPI_Comm tmp = static_cast<MPI_Comm>(xbt_dict_get_or_null(F2C::f2c_lookup(),get_key_id(key, id)));
- return tmp != nullptr ? tmp : MPI_COMM_NULL ;
+ char key[KEY_SIZE];
+ const auto& lookup = F2C::f2c_lookup();
+ auto comm = lookup->find(get_key_id(key, id));
+ return comm == lookup->end() ? MPI_COMM_NULL : static_cast<MPI_Comm>(comm->second);
} else {
return MPI_COMM_NULL;
}
void Comm::free_f(int id) {
char key[KEY_SIZE];
- xbt_dict_remove(F2C::f2c_lookup(), id==0? get_key(key, id) : get_key_id(key, id));
+ F2C::f2c_lookup()->erase(id == 0 ? get_key(key, id) : get_key_id(key, id));
}
int Comm::add_f() {
if(F2C::f2c_lookup()==nullptr){
- F2C::set_f2c_lookup(xbt_dict_new_homogeneous(nullptr));
+ F2C::set_f2c_lookup(new std::unordered_map<std::string, F2C*>);
}
char key[KEY_SIZE];
- xbt_dict_set(F2C::f2c_lookup(), this==MPI_COMM_WORLD? get_key(key, F2C::f2c_id()) : get_key_id(key,F2C::f2c_id()), this, nullptr);
+ (*(F2C::f2c_lookup()))[this == MPI_COMM_WORLD ? get_key(key, F2C::f2c_id()) : get_key_id(key, F2C::f2c_id())] = this;
f2c_id_increment();
return F2C::f2c_id()-1;
}
-
void Comm::add_rma_win(MPI_Win win){
rma_wins_.push_back(win);
}
}
void Comm::finish_rma_calls(){
- for(auto it : rma_wins_){
+ for (auto const& it : rma_wins_) {
if(it->rank()==this->rank()){//is it ours (for MPI_COMM_WORLD)?
int finished = it->finish_comms();
XBT_DEBUG("Barrier for rank %d - Finished %d RMA calls",this->rank(), finished);
}
}
+MPI_Comm Comm::split_type(int type, int key, MPI_Info info)
+{
+ if(type != MPI_COMM_TYPE_SHARED){
+ return MPI_COMM_NULL;
+ }
+ this->init_smp();
+ this->ref();
+ this->get_intra_comm()->ref();
+ return this->get_intra_comm();
+}
}
}
