Changeset 831 for XIOS/trunk/src/transformation

Timestamp:

03/23/16 16:11:09 (8 years ago)

Author:

mhnguyen

Message:

Cleaning up some redundant coeds and making some improvements

+) Remove some XIOS Search to make code run faster
+) Remove some commented codes

Test
+) On Curie
+) All tests pass

Location:

XIOS/trunk/src/transformation

Files:

• axis_algorithm_interpolate.cpp (modified) (4 diffs)
• generic_algorithm_transformation.cpp (modified) (4 diffs)
• generic_algorithm_transformation.hpp (modified) (1 diff)
• grid_transformation.cpp (modified) (8 diffs)
• transformation_mapping.cpp (modified) (1 diff)

XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

@@ -28 +28 @@
     this->idAuxInputs_[0] = coordinate_;
   }
-
-//  computeIndexSourceMapping();
 }
 
@@ -282 +280 @@
     this->transformationPosition_.resize(vecAxisValueSize);
 
-    const std::vector<size_t>& globalIndexSendToServer = grid->getDistributionClient()->getGlobalDataIndexSendToServer();
-    const std::vector<int>& localDataSendToServer = grid->getDistributionClient()->getLocalDataIndexSendToServer();
-    std::vector<int> permutIndex(globalIndexSendToServer.size());
-    std::vector<int>::iterator itVec;
-    XIOSAlgorithms::fillInIndex(globalIndexSendToServer.size(), permutIndex);
-    XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(globalIndexSendToServer, permutIndex);
+    const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = grid->getDistributionClient()->getGlobalLocalDataSendToServer();
+    CDistributionClient::GlobalLocalDataMap::const_iterator itIndex, iteIndex = globalLocalIndexSendToServer.end();
     size_t axisSrcSize = axisSrc_->index.numElements();
     std::vector<int> globalDimension = grid->getGlobalDimension();
-    XIOSBinarySearchWithIndex<size_t> binSearch(globalIndexSendToServer);
+
     for (size_t idx = 0; idx < vecAxisValueSize; ++idx)
     {
@@ -297 +291 @@
       {
         size_t globalIndex = ((dom->i_index)(idx) + (dom->j_index)(idx)*globalDimension[0]) + (axisSrc_->index)(jdx)*globalDimension[0]*globalDimension[1];
-        if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndex, itVec))
+        if (iteIndex != globalLocalIndexSendToServer.find(globalIndex))
         {
           ++axisValueSize;
@@ -308 +302 @@
       {
         size_t globalIndex = ((dom->i_index)(idx) + (dom->j_index)(idx)*globalDimension[0]) + (axisSrc_->index)(jdx)*globalDimension[0]*globalDimension[1];
-        if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndex, itVec))
+        itIndex = globalLocalIndexSendToServer.find(globalIndex);
+        if (iteIndex != itIndex)
         {
-          vecAxisValue[idx](axisValueSize) = (*dataAuxInputs[0])(localDataSendToServer[*itVec]);
+          vecAxisValue[idx](axisValueSize) = (*dataAuxInputs[0])(itIndex->second);
           ++axisValueSize;
         }

XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

@@ -22 +22 @@
   \param[in] gridDestGlobalDim global size of each dimension of grid source (all dimension must have the same size except of the one on which transformation is performed)
   \param[in] gridSrcGlobalDim dimension size of source grid (it should share the same size for all dimension, maybe except the domain on which transformation is performed)
-  \param[in] globalIndexGridDestSendToServer global index of grid destination on the current client to send to server
-  \param[in] localIndexGridSendToServer local index of grid destination on the current client to send to server
+  \param[in] globalLocalIndexGridDestSendToServer global and local index mapping of grid destination on the current client to send to server
   \param[in/out] globaIndexWeightFromDestToSource mapping between transformed global index of grid destination
              and the weighted value as well as global index from grid index source
 */
 void CGenericAlgorithmTransformation::computeGlobalSourceIndex(int elementPositionInGrid,
-                                                             const std::vector<int>& gridDestGlobalDim,
-                                                             const std::vector<int>& gridSrcGlobalDim,
-                                                             const std::vector<size_t>& globalIndexGridDestSendToServer,
-                                                             const std::vector<int>& localIndexGridSendToServer,
-                                                             DestinationIndexMap& globaIndexWeightFromDestToSource)
+                                                               const std::vector<int>& gridDestGlobalDim,
+                                                               const std::vector<int>& gridSrcGlobalDim,
+                                                               const GlobalLocalMap& globalLocalIndexGridDestSendToServer,
+                                                               DestinationIndexMap& globaIndexWeightFromDestToSource)
 {
   bool isTransPosEmpty = transformationPosition_.empty();
-  boost::unordered_map<size_t,int> globalLocalIndexDestSendToServerMap;
-  size_t nbGlobalIndexDest = globalIndexGridDestSendToServer.size();
-  for (size_t idx = 0; idx < nbGlobalIndexDest; ++idx)
-  {
-    globalLocalIndexDestSendToServerMap[globalIndexGridDestSendToServer[idx]] = localIndexGridSendToServer[idx];
-  }
-
   for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans)
   {
@@ -61 +52 @@
     for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight)
     {
-      boost::unordered_map<size_t,int> globalLocalIndexDestMap;
       if (!isTransPosEmpty)
       {
@@ -70 +60 @@
                                                            gridDestGlobalDim,
                                                            gridSrcGlobalDim,
-                                                           globalLocalIndexDestSendToServerMap,
+                                                           globalLocalIndexGridDestSendToServer,
                                                            globalLocalIndexDest,
                                                            globalIndexSrcGrid);
@@ -83 +73 @@
                                                            gridDestGlobalDim,
                                                            gridSrcGlobalDim,
-                                                           globalLocalIndexDestSendToServerMap,
+                                                           globalLocalIndexGridDestSendToServer,
                                                            globalLocalIndexDest,
                                                            globalIndexSrcGrid);

XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

@@ -36 +36 @@
                                 const std::vector<int>& gridDestGlobalDim,
                                 const std::vector<int>& gridSrcGlobalDim,
-                                const std::vector<size_t>& globalIndexGridDestSendToServer,
-                                const std::vector<int>& localIndexGridSendToServer,
+                                const GlobalLocalMap& globalLocalIndexGridDestSendToServer,
                                 DestinationIndexMap& globaIndexWeightFromDestToSource);
 

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -392 +392 @@
       // Recalculate the distribution of grid destination
       CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
-      const std::vector<size_t>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
-      const std::vector<int>& localIndexGridDestSendToServer = distributionClientDest.getLocalDataIndexSendToServer();
+      const CDistributionClient::GlobalLocalDataMap& globalLocalIndexGridDestSendToServer = distributionClientDest.getGlobalLocalDataSendToServer();
 
       // ComputeTransformation of global index of each element
@@ -402 +401 @@
                                      gridDestinationDimensionSize,
                                      gridSrcDimensionSize,
-                                     globalIndexGridDestSendToServer,
-                                     localIndexGridDestSendToServer,
+                                     globalLocalIndexGridDestSendToServer,
                                      globaIndexWeightFromDestToSource);
 
@@ -443 +441 @@
   CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
   const std::vector<int>& localMaskIndexOnClientDest = distributionClientDest.getLocalMaskIndexOnClient();
-  const std::vector<size_t>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer();
-
-  std::vector<size_t>::const_iterator itbArr, itArr, iteArr;
+  const CDistributionClient::GlobalLocalDataMap& globalIndexOnClientDest = distributionClientDest.getGlobalLocalDataSendToServer();
+
+  CDistributionClient::GlobalLocalDataMap::const_iterator itbArr, itArr, iteArr;
   itbArr = globalIndexOnClientDest.begin();
   iteArr = globalIndexOnClientDest.end();
@@ -454 +452 @@
   for (itArr = itbArr; itArr != iteArr; ++itArr)
   {
-    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(*itArr))
-    {
-      const std::vector<std::pair<int, std::pair<size_t,double> > >& vecIndex = currentGridIndexToOriginalGridIndex_[*itArr];
+    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(itArr->first))
+    {
+      const std::vector<std::pair<int, std::pair<size_t,double> > >& vecIndex = currentGridIndexToOriginalGridIndex_[itArr->first];
       for (int idx = 0; idx < vecIndex.size(); ++idx)
       {
@@ -472 +470 @@
   for (itArr = itbArr; itArr != iteArr; ++itArr)
   {
-    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(*itArr))
-    {
-      const std::vector<std::pair<int, std::pair<size_t,double> > >& vecIndex = currentGridIndexToOriginalGridIndex_[*itArr];
+    if (iteGlobalMap != currentGridIndexToOriginalGridIndex_.find(itArr->first))
+    {
+      const std::vector<std::pair<int, std::pair<size_t,double> > >& vecIndex = currentGridIndexToOriginalGridIndex_[itArr->first];
       for (int idx = 0; idx < vecIndex.size(); ++idx)
       {
@@ -731 +729 @@
 
   const CTransformationMapping::ReceivedIndexMap& globalIndexToReceive = transformationMap.getGlobalIndexReceivedOnGridDestMapping();
-  const CTransformationMapping::SentIndexMap& globalIndexToSend = transformationMap.getGlobalIndexSendToGridDestMapping();
-
-//  CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
-//  CDistributionClient distributionClientSrc(client->clientRank, originalGridSource_);
-//
-//  const std::vector<size_t>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer();
-//  const std::vector<size_t>& globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer();
-
-//  std::vector<size_t>::const_iterator itbArr, itArr, iteArr;
-//  std::vector<int>::const_iterator itIndex, itbIndex, iteIndex;
   CTransformationMapping::ReceivedIndexMap::const_iterator itbMapRecv, itMapRecv, iteMapRecv;
-
-//  std::vector<int> permutIndex;
-//  typedef XIOSBinarySearchWithIndex<size_t> BinarySearch;
-//
-//  // Find out local index on grid destination (received)
-//  XIOSAlgorithms::fillInIndex(globalIndexOnClientDest.size(), permutIndex);
-//  XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(globalIndexOnClientDest, permutIndex);
-//  itbIndex = permutIndex.begin();
-//  iteIndex = permutIndex.end();
-//  BinarySearch searchClientDest(globalIndexOnClientDest);
   itbMapRecv = globalIndexToReceive.begin();
   iteMapRecv = globalIndexToReceive.end();
@@ -762 +740 @@
     {
       int vecSize = ((itMapRecv->second)[i]).size();
-//      std::vector<std::pair<int,double> > tmpVec;
       for (int idx = 0; idx < vecSize; ++idx)
       {
         const std::pair<int, std::pair<size_t,double> >& tmpPair = (itMapRecv->second)[i][idx];
         localIndexToReceiveOnGridDest_[sourceRank][i].push_back(make_pair(tmpPair.first, tmpPair.second.second));
-//        size_t globalIndex = (itMapRecv->second)[i][idx].first;
-//        double weight = (itMapRecv->second)[i][idx].second;
-//        if (searchClientDest.search(itbIndex, iteIndex, globalIndex, itIndex))
-//        {
-//          tmpVec.push_back(make_pair(*itIndex, weight));
-//        }
       }
-//      localIndexToReceiveOnGridDest_[sourceRank][i] = tmpVec;
     }
   }
 
   // Find out local index on grid source (to send)
+  const CTransformationMapping::SentIndexMap& globalIndexToSend = transformationMap.getGlobalIndexSendToGridDestMapping();
   CTransformationMapping::SentIndexMap::const_iterator itbMap, itMap, iteMap;
-//  XIOSAlgorithms::fillInIndex(globalIndexOnClientSrc.size(), permutIndex);
-//  XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(globalIndexOnClientSrc, permutIndex);
-//  itbIndex = permutIndex.begin();
-//  iteIndex = permutIndex.end();
-//  BinarySearch searchClientSrc(globalIndexOnClientSrc);
   itbMap = globalIndexToSend.begin();
   iteMap = globalIndexToSend.end();
@@ -794 +760 @@
     for (int idx = 0; idx < vecSize; ++idx)
     {
-//      if (searchClientSrc.search(itbIndex, iteIndex, itMap->second[idx], itIndex))
-//      {
-        localIndexToSendFromGridSource_[destRank](idx) = itMap->second[idx].first; //*itIndex;
-//      }
+      localIndexToSendFromGridSource_[destRank](idx) = itMap->second[idx].first;
     }
   }

XIOS/trunk/src/transformation/transformation_mapping.cpp

@@ -27 +27 @@
 
   CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
-
-  const std::vector<size_t>& globalIndexGridSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
-  const std::vector<int>& localIndexGridSrc = distributionClientSrc.getLocalDataIndexSendToServer();
+  const CDistributionClient::GlobalLocalDataMap& globalLocalIndexGridSrc = distributionClientSrc.getGlobalLocalDataSendToServer();
+  CDistributionClient::GlobalLocalDataMap::const_iterator itIndex = globalLocalIndexGridSrc.begin(), iteIndex = globalLocalIndexGridSrc.end();
 
   // Mapping of global index and pair containing rank and local index
   CClientClientDHTPairIntInt::Index2InfoTypeMap globalIndexOfServer;
-  int globalIndexSize = globalIndexGridSrc.size();
-  PairIntInt pii;
-  for (int idx = 0; idx < globalIndexSize; ++idx)
-  {
-    pii.first  = clientRank;
-    pii.second = localIndexGridSrc[idx];
-    globalIndexOfServer[globalIndexGridSrc[idx]] = pii; //std::make_pair(clientRank, localIndexGridSrc[idx]);
+  PairIntInt pairIntInt;
+  for (; itIndex != iteIndex; ++itIndex)
+  {
+    pairIntInt.first  = clientRank;
+    pairIntInt.second = itIndex->second;
+    globalIndexOfServer[itIndex->first] = pairIntInt;
   }