Changeset 924 for XIOS/trunk/src/dht_auto_indexing.cpp

Timestamp:

09/02/16 09:41:27 (8 years ago)

Author:

oabramkina

Message:

Parallel version of UGRID norms.

The following connectivity parameters have been implemented:

edge_nodes
face_nodes
face_edges
edge_faces
face_faces.

Test with a regular(structured) quadrilateral mesh (test_regular) has been added.

File:

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

XIOS/trunk/src/dht_auto_indexing.cpp

@@ -12 +12 @@
 {
 
-/*!
-  Constructor with initial distribution information and the corresponding index
-  Each process holds a piece of hash value, which has no information (global index) associated.
-The constructor tries to assign this information to each process basing on their rank.
-The global index (information) are assigned across processes in the incremental manner.
-The process has lower rank will have low global index.
-  \param [in] hashValue Carray contains hash value
-  \param [in] clientIntraComm communicator of clients
-*/
+  CDHTAutoIndexing::~CDHTAutoIndexing()
+  {
+  }
 
-CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
-                                   const MPI_Comm& clientIntraComm)
-  : CClientClientDHTTemplate<size_t>(clientIntraComm)
-{
-  Index2VectorInfoTypeMap indexToVecInfoMap;
-  indexToVecInfoMap.rehash(std::ceil(hashValue.size()/indexToVecInfoMap.max_load_factor()));
-  CArray<size_t,1>::const_iterator it = hashValue.begin(), ite = hashValue.end();
+  /*!
+    \param [in]
+    \param [in]
+  */
 
-  // Just use a dummy value to initialize
-  int nbLvl = this->getNbLevel();
-  for (; it != ite; ++it)
+  CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue,
+                                     const MPI_Comm& clientIntraComm)
+    : CClientClientDHTTemplate<size_t>(clientIntraComm)
   {
-    indexToVecInfoMap[*it].resize(1);
-    indexToVecInfoMap[*it][0] = 0;
+
+    nbIndexOnProc_ = hashValue.size();
+    size_t nbIndexAccum;
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
+
+    // Broadcasting the total number of indexes
+    int rank, size;
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
+    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
+
+    CArray<size_t,1>::const_iterator itbIdx = hashValue.begin(), itIdx,
+                                     iteIdx = hashValue.end();
+
+    size_t idx = 0;
+    beginIndexOnProc_ = nbIndexAccum - nbIndexOnProc_;
+    globalIndex_.resize(nbIndexOnProc_);
+    for (itIdx = itbIdx; itIdx != iteIdx; ++itIdx)
+    {
+      globalIndex_[idx] = beginIndexOnProc_ + idx;
+      ++idx ;
+    }
   }
-  computeDistributedIndex(indexToVecInfoMap, clientIntraComm, nbLvl-1);
 
-  // Find out number of index on other proc
-  size_t nbIndexOnProc = index2InfoMapping_.size();
-  size_t nbIndexAccum;
+  /*!
+   * \fn void CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, const MPI_Comm& clientIntraComm)
+   * Assigns a global index to unique input indexes.
+   * The returned map has unique indexes as a key and global indexes as a mapped value.
+   * \param [in] hashInitMap map<size_t, vector<size_t>> is a map of unique indexes.
+   * \param [in] clientIntraComm
+  */
+  CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap,
+                                     const MPI_Comm& clientIntraComm)
+    : CClientClientDHTTemplate<size_t>(clientIntraComm)
+  {
 
-  MPI_Scan(&nbIndexOnProc, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
+    nbIndexOnProc_ = hashInitMap.size();
+    size_t nbIndexAccum;
+    MPI_Scan(&nbIndexOnProc_, &nbIndexAccum, 1, MPI_UNSIGNED_LONG, MPI_SUM, clientIntraComm);
 
-  Index2VectorInfoTypeMap::iterator itbIdx = index2InfoMapping_.begin(), itIdx,
-                                    iteIdx = index2InfoMapping_.end();
-  size_t idx = 0;
-  size_t idxBegin = nbIndexAccum - nbIndexOnProc;
-  for (itIdx = itbIdx; itIdx != iteIdx; ++itIdx)
+    int rank, size;
+    MPI_Comm_rank(clientIntraComm, &rank);
+    MPI_Comm_size(clientIntraComm, &size);
+    if (rank == (size-1)) nbIndexesGlobal_ = nbIndexAccum;
+    MPI_Bcast(&nbIndexesGlobal_, 1, MPI_UNSIGNED_LONG, size-1, clientIntraComm);
+
+    Index2VectorInfoTypeMap::iterator itbIdx = hashInitMap.begin(), itIdx,
+                                      iteIdx = hashInitMap.end();
+    size_t idx = 0;
+    beginIndexOnProc_ = nbIndexAccum - nbIndexOnProc_;
+    globalIndex_.resize(nbIndexOnProc_);
+    for (itIdx = itbIdx; itIdx != iteIdx; ++itIdx)
+    {
+      (itIdx->second)[0] = beginIndexOnProc_ + idx;
+      globalIndex_[idx] = beginIndexOnProc_ + idx;
+      ++idx ;
+    }
+  }
+
+  /*!
+   * \fn size_t CDHTAutoIndexing::getNbIndexesGlobal() const
+   * Returns the total number of global indexes.
+  */
+  size_t CDHTAutoIndexing::getNbIndexesGlobal() const
   {
-    (itIdx->second)[0] = idxBegin + idx;
-    ++idx ;
+    return nbIndexesGlobal_;
   }
-}
+
+  /*!
+   * \fn size_t CDHTAutoIndexing::getIndexStart() const
+   * Returns the starting global index for a proc.
+  */
+  size_t CDHTAutoIndexing::getIndexStart() const
+  {
+    return beginIndexOnProc_;
+  }
+
+  /*!
+   * \fn size_t CDHTAutoIndexing::getIndexCount() const
+   * Returns the number of global indexes on a proc.
+  */
+  size_t CDHTAutoIndexing::getIndexCount() const
+  {
+    return nbIndexOnProc_;
+  }
 
 }