Changeset 833 for XIOS/trunk/src/policy.cpp

Timestamp:

04/08/16 15:00:15 (8 years ago)

Author:

mhnguyen

Message:

Improvements for dht

+) Implement adaptive hierarchy for dht, level of hierarchy depends on number of processes
+) Remove some redundant codes

Test
+) On Curie
+) All tests are correct

File:

• XIOS/trunk/src/policy.cpp (modified) (1 diff)

XIOS/trunk/src/policy.cpp

@@ -49 +49 @@
 }
 
+DivideAdaptiveComm::DivideAdaptiveComm(const MPI_Comm& mpiComm)
+  : internalComm_(mpiComm), level_(0), groupBegin_(), nbInGroup_(), computed_(false)
+{
+
 }
 
+void DivideAdaptiveComm::computeMPICommLevel()
+{
+  if (computed_) return;
+  computed_ = true;
+
+  int mpiSize, mpiRank;
+  MPI_Comm_size(internalComm_,&mpiSize);
+  MPI_Comm_rank(internalComm_,&mpiRank);
+
+  int maxChild=1;
+  int m;
+  do
+  {
+    m=1;
+    ++maxChild;
+    for(int i=0;i<maxChild;++i) m *= maxChild;
+   } while(m<mpiSize);
+
+  int maxLevel=0;
+  for(int size=1; size<=mpiSize; size*=maxChild) ++maxLevel;
+
+  int pos, n, idx;
+  level_=0;
+  int begin=0;
+  int end=mpiSize-1;
+  int nb=end-begin+1;
+
+  nbInGroup_ = groupBegin_= std::vector<int>(maxLevel);
+  nbInGroupParents_ = groupParentsBegin_= std::vector<std::vector<int> >(maxLevel,std::vector<int>(maxChild));
+
+  groupBegin_[level_] = begin;
+  nbInGroup_[level_] = nb;
+  ++level_;
+  while (nb>2 && (level_<maxLevel))
+  {
+    n = 0; idx = 0;
+    pos = begin;
+    for(int i=0;i<maxChild && i<nb;i++)
+    {
+      if (i<nb%maxChild) n = nb/maxChild + 1;
+      else n = nb/maxChild;
+
+      if (mpiRank>=pos && mpiRank<pos+n)
+      {
+        begin=pos;
+        end=pos+n-1;
+      }
+      groupParentsBegin_[level_-1][idx] = pos;
+      nbInGroupParents_[level_-1][idx] = n;
+      ++idx;
+      pos=pos+n;
+    }
+    groupBegin_[level_] = begin;
+    nbInGroup_[level_] = nb = end-begin+1;
+
+    ++level_;
+  }
+
+  for (int i = 0; i < nbInGroup_[level_-1];++i)
+  {
+    groupParentsBegin_[level_-1][i] = groupBegin_[level_-1]+i;
+    nbInGroupParents_[level_-1][i] = 1;
+  }
+
+
+
+//  parent=vector<int>(maxLevel+1);
+//  child=vector<vector<int> >(maxLevel+1,vector<int>(maxChild));
+//  nbChild=vector<int> (maxLevel+1);
+
+//  do
+//  {
+//    n=0;
+//    pos=begin;
+//    nbChild[level_]=0;
+//    parent[level_+1]=begin;
+//    for(int i=0;i<maxChild && i<nb;i++)
+//    {
+//      if (i<nb%maxChild) n = nb/maxChild + 1;
+//      else n = nb/maxChild;
+//
+//      if (mpiRank>=pos && mpiRank<pos+n)
+//      {
+//        begin=pos;
+//        end=pos+n-1;
+//      }
+//      child[level_][i]=pos;
+//      pos=pos+n;
+//      nbChild[level_]++;
+//    }
+//    nb=end-begin+1;
+//    level_=level_+1;
+//  } while (nb>1);
+}
+
+//void DivideAdaptiveComm::divideMPICommLevel(const MPI_Comm& mpiCommLevel, int color, int level)
+//{
+////  int clientRank;
+////  MPI_Comm_rank(mpiCommLevel,&clientRank);
+//
+//   --level;
+//  if (0 < level)
+//  {
+//   int color = clientRank % 2;
+//   commLevel_.push_back(MPI_Comm());
+//   MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back()));
+//   divideMPICommLevel(commLevel_.back(), level);
+//  }
+//}
+
+
+}
+