Ignore:
Timestamp:
08/24/15 14:53:36 (9 years ago)
Author:
mhnguyen
Message:

Implementing some code factoring

+) Replace some slow searching function by faster ones

Test
+) On Curie
+) test_client and test_complete are correct

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r660 r668  
    2222CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source) 
    2323: gridSource_(source), gridDestination_(destination), originalGridSource_(source), 
    24   globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0), weightOfGlobalIndexOfOriginalGridSource_(0), algoTypes_() 
     24  globalIndexOfCurrentGridSource_(), globalIndexOfOriginalGridSource_(), weightOfGlobalIndexOfOriginalGridSource_(0), algoTypes_() 
    2525{ 
    2626  //Verify the compatibity between two grids 
    … …  
    7777 
    7878  CDistributionClient distribution(client->clientRank, originalGridSource_); 
    79   const CArray<size_t,1>& globalIndexGridDestSendToServer = distribution.getGlobalDataIndexSendToServer(); 
    80  
    81   globalIndexOfCurrentGridSource_.resize(globalIndexGridDestSendToServer.numElements()); 
    82   globalIndexOfOriginalGridSource_.resize(globalIndexGridDestSendToServer.numElements()); 
    83   weightOfGlobalIndexOfOriginalGridSource_.resize(globalIndexGridDestSendToServer.numElements()); 
     79  const std::vector<size_t>& globalIndexGridDestSendToServer = distribution.getGlobalDataIndexSendToServer(); 
     80 
     81  weightOfGlobalIndexOfOriginalGridSource_.resize(globalIndexGridDestSendToServer.size()); 
    8482  globalIndexOfCurrentGridSource_  = globalIndexGridDestSendToServer; 
    8583  globalIndexOfOriginalGridSource_ = globalIndexGridDestSendToServer; 
    … …  
    362360    // Recalculate the distribution of grid destination 
    363361    CDistributionClient distributionClientDest(client->clientRank, gridDestination_); 
    364     const CArray<size_t,1>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer(); 
     362    const std::vector<size_t>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer(); 
    365363 
    366364    // ComputeTransformation of global index of each element 
    … …  
    397395  //First of all, retrieve info of local mask of grid destination 
    398396  CDistributionClient distributionClientDest(client->clientRank, gridDestination_); 
    399   const CArray<int, 1>& localMaskIndexOnClientDest = distributionClientDest.getLocalMaskIndexOnClient(); 
    400   const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); 
    401  
    402   CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr; 
     397  const std::vector<int>& localMaskIndexOnClientDest = distributionClientDest.getLocalMaskIndexOnClient(); 
     398  const std::vector<size_t>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); 
     399 
     400  std::vector<size_t>::const_iterator itbArr, itArr, iteArr; 
    403401  itbArr = globalIndexOnClientDest.begin(); 
    404402  iteArr = globalIndexOnClientDest.end(); 
    405403 
    406404  // Then find out which index became invalid (become masked after being applied the algorithms, or demande some masked points from grid source) 
    407   int num = globalIndexOfOriginalGridSource_.numElements(); 
     405  int num = globalIndexOfOriginalGridSource_.size(); 
    408406  const size_t sfmax = NumTraits<unsigned long>::sfmax(); 
    409407  int maskIndexNum = 0; 
    410408  for (int idx = 0; idx < num; ++idx) 
    411409  { 
    412     if (sfmax == globalIndexOfOriginalGridSource_(idx)) 
    413     { 
    414       size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_(idx); 
     410    if (sfmax == globalIndexOfOriginalGridSource_[idx]) 
     411    { 
     412      size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_[idx]; 
    415413      itArr = std::find(itbArr, iteArr, maskedGlobalIndex); 
    416414      if (iteArr != itArr) ++maskIndexNum; 
    … …  
    422420  for (int idx = 0; idx < num; ++idx) 
    423421  { 
    424     if (sfmax == globalIndexOfOriginalGridSource_(idx)) 
    425     { 
    426       size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_(idx); 
     422    if (sfmax == globalIndexOfOriginalGridSource_[idx]) 
     423    { 
     424      size_t maskedGlobalIndex = globalIndexOfCurrentGridSource_[idx]; 
    427425      itArr = std::find(itbArr, iteArr, maskedGlobalIndex); 
    428426      if (iteArr != itArr) 
    429427      { 
    430428        int localIdx = std::distance(itbArr, itArr); 
    431         maskIndexToModify(maskIndexNum) = localMaskIndexOnClientDest(localIdx); 
     429        maskIndexToModify(maskIndexNum) = localMaskIndexOnClientDest[localIdx]; 
    432430        ++maskIndexNum; 
    433431      } 
    … …  
    459457  std::map<int,std::vector<size_t> >::const_iterator itbSend = globalIndexToSend.begin(), itSend, 
    460458                                                     iteSend = globalIndexToSend.end(); 
    461   CArray<size_t,1>::const_iterator itbArr = globalIndexOfCurrentGridSource_.begin(), itArr, 
    462                                    iteArr = globalIndexOfCurrentGridSource_.end(); 
     459  std::vector<size_t>::const_iterator itbArr = globalIndexOfCurrentGridSource_.begin(), itArr, 
     460                                      iteArr = globalIndexOfCurrentGridSource_.end(); 
    463461 int sendBuffSize = 0; 
    464462 for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize += (itSend->second).size(); 
    … …  
    471469 std::map<int, MPI_Request> requests; 
    472470 
     471 std::vector<int> permutIndex(globalIndexOfCurrentGridSource_.size()); 
     472 typedef XIOSBinarySearchWithIndex<size_t> BinarySearch; 
     473 XIOSAlgorithms::fillInIndex(globalIndexOfCurrentGridSource_.size(), permutIndex); 
     474 XIOSAlgorithms::sortWithIndex<size_t>(globalIndexOfCurrentGridSource_, permutIndex); 
     475 BinarySearch searchCurrentSrc(globalIndexOfCurrentGridSource_); 
     476 std::vector<int>::iterator itbIndex = permutIndex.begin(), itIndex, 
     477                            iteIndex = permutIndex.end(); 
     478 
     479  // Find out local index on grid destination (received) 
    473480 int currentBuffPosition = 0; 
    474481 for (itSend = itbSend; itSend != iteSend; ++itSend) 
    … …  
    479486   for (int idx = 0; idx < (countSize); ++idx) 
    480487   { 
    481      itArr = std::find(itbArr, iteArr, globalIndexOfCurrentGridSourceToSend[idx]); 
    482      if (iteArr != itArr) 
     488     if (searchCurrentSrc.search(itbIndex, iteIndex, globalIndexOfCurrentGridSourceToSend[idx], itIndex)) 
    483489     { 
    484        int index = std::distance(itbArr, itArr); 
    485        sendBuff[idx+currentBuffPosition] = globalIndexOfOriginalGridSource_(index); 
     490//       int index = std::distance(itbArr, itArr); 
     491       sendBuff[idx+currentBuffPosition] = globalIndexOfOriginalGridSource_[*itIndex]; //[index]; 
    486492     } 
    487493   } 
    … …  
    522528 } 
    523529 
    524  if (globalIndexOfCurrentGridSource_.numElements() != nbCurrentGridSource) 
     530 if (globalIndexOfCurrentGridSource_.size() != nbCurrentGridSource) 
    525531 { 
    526532   globalIndexOfCurrentGridSource_.resize(nbCurrentGridSource); 
    … …  
    539545     for (int i = 0; i < ssize; ++i) 
    540546     { 
    541        globalIndexOfCurrentGridSource_(k) = ((itRecv->second)[idx][i]).first; 
     547       globalIndexOfCurrentGridSource_[k] = ((itRecv->second)[idx][i]).first; 
    542548       weightOfGlobalIndexOfOriginalGridSource_(k) = ((itRecv->second)[idx][i]).second; 
    543        globalIndexOfOriginalGridSource_(k) = *currentRecvBuff; 
     549       globalIndexOfOriginalGridSource_[k] = *currentRecvBuff; 
    544550       ++k; 
    545551     } 
    … …  
    568574 
    569575  std::map<size_t, std::vector<std::pair<size_t,double> > > globaIndexWeightFromDestToSource; 
    570   int nb = globalIndexOfCurrentGridSource_.numElements(); 
     576  int nb = globalIndexOfCurrentGridSource_.size(); 
    571577  const size_t sfmax = NumTraits<unsigned long>::sfmax(); 
    572578  for (int idx = 0; idx < nb; ++idx) 
    573579  { 
    574     if (sfmax != globalIndexOfOriginalGridSource_(idx)) 
    575       globaIndexWeightFromDestToSource[globalIndexOfCurrentGridSource_(idx)].push_back(make_pair(globalIndexOfOriginalGridSource_(idx), weightOfGlobalIndexOfOriginalGridSource_(idx))) ; 
     580    if (sfmax != globalIndexOfOriginalGridSource_[idx]) 
     581      globaIndexWeightFromDestToSource[globalIndexOfCurrentGridSource_[idx]].push_back(make_pair(globalIndexOfOriginalGridSource_[idx], weightOfGlobalIndexOfOriginalGridSource_(idx))) ; 
    576582  } 
    577583 
    … …  
    585591  CDistributionClient distributionClientSrc(client->clientRank, originalGridSource_); 
    586592 
    587   const CArray<int, 1>& localIndexOnClientDest = distributionClientDest.getLocalDataIndexSendToServer(); 
    588   const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); 
    589  
    590   const CArray<int, 1>& localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); 
    591   const CArray<size_t,1>& globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); 
    592  
    593   std::vector<size_t>::const_iterator itbVec, itVec, iteVec; 
    594   CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr; 
    595  
     593  const std::vector<size_t>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); 
     594  const std::vector<size_t>& globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); 
     595 
     596  std::vector<size_t>::const_iterator itbArr, itArr, iteArr; 
     597  std::vector<int>::const_iterator itIndex, itbIndex, iteIndex; 
    596598  std::map<int,std::vector<std::vector<std::pair<size_t,double> > > >::const_iterator itbMapRecv, itMapRecv, iteMapRecv; 
    597599 
     600  std::vector<int> permutIndex; 
     601  typedef XIOSBinarySearchWithIndex<size_t> BinarySearch; 
     602 
    598603  // Find out local index on grid destination (received) 
     604  XIOSAlgorithms::fillInIndex(globalIndexOnClientDest.size(), permutIndex); 
     605  XIOSAlgorithms::sortWithIndex<size_t>(globalIndexOnClientDest, permutIndex); 
     606  itbIndex = permutIndex.begin(); 
     607  iteIndex = permutIndex.end(); 
     608  BinarySearch searchClientDest(globalIndexOnClientDest); 
    599609  itbMapRecv = globalIndexToReceive.begin(); 
    600610  iteMapRecv = globalIndexToReceive.end(); 
    601   itbArr = globalIndexOnClientDest.begin(); 
    602   iteArr = globalIndexOnClientDest.end(); 
    603611  for (itMapRecv = itbMapRecv; itMapRecv != iteMapRecv; ++itMapRecv) 
    604612  { 
    … …  
    613621        size_t globalIndex = (itMapRecv->second)[i][idx].first; 
    614622        double weight = (itMapRecv->second)[i][idx].second; 
    615         itArr = std::find(itbArr, iteArr, globalIndex); 
    616         if (iteArr != itArr) 
     623        if (searchClientDest.search(itbIndex, iteIndex, globalIndex, itIndex)) 
    617624        { 
    618           int localIdx = std::distance(itbArr, itArr); 
    619           tmpVec.push_back(make_pair(localIdx, weight)); 
     625          tmpVec.push_back(make_pair(*itIndex, weight)); 
    620626        } 
    621627      } 
    … …  
    626632  // Find out local index on grid source (to send) 
    627633  std::map<int,std::vector<size_t> >::const_iterator itbMap, itMap, iteMap; 
     634  XIOSAlgorithms::fillInIndex(globalIndexOnClientSrc.size(), permutIndex); 
     635  XIOSAlgorithms::sortWithIndex<size_t>(globalIndexOnClientSrc, permutIndex); 
     636  itbIndex = permutIndex.begin(); 
     637  iteIndex = permutIndex.end(); 
     638  BinarySearch searchClientSrc(globalIndexOnClientSrc); 
    628639  itbMap = globalIndexToSend.begin(); 
    629640  iteMap = globalIndexToSend.end(); 
    630   itbArr = globalIndexOnClientSrc.begin(); 
    631   iteArr = globalIndexOnClientSrc.end(); 
    632641  for (itMap = itbMap; itMap != iteMap; ++itMap) 
    633642  { 
    … …  
    637646    for (int idx = 0; idx < vecSize; ++idx) 
    638647    { 
    639       itArr = std::find(itbArr, iteArr, itMap->second[idx]); 
    640       if (iteArr != itArr) 
     648      if (searchClientSrc.search(itbIndex, iteIndex, itMap->second[idx], itIndex)) 
    641649      { 
    642         int localIdx = std::distance(itbArr, itArr); 
    643         localIndexToSendFromGridSource_[destRank](idx) = localIdx; 
     650        localIndexToSendFromGridSource_[destRank](idx) = *itIndex; 
    644651      } 
    645652    } 
Note: See TracChangeset for help on using the changeset viewer.