X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/345b6916a63cb79022342c2445d0f883ae0dfc5c..583ac005306d3eab67133d1301bfd5001745ffa6:/src/smpi/mpi/smpi_comm.cpp

diff --git a/src/smpi/mpi/smpi_comm.cpp b/src/smpi/mpi/smpi_comm.cpp
index b3dd93f9bc..9efc299921 100644
--- a/src/smpi/mpi/smpi_comm.cpp
+++ b/src/smpi/mpi/smpi_comm.cpp
@@ -4,7 +4,6 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "smpi_comm.hpp"
-#include "private.h"
 #include "private.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "smpi_coll.hpp"
@@ -13,14 +12,14 @@
 #include "smpi_request.hpp"
 #include "smpi_status.hpp"
 #include "smpi_win.hpp"
-#include "src/simix/smx_private.h"
+#include "src/simix/smx_private.hpp"
 #include <algorithm>
 #include <climits>
 #include <vector>
 
 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;
 
 /* Support for cartesian topology was added, but there are 2 other types of topology, graph et dist graph. In order to
@@ -34,14 +33,14 @@ int Comm::keyval_id_=0;
 
 Comm::Comm(MPI_Group group, MPI_Topology topo) : group_(group), topo_(topo)
 {
-  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)
@@ -56,16 +55,16 @@ 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());
-   }
+    smpi_switch_data_segment(smpi_process()->index());
+  }
   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()){
+    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);
@@ -79,8 +78,8 @@ int Comm::dup(MPI_Comm* newcomm){
           (*newcomm)->attributes()->insert({it.first, value_out});
         }
       }
-      }
     }
+  }
   return ret;
 }
 
@@ -222,7 +221,7 @@ MPI_Comm Comm::split(int color, int key)
         }
         MPI_Request* requests = xbt_new(MPI_Request, rankmap.size());
         int reqs              = 0;
-        for (const auto& rank : rankmap) {
+        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, rank.second, system_tag, this);
@@ -264,7 +263,7 @@ void Comm::cleanup_smp(){
   if (non_uniform_map_ != nullptr)
     xbt_free(non_uniform_map_);
   if (leaders_map_ != nullptr)
-    xbt_free(leaders_map_);
+    delete[] leaders_map_;
 }
 
 void Comm::unref(Comm* comm){
@@ -294,36 +293,32 @@ void Comm::init_smp(){
   // 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());
-   }
+    smpi_switch_data_segment(smpi_process()->index());
+  }
   //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;
-     }
+  const auto& 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
+  for (auto const& 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;
+    }
   }
   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;
+  for (auto const& actor : process_list) {
+    int index = actor.pid - 1;
     if(this->group()->rank(index)!=MPI_UNDEFINED){
       group_intra->set_mapping(index, i);
       i++;
@@ -333,36 +328,34 @@ void Comm::init_smp(){
   MPI_Comm comm_intra = new  Comm(group_intra, nullptr);
   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);
 
   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());
-   }
+    smpi_switch_data_segment(smpi_process()->index());
+  }
 
   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++;
+    }
   }
   std::sort(leader_list, leader_list + leader_group_size);
 
@@ -377,7 +370,7 @@ void Comm::init_smp(){
     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);
@@ -406,27 +399,27 @@ void Comm::init_smp(){
       }
     }
     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 );
 
   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());
-   }
+    smpi_switch_data_segment(smpi_process()->index());
+  }
   // 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;
+  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 global_blocked;
@@ -434,12 +427,12 @@ void Comm::init_smp(){
 
   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);
@@ -451,9 +444,10 @@ MPI_Comm Comm::f2c(int id) {
   } 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;
   }
@@ -461,20 +455,19 @@ MPI_Comm Comm::f2c(int id) {
 
 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);
 }
@@ -484,7 +477,7 @@ void Comm::remove_rma_win(MPI_Win 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);
@@ -492,7 +485,6 @@ void Comm::finish_rma_calls(){
   }
 }
 
-
 }
 }