Changeset 842 for XIOS

Timestamp:

04/26/16 16:03:58 (8 years ago)

Author:

mhnguyen

Message:

Small improvements on transformation mapping

+) Remove complex structure of transformation mapping by a simpler one

Test
+) On Curie
+) All tests pass

Location:

XIOS/trunk/src

Files:

• filter/spatial_transform_filter.cpp (modified) (1 diff)
• transformation/axis_algorithm_inverse.cpp (modified) (1 diff)
• transformation/grid_transformation.cpp (modified) (1 diff)
• transformation/grid_transformation.hpp (modified) (1 diff)
• transformation/transformation_mapping.cpp (modified) (6 diffs)
• transformation/transformation_mapping.hpp (modified) (1 diff)

XIOS/trunk/src/filter/spatial_transform_filter.cpp

@@ -169 +169 @@
       {
         int countSize = itRecv->second.size();
+        const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second;
         for (int idx = 0; idx < countSize; ++idx)
         {
-          const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second[idx];
-          int numIndex = localIndex_p.size();
-          for (int i = 0; i < numIndex; ++i)
-          {
-            dataCurrentDest(localIndex_p[i].first) += *(recvBuff+currentBuff+idx) * localIndex_p[i].second;
-          }
+          dataCurrentDest(localIndex_p[idx].first) += *(recvBuff+currentBuff+idx) * localIndex_p[idx].second;
         }
         currentBuff += countSize;

XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

@@ -139 +139 @@
    for (int idx = 0; idx < countSize; ++idx, ++currentRecvBuff)
    {
-     int ssize = (itRecv->second)[idx].size();
-     for (int i = 0; i < ssize; ++i)
-     {
-       int index = ((itRecv->second)[idx][i]).first - ibeginDest;
-       (axisDest_->value)(index) = *currentRecvBuff;
-     }
+     int index = ((itRecv->second)[idx]).localIndex - ibeginDest;
+     (axisDest_->value)(index) = *currentRecvBuff;
+//     int ssize = (itRecv->second)[idx].size();
+//     for (int i = 0; i < ssize; ++i)
+//     {
+//       int index = ((itRecv->second)[idx][i]).first - ibeginDest;
+//       (axisDest_->value)(index) = *currentRecvBuff;
+//     }
    }
  }

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -450 +450 @@
     for (int i = 0; i < numGlobalIndex; ++i)
     {
-      int vecSize = ((itMapRecv->second)[i]).size();
-      for (int idx = 0; idx < vecSize; ++idx)
-      {
-        const std::pair<int, std::pair<size_t,double> >& tmpPair = (itMapRecv->second)[i][idx];
-        recvTmp[sourceRank][i].push_back(make_pair(tmpPair.first, tmpPair.second.second));
-      }
+      recvTmp[sourceRank][i] = make_pair((itMapRecv->second)[i].localIndex,(itMapRecv->second)[i].weight);
     }
   }

XIOS/trunk/src/transformation/grid_transformation.hpp

@@ -38 +38 @@
   typedef boost::unordered_map<size_t, std::vector<std::pair<int, std::pair<size_t,double> > > > DestinationIndexMap;
   typedef std::map<int, CArray<int,1> > SendingIndexGridSourceMap;
-  typedef std::map<int,std::vector<std::vector<std::pair<int,double> > > > RecvIndexGridDestinationMap;
+  typedef std::map<int,std::vector<std::pair<int,double> > > RecvIndexGridDestinationMap;
+//  typedef std::map<int,std::vector<std::vector<std::pair<int,double> > > > RecvIndexGridDestinationMap;
 
 public:

XIOS/trunk/src/transformation/transformation_mapping.cpp

@@ -89 +89 @@
   // Not only one index on grid destination can demande two indexes from grid source
   // but an index on grid source has to be sent to two indexes of grid destination
-  DestinationIndexMap globalIndexMapFromSrcToDest;
-  boost::unordered_map<size_t, int> nbGlobalIndexMapFromSrcToDest;
+  size_t nbGlobalIndexSrc = 0;
+  for (itMap = itbMap; itMap != iteMap; ++itMap)
+  {
+    nbGlobalIndexSrc += (itMap->second).size();
+  }
+
+  CArray<size_t,1> globalIndexMap(nbGlobalIndexSrc);
   std::vector<std::pair<int, std::pair<size_t,double> > >::const_iterator itbVecPair, itVecPair, iteVecPair;
+  size_t idxSrc = 0;
   for (itMap = itbMap; itMap != iteMap; ++itMap)
   {
@@ -98 +104 @@
     for (itVecPair = itbVecPair; itVecPair != iteVecPair; ++itVecPair)
     {
-      ++nbGlobalIndexMapFromSrcToDest[(itVecPair->second).first];
-    }
-  }
-
-  for (boost::unordered_map<size_t, int>::const_iterator it = nbGlobalIndexMapFromSrcToDest.begin();
-                                                         it != nbGlobalIndexMapFromSrcToDest.end(); ++it)
-  {
-    globalIndexMapFromSrcToDest[it->first].reserve(it->second);
-  }
-
-  for (itMap = itbMap; itMap != iteMap; ++itMap)
-  {
-    itbVecPair = (itMap->second).begin();
-    iteVecPair = (itMap->second).end();
-    for (itVecPair = itbVecPair; itVecPair != iteVecPair; ++itVecPair)
-    {
-      globalIndexMapFromSrcToDest[(itVecPair->second).first].push_back(std::make_pair(itVecPair->first, std::make_pair(itMap->first, (itVecPair->second).second)));
-    }
-  }
-
-  // All global indexes of a client on grid destination
-  CArray<size_t,1> globalIndexMap(globalIndexMapFromSrcToDest.size());
-  DestinationIndexMap::const_iterator itbMapBoost = globalIndexMapFromSrcToDest.begin(), itMapBoost;
-  DestinationIndexMap::const_iterator iteMapBoost = globalIndexMapFromSrcToDest.end();
-  int idx = 0;
-  for (itMapBoost = itbMapBoost; itMapBoost != iteMapBoost; ++itMapBoost)
-  {
-    globalIndexMap(idx) = itMapBoost->first;
-    ++idx;
+      globalIndexMap(idxSrc) = itVecPair->second.first;
+      ++idxSrc;
+    }
   }
 
@@ -134 +114 @@
   CClientClientDHTPairIntInt::Index2InfoTypeMap::const_iterator itbMapSrc = globalIndexSentFromGridSource.begin(), itMapSrc,
                                                                 iteMapSrc = globalIndexSentFromGridSource.end();
-  std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
-    // Inform client about the destination to which it needs to send global indexes
+  size_t currentIndexSrc;
   int nbClient = client->clientSize;
+  std::vector<int> nbIndexEachClient(nbClient,0);
   std::vector<int> sendNbClientBuff(nbClient,0);
+  for (idxSrc = 0; idxSrc < nbGlobalIndexSrc; ++idxSrc)
+  {
+    currentIndexSrc = globalIndexMap(idxSrc);
+    itMapSrc = globalIndexSentFromGridSource.find(currentIndexSrc);
+    if (iteMapSrc != itMapSrc)
+    {
+      ++nbIndexEachClient[itMapSrc->second.first];
+    }
+  }
+
+  boost::unordered_map<int,size_t* > sendIndexMap;
+  for (int idx = 0; idx < nbClient; ++idx)
+  {
+    if (0 != nbIndexEachClient[idx])
+    {
+      globalIndexReceivedOnGridDestMapping_[idx].resize(nbIndexEachClient[idx]);
+      sendIndexMap[idx] = new unsigned long [2*nbIndexEachClient[idx]];
+      nbIndexEachClient[idx] = 0;
+      sendNbClientBuff[idx] = 1;
+    }
+  }
+
+  int srcRank;
+  for (itMap = itbMap; itMap != iteMap; ++itMap)
+  {
+    itbVecPair = (itMap->second).begin();
+    iteVecPair = (itMap->second).end();
+    for (itVecPair = itbVecPair; itVecPair != iteVecPair; ++itVecPair)
+    {
+      currentIndexSrc = itVecPair->second.first;
+      itMapSrc = globalIndexSentFromGridSource.find(currentIndexSrc);
+      if (iteMapSrc != itMapSrc)
+      {
+        srcRank = (itMapSrc->second).first;
+        int& ind = nbIndexEachClient[srcRank];
+        globalIndexReceivedOnGridDestMapping_[srcRank][ind] = ReceivedIndex(itVecPair->first, itMap->first, itVecPair->second.second);
+        sendIndexMap[srcRank][2*ind] = (itMapSrc->second).second;
+        sendIndexMap[srcRank][2*ind+1] = itMapSrc->first;
+        ++ind;
+      }
+    }
+  }
+
   std::vector<int> recvNbClientBuff(nbClient,0);
-  std::vector<int> sendIndexBuff(nbClient,0);
-  std::vector<int> recvIndexBuff(nbClient,0);
-  boost::unordered_map<int,std::vector<size_t> > sendIndexMap;
-  for (itMapSrc = itbMapSrc; itMapSrc != iteMapSrc; ++itMapSrc)
-  {
-    int sourceRank = (itMapSrc->second).first;
-    (globalIndexReceivedOnGridDestMapping_[sourceRank]).push_back(globalIndexMapFromSrcToDest[itMapSrc->first]);
-    sendIndexMap[sourceRank].push_back((itMapSrc->second).second);
-    sendIndexMap[sourceRank].push_back(itMapSrc->first);
-    sendNbClientBuff[sourceRank] = 1;
-    ++sendIndexBuff[sourceRank];
-  }
-
   MPI_Allreduce(&sendNbClientBuff[0], &recvNbClientBuff[0], nbClient, MPI_INT, MPI_SUM, client->intraComm);
   int numClientToReceive = recvNbClientBuff[client->clientRank];
 
   // Then specify the size of receiving buffer, because we use synch send/receive so only necessary to know maximum size
-  MPI_Allreduce(&sendIndexBuff[0], &recvIndexBuff[0], nbClient, MPI_INT, MPI_MAX, client->intraComm);
+  std::vector<int> recvIndexBuff(nbClient,0);
+  MPI_Allreduce(&nbIndexEachClient[0], &recvIndexBuff[0], nbClient, MPI_INT, MPI_MAX, client->intraComm);
+  std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
+
   int buffSize = 2*recvIndexBuff[client->clientRank]; // we send global as well as local index
   unsigned long* recvBuffGlobalIndex;
@@ -164 +177 @@
 
   // Inform all "source clients" about index that they need to send
-  boost::unordered_map<int,std::vector<size_t> >::const_iterator itSendIndex = sendIndexMap.begin(),
-                                                                 iteSendIndex= sendIndexMap.end();
+  boost::unordered_map<int,size_t* >::const_iterator itSendIndex = sendIndexMap.begin(),
+                                                     iteSendIndex= sendIndexMap.end();
   for (; itSendIndex != iteSendIndex; ++itSendIndex)
   {
-    unsigned long* sendPtr = const_cast<unsigned long*>(&(itSendIndex->second)[0]);
-    MPI_Isend(sendPtr,
-              (itSendIndex->second).size(),
+    MPI_Isend((itSendIndex->second),
+              2*nbIndexEachClient[itSendIndex->first],
               MPI_UNSIGNED_LONG,
               (itSendIndex->first),
@@ -194 +206 @@
     MPI_Get_count(&status, MPI_UNSIGNED_LONG, &countBuff);
     int clientDestRank = status.MPI_SOURCE;
-    for (int idx = 0; idx < countBuff; idx += 2)
-    {
-      globalIndexSendToGridDestMapping_[clientDestRank].push_back(std::make_pair<int,size_t>(recvBuffGlobalIndex[idx], recvBuffGlobalIndex[idx+1]));
+    int sizeMap = countBuff/2;
+    globalIndexSendToGridDestMapping_[clientDestRank].resize(sizeMap);
+    for (int idx = 0, i = 0; idx < countBuff; idx += 2, ++i)
+    {
+      globalIndexSendToGridDestMapping_[clientDestRank][i].first = recvBuffGlobalIndex[idx];
+      globalIndexSendToGridDestMapping_[clientDestRank][i].second = recvBuffGlobalIndex[idx+1];
     }
     ++numClientReceived;
@@ -206 +221 @@
 
   if (0 != buffSize) delete [] recvBuffGlobalIndex;
+  for (itSendIndex = sendIndexMap.begin(); itSendIndex != iteSendIndex; ++itSendIndex)
+    delete [] itSendIndex->second;
 }
 

XIOS/trunk/src/transformation/transformation_mapping.hpp

@@ -29 +29 @@
 public:
   typedef boost::unordered_map<size_t, std::vector<std::pair<int, std::pair<size_t,double> > > > DestinationIndexMap;
-  typedef boost::unordered_map<int,std::vector<std::vector<std::pair<int, std::pair<size_t,double> > > > > ReceivedIndexMap;
+  struct ReceivedIndex {
+    ReceivedIndex(int l, size_t g, double w) : localIndex(l),globalIndex(g), weight(w) {}
+    ReceivedIndex() : localIndex(0), globalIndex(0), weight(0.0) {}
+    int localIndex;
+    size_t globalIndex;
+    double weight;
+  };
+
+  typedef boost::unordered_map<int,std::vector<ReceivedIndex> > ReceivedIndexMap;
   typedef boost::unordered_map<int,std::vector<std::pair<int, size_t> > > SentIndexMap;