Changeset 831

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

Files:

• client_server_mapping.hpp (modified) (3 diffs)
• distribution_client.cpp (modified) (6 diffs)
• distribution_client.hpp (modified) (5 diffs)
• node/grid.cpp (modified) (4 diffs)
• transformation/axis_algorithm_interpolate.cpp (modified) (4 diffs)
• transformation/generic_algorithm_transformation.cpp (modified) (4 diffs)
• transformation/generic_algorithm_transformation.hpp (modified) (1 diff)
• transformation/grid_transformation.cpp (modified) (8 diffs)
• transformation/transformation_mapping.cpp (modified) (1 diff)

XIOS/trunk/src/client_server_mapping.hpp

@@ -26 +26 @@
 public:
   typedef boost::unordered_map<int, std::vector<size_t> > GlobalIndexMap;
-  typedef std::map<int, std::vector<int> > LocalIndexMap;
   public:
     /** Default constructor */
@@ -37 +36 @@
     virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient) = 0;
 
-//    // Simple case, global index on client and index on servers
-//    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-//                                           const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
-
     static std::map<int,int> computeConnectedClients(int nbServer, int nbClient,
                                                      MPI_Comm& clientIntraComm,
@@ -46 +41 @@
 
     const GlobalIndexMap& getGlobalIndexOnServer() const;
-//    const LocalIndexMap& getLocalIndexSendToServer() const;
-
-  protected:
-//    void defaultComputeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-//                                          const std::vector<CArray<size_t,1>* >& globalIndexOnServer,
-//                                          const CArray<int,1>* localIndexOnClient = 0);
 
   protected:
     //! Global index of data on SERVER, which are calculated by client(s)
     GlobalIndexMap indexGlobalOnServer_;
-
-    //! Index of the local data which will be sent to the corresponding server(s)
-//    LocalIndexMap  localIndexSend2Server_;
 
     //!< Number of clients connected to a server

XIOS/trunk/src/distribution_client.cpp

@@ -18 +18 @@
    , gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
    , isDataDistributed_(true), axisNum_(0), domainNum_(0), nIndexDomain_(), nIndexAxis_()
-   , globalDataSendToServer_(), localDataIndexSendToServer_(), localDataIndex_(), localMaskIndex_()
+   , localDataIndex_(), localMaskIndex_()//, globalDataSendToServer_(), localDataIndexSendToServer_()
+   , globalLocalDataSendToServerMap_()
    , infoIndex_()
 {
@@ -30 +31 @@
    , gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
    , isDataDistributed_(true), axisNum_(0), domainNum_(0), nIndexDomain_(), nIndexAxis_()
-   , globalDataSendToServer_(), localDataIndexSendToServer_(), localDataIndex_(), localMaskIndex_()
+   , localDataIndex_(), localMaskIndex_()//, globalDataSendToServer_(), localDataIndexSendToServer_()
+   , globalLocalDataSendToServerMap_()
    , infoIndex_()
 {
@@ -505 +507 @@
 
   // Now allocate these arrays
-  globalDataSendToServer_.resize(indexSend2ServerCount);
+//  globalDataSendToServer_.resize(indexSend2ServerCount);
+//  localDataIndexSendToServer_.resize(indexSend2ServerCount);
   localDataIndex_.resize(indexLocalDataOnClientCount);
-  localDataIndexSendToServer_.resize(indexSend2ServerCount);
+
   localMaskIndex_.resize(indexSend2ServerCount);
 
@@ -655 +658 @@
             }
           }
-          globalDataSendToServer_[indexSend2ServerCount] = globalIndex;
-          localDataIndexSendToServer_[indexSend2ServerCount] = indexLocalDataOnClientCount;
+//          globalDataSendToServer_[indexSend2ServerCount] = globalIndex;
+//          localDataIndexSendToServer_[indexSend2ServerCount] = indexLocalDataOnClientCount;
+          globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount;
           localMaskIndex_[indexSend2ServerCount] = gridMaskIndex;
           ++indexSend2ServerCount;
@@ -710 +714 @@
 }
 
-const std::vector<size_t>& CDistributionClient::getGlobalDataIndexSendToServer() const
-{
-  return globalDataSendToServer_;
+/*!
+  Return global local data mapping of client
+*/
+const CDistributionClient::GlobalLocalDataMap& CDistributionClient::getGlobalLocalDataSendToServer() const
+{
+  return globalLocalDataSendToServerMap_;
 }
 
@@ -731 +738 @@
 }
 
-/*!
-  Return local data index on client which are sent to servers
-*/
-const std::vector<int>& CDistributionClient::getLocalDataIndexSendToServer() const
-{
-  return localDataIndexSendToServer_;
-}
-
 } // namespace xios

XIOS/trunk/src/distribution_client.hpp

@@ -14 +14 @@
 #include "domain.hpp"
 #include "grid.hpp"
+#include <boost/unordered_map.hpp>
 
 namespace xios {
@@ -28 +29 @@
 class CDistributionClient : public CDistribution
 {
+public:
+  typedef boost::unordered_map<size_t,int> GlobalLocalDataMap;
+
   public:
     /** Default constructor */
@@ -37 +41 @@
 
     virtual const std::vector<int>& getLocalDataIndexOnClient() const;
-    virtual const std::vector<int>& getLocalDataIndexSendToServer() const;
-    const std::vector<size_t>& getGlobalDataIndexSendToServer() const;
+    const GlobalLocalDataMap& getGlobalLocalDataSendToServer() const;
     const std::vector<int>& getLocalMaskIndexOnClient() const;
 
@@ -72 +75 @@
   private:
     //!< LocalData index on client
-    std::vector<size_t> globalDataSendToServer_;
+    GlobalLocalDataMap globalLocalDataSendToServerMap_;
     std::vector<int> localDataIndex_;
-    std::vector<int> localDataIndexSendToServer_;
     std::vector<int> localMaskIndex_;
 
@@ -164 +166 @@
 }
 
-
 } // namespace xios
 #endif // __XIOS_DISTRIBUTIONCLIENT_HPP__

XIOS/trunk/src/node/grid.cpp

@@ -459 +459 @@
      const CClientServerMapping::GlobalIndexMap& globalIndexOnServer = clientServerMap_->getGlobalIndexOnServer();
 
-     const std::vector<size_t>& globalIndexSendToServer = clientDistribution_->getGlobalDataIndexSendToServer();
+     const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer();
+     CDistributionClient::GlobalLocalDataMap::const_iterator iteGlobalLocalIndexMap = globalLocalIndexSendToServer.end(), itGlobalLocalIndexMap;
      CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap;
      itGlobalMap  = itbGlobalMap = globalIndexOnServer.begin();
      iteGlobalMap = globalIndexOnServer.end();
 
-     typedef XIOSBinarySearchWithIndex<size_t> BinarySearch;
-     std::vector<int>::iterator itVec;
-     int nbGlobalIndex = globalIndexSendToServer.size();
      for (; itGlobalMap != iteGlobalMap; ++itGlobalMap)
      {
        int serverRank = itGlobalMap->first;
        int indexSize = itGlobalMap->second.size();
-       std::vector<int> permutIndex(indexSize);
-       XIOSAlgorithms::fillInIndex(indexSize, permutIndex);
-       XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(itGlobalMap->second, permutIndex);
-       BinarySearch binSearch(itGlobalMap->second);
-       for (int i = 0; i < nbGlobalIndex; ++i)
+       const std::vector<size_t>& indexVec = itGlobalMap->second;
+       for (int idx = 0; idx < indexSize; ++idx)
        {
-         if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndexSendToServer[i], itVec))
-         {
-           if (connectedDataSize_.end() == connectedDataSize_.find(serverRank))
-             connectedDataSize_[serverRank] = 1;
-           else
-             ++connectedDataSize_[serverRank];
-         }
+          itGlobalLocalIndexMap = globalLocalIndexSendToServer.find(indexVec[idx]);
+          if (iteGlobalLocalIndexMap != itGlobalLocalIndexMap)
+          {
+             if (connectedDataSize_.end() == connectedDataSize_.find(serverRank))
+               connectedDataSize_[serverRank] = 1;
+             else
+               ++connectedDataSize_[serverRank];
+          }
        }
      }
@@ -788 +784 @@
     list<CArray<size_t,1> > listOutIndex;
     const CClientServerMapping::GlobalIndexMap& globalIndexOnServer = clientServerMap_->getGlobalIndexOnServer();
-    const std::vector<int>& localIndexSendToServer = clientDistribution_->getLocalDataIndexSendToServer();
-    const std::vector<size_t>& globalIndexSendToServer = clientDistribution_->getGlobalDataIndexSendToServer();
+    const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer();
+    CDistributionClient::GlobalLocalDataMap::const_iterator itIndex = globalLocalIndexSendToServer.begin(),
+                                                           iteIndex = globalLocalIndexSendToServer.end();
 
     if (!doGridHaveDataDistributed())
@@ -795 +792 @@
       if (0 == client->clientRank)
       {
-        CArray<size_t,1> outGlobalIndexOnServer(globalIndexSendToServer.size());
-        for (int idx = 0; idx < globalIndexSendToServer.size();++idx)
-          outGlobalIndexOnServer(idx) = globalIndexSendToServer[idx];
-
-        CArray<int,1> outLocalIndexToServer(localIndexSendToServer.size());
-        for (int idx = 0; idx < localIndexSendToServer.size();++idx)
-          outLocalIndexToServer(idx) = localIndexSendToServer[idx];
+        int indexSize = globalLocalIndexSendToServer.size();
+        CArray<size_t,1> outGlobalIndexOnServer(indexSize);
+        CArray<int,1> outLocalIndexToServer(indexSize);
+        for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx)
+        {
+          outGlobalIndexOnServer(idx) = itIndex->first;
+          outLocalIndexToServer(idx) = itIndex->second;
+        }
 
         for (rank = 0; rank < client->serverSize; ++rank)
@@ -821 +819 @@
     else
     {
-      CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap;
-      itbGlobalMap = itGlobalMap = globalIndexOnServer.begin();
+      CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap;
+      itGlobalMap = globalIndexOnServer.begin();
       iteGlobalMap = globalIndexOnServer.end();
 
-      int nbGlobalIndex = globalIndexSendToServer.size();
       std::map<int,std::vector<int> >localIndexTmp;
       std::map<int,std::vector<size_t> > globalIndexTmp;
-
-      typedef XIOSBinarySearchWithIndex<size_t> BinarySearch;
-      std::vector<int>::iterator itVec;
       for (; itGlobalMap != iteGlobalMap; ++itGlobalMap)
       {
         int serverRank = itGlobalMap->first;
         int indexSize = itGlobalMap->second.size();
-        std::vector<int> permutIndex(indexSize);
-        XIOSAlgorithms::fillInIndex(indexSize, permutIndex);
-        XIOSAlgorithms::sortWithIndex<size_t, CVectorStorage>(itGlobalMap->second, permutIndex);
-        BinarySearch binSearch(itGlobalMap->second);
-
-        for (int i = 0; i < nbGlobalIndex; ++i)
+        const std::vector<size_t>& indexVec = itGlobalMap->second;
+        for (int idx = 0; idx < indexSize; ++idx)
         {
-          if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndexSendToServer[i], itVec))
+          itIndex = globalLocalIndexSendToServer.find(indexVec[idx]);
+          if (iteIndex != itIndex)
           {
-            globalIndexTmp[serverRank].push_back(globalIndexSendToServer[i]);
-            localIndexTmp[serverRank].push_back(localIndexSendToServer[i]);
+            globalIndexTmp[serverRank].push_back(itIndex->first);
+            localIndexTmp[serverRank].push_back(itIndex->second);
           }
         }

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;
   }