Changeset 866


Ignore:
Timestamp:
06/09/16 11:33:12 (5 years ago)
Author:
mhnguyen
Message:

Reorganizing codes

+) Reorganize some structures to make them more performant

Test:
+) On Curie
+) All tests pass

Location:
XIOS/trunk/src/transformation
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

    r862 r866  
    3333 
    3434void CAxisAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex, 
    35                                                               boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc) 
     35                                                              CClientClientDHTInt::Index2VectorInfoTypeMap& globalAxisIndexOnProc) 
    3636{ 
    3737  CContext* context = CContext::getCurrent(); 
     
    4747  { 
    4848    globalIndex = axisSrc_->index(idx); 
    49     globalIndex2ProcRank[globalIndex].push_back(clientRank); 
     49    globalIndex2ProcRank[globalIndex].resize(1); 
     50    globalIndex2ProcRank[globalIndex][0] = clientRank; 
     51//    globalIndex2ProcRank[globalIndex].push_back(clientRank); 
    5052  } 
    5153 
     
    5355  dhtIndexProcRank.computeIndexInfoMapping(globalAxisIndex); 
    5456 
    55   std::vector<int> countIndex(clientSize,0); 
    56   const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
    57   CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it, 
    58                                                                ite = computedGlobalIndexOnProc.end(); 
    59   for (it = itb; it != ite; ++it) 
    60   { 
    61     const std::vector<int>& procList = it->second; 
    62     for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]]; 
    63   } 
    64  
    65   globalAxisIndexOnProc.rehash(std::ceil(clientSize/globalAxisIndexOnProc.max_load_factor())); 
    66   for (int idx = 0; idx < clientSize; ++idx) 
    67   { 
    68     if (0 != countIndex[idx]) 
    69     { 
    70       globalAxisIndexOnProc[idx].resize(countIndex[idx]); 
    71       countIndex[idx] = 0; 
    72     } 
    73   } 
    74  
    75   for (it = itb; it != ite; ++it) 
    76   { 
    77     const std::vector<int>& procList = it->second; 
    78     for (int idx = 0; idx < procList.size(); ++idx) 
    79     { 
    80       globalAxisIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first; 
    81       ++countIndex[procList[idx]]; 
    82     } 
    83   } 
     57//  std::vector<int> countIndex(clientSize,0); 
     58//  const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
     59  globalAxisIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
     60// 
     61//  CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it, 
     62//                                                               ite = computedGlobalIndexOnProc.end(); 
     63//  for (it = itb; it != ite; ++it) 
     64//  { 
     65//    const std::vector<int>& procList = it->second; 
     66//    for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]]; 
     67//  } 
     68// 
     69//  globalAxisIndexOnProc.rehash(std::ceil(clientSize/globalAxisIndexOnProc.max_load_factor())); 
     70//  for (int idx = 0; idx < clientSize; ++idx) 
     71//  { 
     72//    if (0 != countIndex[idx]) 
     73//    { 
     74//      globalAxisIndexOnProc[idx].resize(countIndex[idx]); 
     75//      countIndex[idx] = 0; 
     76//    } 
     77//  } 
     78// 
     79//  for (it = itb; it != ite; ++it) 
     80//  { 
     81//    const std::vector<int>& procList = it->second; 
     82//    for (int idx = 0; idx < procList.size(); ++idx) 
     83//    { 
     84//      globalAxisIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first; 
     85//      ++countIndex[procList[idx]]; 
     86//    } 
     87//  } 
    8488} 
    8589 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.hpp

    r862 r866  
    4040 
    4141  void computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex, 
    42                                   boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc); 
     42                                  CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc); 
    4343 
    4444protected: 
  • XIOS/trunk/src/transformation/domain_algorithm_transformation.cpp

    r862 r866  
    1111#include "context.hpp" 
    1212#include "context_client.hpp" 
    13 #include "client_client_dht_template.hpp" 
     13#include "domain.hpp" 
    1414 
    1515namespace xios { 
     
    2929 
    3030void CDomainAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex, 
    31                                                                 boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc) 
     31                                                                CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc) 
    3232{ 
    3333  CContext* context = CContext::getCurrent(); 
     
    5353  CClientClientDHTInt dhtIndexProcRank(globalIndex2ProcRank, client->intraComm); 
    5454  dhtIndexProcRank.computeIndexInfoMapping(globalDomainIndex); 
    55  
    56   std::vector<int> countIndex(clientSize,0); 
    57   const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
    58   CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it, 
    59                                                                ite = computedGlobalIndexOnProc.end(); 
    60   for (it = itb; it != ite; ++it) 
    61   { 
    62     const std::vector<int>& procList = it->second; 
    63     for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]]; 
    64   } 
    65  
    66   globalDomainIndexOnProc.rehash(std::ceil(clientSize/globalDomainIndexOnProc.max_load_factor())); 
    67   for (int idx = 0; idx < clientSize; ++idx) 
    68   { 
    69     if (0 != countIndex[idx]) 
    70     { 
    71       globalDomainIndexOnProc[idx].resize(countIndex[idx]); 
    72       countIndex[idx] = 0; 
    73     } 
    74   } 
    75  
    76   for (it = itb; it != ite; ++it) 
    77   { 
    78     const std::vector<int>& procList = it->second; 
    79     for (int idx = 0; idx < procList.size(); ++idx) 
    80     { 
    81       globalDomainIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first; 
    82       ++countIndex[procList[idx]]; 
    83     } 
    84   } 
     55  globalDomainIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
     56 
     57 
     58//  std::vector<int> countIndex(clientSize,0); 
     59//  const CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap(); 
     60//  CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = computedGlobalIndexOnProc.begin(), it, 
     61//                                                               ite = computedGlobalIndexOnProc.end(); 
     62//  for (it = itb; it != ite; ++it) 
     63//  { 
     64//    const std::vector<int>& procList = it->second; 
     65//    for (int idx = 0; idx < procList.size(); ++idx) ++countIndex[procList[idx]]; 
     66//  } 
     67// 
     68//  globalDomainIndexOnProc.rehash(std::ceil(clientSize/globalDomainIndexOnProc.max_load_factor())); 
     69//  for (int idx = 0; idx < clientSize; ++idx) 
     70//  { 
     71//    if (0 != countIndex[idx]) 
     72//    { 
     73//      globalDomainIndexOnProc[idx].resize(countIndex[idx]); 
     74//      countIndex[idx] = 0; 
     75//    } 
     76//  } 
     77// 
     78//  for (it = itb; it != ite; ++it) 
     79//  { 
     80//    const std::vector<int>& procList = it->second; 
     81//    for (int idx = 0; idx < procList.size(); ++idx) 
     82//    { 
     83//      globalDomainIndexOnProc[procList[idx]][countIndex[procList[idx]]] = it->first; 
     84//      ++countIndex[procList[idx]]; 
     85//    } 
     86//  } 
    8587} 
    8688 
  • XIOS/trunk/src/transformation/domain_algorithm_transformation.hpp

    r862 r866  
    1111 
    1212#include "generic_algorithm_transformation.hpp" 
    13 #include "domain.hpp" 
     13#include "client_client_dht_template.hpp" 
    1414 
    1515namespace xios { 
    1616 
     17class CDomain; 
    1718/*! 
    1819  \class CDomainAlgorithmTransformation 
     
    4041 
    4142  void computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex, 
    42                                   boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc); 
     43                                  CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc); 
    4344protected: 
    4445  inline void domainGlobalIndex(const int& index, const int& niGlob, const int& njGlob, 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r862 r866  
    118118 
    119119  typedef boost::unordered_map<int, std::vector<std::pair<int,double> > > SrcToDstMap; 
     120 
     121  size_t indexSrcSize = 0; 
     122  for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans) 
     123  { 
     124    TransformationIndexMap::const_iterator itbTransMap = transformationMapping_[idxTrans].begin(), itTransMap, 
     125                                           iteTransMap = transformationMapping_[idxTrans].end(); 
     126    TransformationWeightMap::const_iterator itbTransWeight = transformationWeight_[idxTrans].begin(), itTransWeight; 
     127 
     128    itTransWeight = itbTransWeight; 
     129    for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight) 
     130    { 
     131       indexSrcSize += (itTransMap->second).size(); 
     132    } 
     133  } 
     134 
    120135  bool isTransPosEmpty = transformationPosition_.empty(); 
     136  CArray<size_t,1> transPos; 
     137  if (!isTransPosEmpty) transPos.resize(transformationMapping_.size()); 
     138  CArray<size_t,1> indexSrc(indexSrcSize); 
     139  indexSrcSize = 0; 
     140  for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans) 
     141  { 
     142    TransformationIndexMap::const_iterator itbTransMap = transformationMapping_[idxTrans].begin(), itTransMap, 
     143                                           iteTransMap = transformationMapping_[idxTrans].end(); 
     144    TransformationWeightMap::const_iterator itbTransWeight = transformationWeight_[idxTrans].begin(), itTransWeight; 
     145 
     146    // Build mapping between global source element index and global destination element index. 
     147    itTransWeight = itbTransWeight; 
     148    for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight) 
     149    { 
     150      const std::vector<int>& srcIndex = itTransMap->second; 
     151      for (int idx = 0; idx < srcIndex.size(); ++idx) 
     152      { 
     153        indexSrc(indexSrcSize) = srcIndex[idx]; 
     154        ++indexSrcSize; 
     155      } 
     156    } 
     157 
     158    if (!isTransPosEmpty) 
     159    { 
     160      TransformationPositionMap::const_iterator itPosMap = transformationPosition_[idxTrans].begin(); 
     161      transPos(idxTrans) = itPosMap->second[0]; 
     162    } 
     163  } 
     164 
     165  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     166  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     167  CArray<bool,1> axisDomainDstOrder = gridDst->axis_domain_order; 
     168  std::vector<CAxis*> axisListSrcP = gridSrc->getAxis(); 
     169  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains(); 
     170 
     171  // Find out global index source of transformed element on corresponding process. 
     172  std::vector<boost::unordered_map<int,std::vector<size_t> > > globalElementIndexOnProc(axisDomainDstOrder.numElements()); 
     173  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndexOfTransformedElementOnProc; 
     174  int axisIndex = 0, domainIndex = 0; 
     175  for (int idx = 0; idx < axisDomainDstOrder.numElements(); ++idx) 
     176  { 
     177    if (idx == elementPositionInGrid) 
     178      computeExchangeGlobalIndex(indexSrc, globalIndexOfTransformedElementOnProc); //globalElementIndexOnProc[idx]); 
     179    if (axisDomainDstOrder(idx)) // It's domain 
     180    { 
     181      if (idx != elementPositionInGrid) 
     182        computeExchangeDomainIndex(domainListDestP[domainIndex], 
     183                                   domainListSrcP[domainIndex], 
     184                                   transPos, 
     185                                   globalElementIndexOnProc[idx]); 
     186      ++domainIndex; 
     187 
     188    } 
     189    else //it's an axis 
     190    { 
     191      if (idx != elementPositionInGrid) 
     192        computeExchangeAxisIndex(axisListDestP[axisIndex], 
     193                                 axisListSrcP[axisIndex], 
     194                                 transPos, 
     195                                 globalElementIndexOnProc[idx]); 
     196      ++axisIndex; 
     197 
     198    } 
     199  } 
     200 
     201  if (!isTransPosEmpty) 
     202  { 
     203    for (int idx = 0; idx < globalElementIndexOnProc.size(); ++idx) 
     204    { 
     205      if (idx != elementPositionInGrid) 
     206      { 
     207        boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc[idx].begin(), it, 
     208                                                                 ite = globalElementIndexOnProc[idx].end(); 
     209        for (it = itb; it != ite; ++it) it->second.resize(1); 
     210      } 
     211    } 
     212  } 
     213 
    121214  for (size_t idxTrans = 0; idxTrans < transformationMapping_.size(); ++idxTrans) 
    122215  { 
     
    127220    src2DstMap.rehash(std::ceil(transformationMapping_[idxTrans].size()/src2DstMap.max_load_factor())); 
    128221 
    129     int indexSrcSize = 0; 
    130     itTransWeight = itbTransWeight; 
    131     for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight) 
    132     { 
    133        indexSrcSize += (itTransMap->second).size(); 
    134     } 
    135  
    136     CArray<size_t,1> indexSrc(indexSrcSize); 
    137     int indexSrcIndex = 0; 
    138222    // Build mapping between global source element index and global destination element index. 
     223    boost::unordered_map<int,std::vector<size_t> >().swap(globalElementIndexOnProc[elementPositionInGrid]); 
     224    boost::unordered_map<int,int> tmpCounter; 
    139225    itTransWeight = itbTransWeight; 
    140226    for (itTransMap = itbTransMap; itTransMap != iteTransMap; ++itTransMap, ++itTransWeight) 
     
    145231      { 
    146232        src2DstMap[srcIndex[idx]].push_back(make_pair(itTransMap->first, weight[idx])); 
    147         indexSrc(indexSrcIndex) = srcIndex[idx]; 
    148         ++indexSrcIndex; 
     233        if (1 == globalIndexOfTransformedElementOnProc.count(srcIndex[idx]) && (0 == tmpCounter.count(srcIndex[idx]))) 
     234        { 
     235          tmpCounter[srcIndex[idx]] = 1; 
     236          std::vector<int>& srcProc = globalIndexOfTransformedElementOnProc[srcIndex[idx]]; 
     237          for (int j = 0; j < srcProc.size(); ++j) 
     238            globalElementIndexOnProc[elementPositionInGrid][srcProc[j]].push_back(srcIndex[idx]); 
     239        } 
    149240      } 
    150241    } 
    151242 
    152     std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
    153     std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
    154     CArray<bool,1> axisDomainDstOrder = gridDst->axis_domain_order; 
    155     std::vector<CAxis*> axisListSrcP = gridSrc->getAxis(); 
    156     std::vector<CDomain*> domainListSrcP = gridSrc->getDomains(); 
    157     CArray<bool,1> axisDomainSrcOrder = gridDst->axis_domain_order; 
    158  
    159     CArray<size_t,1> transPos; 
    160243    if (!isTransPosEmpty) 
    161244    { 
    162       transPos.resize(transformationPosition_[idxTrans].size()); 
    163       TransformationPositionMap::const_iterator itPosMap = transformationPosition_[idxTrans].begin(), 
    164                                                itePosMap = transformationPosition_[idxTrans].end(); 
    165       for (int idx = 0; itPosMap != itePosMap; ++itPosMap, ++idx) 
    166         transPos(idx) = itPosMap->second[0]; 
    167     } 
    168     // Find out global index source of transformed element on corresponding process. 
    169     std::vector<boost::unordered_map<int,std::vector<size_t> > > globalElementIndexOnProc(axisDomainDstOrder.numElements()); 
    170     int axisIndex = 0, domainIndex = 0; 
    171     for (int idx = 0; idx < axisDomainDstOrder.numElements(); ++idx) 
    172     { 
    173       if (idx == elementPositionInGrid) 
    174         computeExchangeGlobalIndex(indexSrc, globalElementIndexOnProc[idx]); 
    175       if (axisDomainDstOrder(idx)) // It's domain 
     245      for (int idx = 0; idx < globalElementIndexOnProc.size(); ++idx) 
    176246      { 
    177247        if (idx != elementPositionInGrid) 
    178           computeExchangeDomainIndex(domainListDestP[domainIndex], 
    179                                      domainListSrcP[domainIndex], 
    180                                      transPos, 
    181                                      globalElementIndexOnProc[idx]); 
    182         ++domainIndex; 
    183  
     248        { 
     249          boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc[idx].begin(), it, 
     250                                                                   ite = globalElementIndexOnProc[idx].end(); 
     251          for (it = itb; it != ite; ++it) it->second[0] = transPos(idxTrans); 
     252        } 
    184253      } 
    185       else //it's an axis 
    186       { 
    187         if (idx != elementPositionInGrid) 
    188           computeExchangeAxisIndex(axisListDestP[axisIndex], 
    189                                    axisListSrcP[axisIndex], 
    190                                    transPos, 
    191                                    globalElementIndexOnProc[idx]); 
    192         ++axisIndex; 
    193  
    194       } 
    195254    } 
    196255 
    197256    std::vector<std::vector<bool> > elementOnProc(axisDomainDstOrder.numElements(), std::vector<bool>(nbClient, false)); 
    198  
    199257    boost::unordered_map<int,std::vector<size_t> >::const_iterator it, itb, ite; 
    200258    for (int idx = 0; idx < globalElementIndexOnProc.size(); ++idx) 
     
    431489  int clientSize = client->clientSize; 
    432490 
    433   int niGlob = domainSrc->ni_glo.getValue(); 
    434   int njGlob = domainSrc->nj_glo.getValue(); 
     491  int niGlobSrc = domainSrc->ni_glo.getValue(); 
    435492  size_t globalIndex; 
    436   int nIndexSize = domainSrc->i_index.numElements(), i_ind, j_ind; 
     493  int i_ind, j_ind; 
     494  int nIndexSize = (destGlobalIndexPositionInGrid.isEmpty()) ? domainSrc->i_index.numElements() 
     495                                                             : destGlobalIndexPositionInGrid.numElements(); 
    437496  CClientClientDHTInt::Index2VectorInfoTypeMap globalIndex2ProcRank; 
    438497  globalIndex2ProcRank.rehash(std::ceil(nIndexSize/globalIndex2ProcRank.max_load_factor())); 
    439   for (int idx = 0; idx < nIndexSize; ++idx) 
    440   { 
    441     i_ind=domainSrc->i_index(idx) ; 
    442     j_ind=domainSrc->j_index(idx) ; 
    443  
    444     globalIndex = i_ind + j_ind * niGlob; 
    445     globalIndex2ProcRank[globalIndex].push_back(clientRank); 
     498  if (destGlobalIndexPositionInGrid.isEmpty()) 
     499  { 
     500    for (int idx = 0; idx < nIndexSize; ++idx) 
     501    { 
     502      i_ind=domainSrc->i_index(idx) ; 
     503      j_ind=domainSrc->j_index(idx) ; 
     504 
     505      globalIndex = i_ind + j_ind * niGlobSrc; 
     506      globalIndex2ProcRank[globalIndex].resize(1); 
     507      globalIndex2ProcRank[globalIndex][0] = clientRank; 
     508    } 
     509  } 
     510  else 
     511  { 
     512    for (int idx = 0; idx < nIndexSize; ++idx) 
     513    { 
     514      globalIndex2ProcRank[destGlobalIndexPositionInGrid(idx)].push_back(clientRank); 
     515    } 
    446516  } 
    447517 
     
    449519  if (destGlobalIndexPositionInGrid.isEmpty()) 
    450520  { 
     521    int niGlobDst = domainDst->ni_glo.getValue(); 
    451522    globalDomainIndex.resize(domainDst->i_index.numElements()); 
    452523    nIndexSize = domainDst->i_index.numElements(); 
     
    457528      j_ind=domainDst->j_index(idx) ; 
    458529 
    459       globalDomainIndex(idx) = i_ind + j_ind * niGlob; 
     530      globalDomainIndex(idx) = i_ind + j_ind * niGlobDst; 
    460531    } 
    461532  } 
    462533  else 
    463534  { 
    464     globalDomainIndex  = destGlobalIndexPositionInGrid; 
    465 //    for (int idx = 0; idx < destGlobalIndexPositionInGrid.size(); ++idx) 
    466 //    { 
    467 //      globalDomainIndex(idx) = destGlobalIndexPositionInGrid[idx]; 
    468 //    } 
     535    globalDomainIndex.reference(destGlobalIndexPositionInGrid); 
    469536  } 
    470537 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

    r862 r866  
    1313#include <set> 
    1414#include "array_new.hpp" 
     15#include "client_client_dht_template.hpp" 
    1516 
    1617namespace xios { 
     
    8889 
    8990  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalElementIndex, 
    90                                           boost::unordered_map<int,std::vector<size_t> >& globalElementIndexOnProc) = 0; 
     91                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalElementIndexOnProc) = 0; 
    9192 
    9293  void computeGlobalGridIndexMapping(int elementPositionInGrid, 
Note: See TracChangeset for help on using the changeset viewer.