Changeset 1337


Ignore:
Timestamp:
11/21/17 10:05:04 (3 years ago)
Author:
oabramkina
Message:

Avoiding recalculation of domain/axis distributions for server-pools of the same size. This commit is complimentary to r1263.

Location:
XIOS/dev/XIOS_DEV_CMIP6/src/node
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/axis.cpp

    r1336 r1337  
    180180     { 
    181181       // size estimation for sendDistributedValue 
    182        boost::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client].end(); 
    183        for (it = indSrv_[client].begin(); it != ite; ++it) 
     182       boost::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end(); 
     183       for (it = indSrv_[client->serverSize].begin(); it != ite; ++it) 
    184184       { 
    185185         size_t sizeIndexEvent = CArray<int,1>::size(it->second.size()); 
     
    607607 
    608608 
    609       indSrv_[client].swap(globalIndexAxisOnServer); 
     609      indSrv_[nbServer].swap(globalIndexAxisOnServer); 
    610610 
    611611      if (distType==CServerDistributionDescription::ROOT_DISTRIBUTION) 
    612612      { 
    613         for(int i=1; i<nbServer; ++i) indSrv_[client].insert(pair<int, vector<size_t> >(i,indSrv_[client][0]) ) ; 
     613        for(int i=1; i<nbServer; ++i) indSrv_[nbServer].insert(pair<int, vector<size_t> >(i,indSrv_[nbServer][0]) ) ; 
    614614        serverZeroIndexLeader.clear() ; 
    615615      } 
    616616          
    617       CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_[client].begin(), 
    618                                                            ite = indSrv_[client].end(); 
    619  
    620       for (it = indSrv_[client].begin(); it != ite; ++it) connectedServerRank_[client].push_back(it->first); 
     617      CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_[nbServer].begin(), 
     618                                                           ite = indSrv_[nbServer].end(); 
     619 
     620      for (it = indSrv_[nbServer].begin(); it != ite; ++it) connectedServerRank_[nbServer].push_back(it->first); 
    621621 
    622622      for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    623         connectedServerRank_[client].push_back(*it); 
     623        connectedServerRank_[nbServer].push_back(*it); 
    624624 
    625625       // Even if a client has no index, it must connect to at least one server and  
    626626       // send an "empty" data to this server 
    627        if (connectedServerRank_[client].empty()) 
    628         connectedServerRank_[client].push_back(client->clientRank % client->serverSize); 
    629  
    630       nbSenders[client] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
     627       if (connectedServerRank_[nbServer].empty()) 
     628        connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
     629 
     630//       nbSenders[client] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
     631       nbSenders[nbServer] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
    631632 
    632633      delete clientServerMap; 
     
    10911092    { 
    10921093      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     1094      int nbServer = client->serverSize; 
    10931095 
    10941096      CEventClient eventData(getType(), EVENT_ID_DISTRIBUTED_ATTRIBUTES); 
     
    11111113 
    11121114      boost::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap; 
    1113       iteMap = indSrv_[client].end(); 
    1114       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     1115      iteMap = indSrv_[nbServer].end(); 
     1116      for (int k = 0; k < connectedServerRank_[nbServer].size(); ++k) 
    11151117      { 
    11161118        int nbData = 0; 
    1117         int rank = connectedServerRank_[client][k];         
    1118         it = indSrv_[client].find(rank); 
     1119        int rank = connectedServerRank_[nbServer][k]; 
     1120        it = indSrv_[nbServer].find(rank); 
    11191121        if (iteMap != it) 
    11201122          nbData = it->second.size(); 
     
    11821184          listData.back() << list_label.back(); 
    11831185 
    1184         eventData.push(rank, nbSenders[client][rank], listData.back()); 
     1186        eventData.push(rank, nbSenders[nbServer][rank], listData.back()); 
    11851187      } 
    11861188 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/axis.hpp

    r1330 r1337  
    157157         //! True if and only if the data defined on the axis can be outputted in a compressed way 
    158158         bool isCompressible_; 
    159          std::map<CContextClient*, map<int,int> > nbSenders; // Mapping of number of communicating client to a server 
    160          std::map<CContextClient*, boost::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server 
     159         std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server 
     160         std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server 
    161161         // std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server 
    162162         boost::unordered_map<size_t,size_t> globalLocalIndexMap_; 
     
    164164         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
    165165         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer; 
    166          std::map<CContextClient*, std::vector<int> > connectedServerRank_;          
     166         std::map<int, std::vector<int> > connectedServerRank_; 
    167167         bool hasBounds; 
    168168         bool hasLabel;          
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/domain.cpp

    r1336 r1337  
    4545      , globalLocalIndexMap_(), computedWrittenIndex_(false) 
    4646   { 
    47         } 
     47    } 
    4848 
    4949   CDomain::~CDomain(void) 
     
    147147     } 
    148148 
    149      boost::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client].end(); 
     149     boost::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client->serverSize].end(); 
    150150     // std::map<int, std::vector<int> >::const_iterator itWrittenIndexEnd = indWrittenSrv_.end(); 
    151      for (size_t k = 0; k < connectedServerRank_[client].size(); ++k) 
    152      { 
    153        int rank = connectedServerRank_[client][k]; 
    154        boost::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client].find(rank); 
     151     for (size_t k = 0; k < connectedServerRank_[client->serverSize].size(); ++k) 
     152     { 
     153       int rank = connectedServerRank_[client->serverSize][k]; 
     154       boost::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client->serverSize].find(rank); 
    155155       size_t idxCount = (it != itIndexEnd) ? it->second.size() : 0; 
    156156 
     
    635635   void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g) 
    636636   { 
    637           CContext* context = CContext::getCurrent(); 
     637     CContext* context = CContext::getCurrent(); 
    638638    // For now the assumption is that secondary server pools consist of the same number of procs. 
    639639    // CHANGE the line below if the assumption changes. 
    640640    CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[0] : context->client; 
    641           lon_g.resize(ni_glo) ; 
    642           lat_g.resize(nj_glo) ; 
    643  
    644  
    645           int* ibegin_g = new int[client->clientSize] ; 
    646           int* jbegin_g = new int[client->clientSize] ; 
    647           int* ni_g = new int[client->clientSize] ; 
    648           int* nj_g = new int[client->clientSize] ; 
    649           int v ; 
    650           v=ibegin ; 
    651           MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
    652           v=jbegin ; 
    653           MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
    654           v=ni ; 
    655           MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
    656           v=nj ; 
    657           MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
    658  
    659           MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
    660           MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
     641     lon_g.resize(ni_glo) ; 
     642     lat_g.resize(nj_glo) ; 
     643 
     644 
     645     int* ibegin_g = new int[client->clientSize] ; 
     646     int* jbegin_g = new int[client->clientSize] ; 
     647     int* ni_g = new int[client->clientSize] ; 
     648     int* nj_g = new int[client->clientSize] ; 
     649     int v ; 
     650     v=ibegin ; 
     651     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ; 
     652     v=jbegin ; 
     653     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ; 
     654     v=ni ; 
     655     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ; 
     656     v=nj ; 
     657     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ; 
     658 
     659     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ; 
     660     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ; 
    661661 
    662662      delete[] ibegin_g ; 
     
    783783     if (type == type_attr::gaussian)  
    784784     { 
    785            hasPole=true ; 
    786              type.setValue(type_attr::unstructured) ; 
    787            } 
    788            else if (type == type_attr::rectilinear) hasPole=true ; 
    789           
     785        hasPole=true ; 
     786        type.setValue(type_attr::unstructured) ; 
     787      } 
     788      else if (type == type_attr::rectilinear) hasPole=true ; 
     789 
    790790     if (type == type_attr::unstructured) 
    791791     { 
     
    10481048      else 
    10491049      { 
    1050                 domainMask.resize(mask_1d.numElements()); 
    1051                 domainMask=mask_1d ; 
    1052           }   
     1050      domainMask.resize(mask_1d.numElements()); 
     1051      domainMask=mask_1d ; 
     1052     } 
    10531053   } 
    10541054 
     
    17121712      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
    17131713      int nbServer = client->serverSize; 
     1714      int nbClient = client->clientSize; 
    17141715      int rank     = client->clientRank; 
    17151716      bool doComputeGlobalIndexServer = true; 
    17161717 
    1717       int i,j,i_ind,j_ind, nbIndex, nbIndexZoom; 
    1718       int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1719       int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1720  
    1721       // Precompute number of index 
    1722       int globalIndexCountZoom = 0; 
    1723       nbIndex = i_index.numElements(); 
    1724  
    1725       if (doZoomByIndex_)  
    1726       { 
    1727         globalIndexCountZoom = zoom_i_index.numElements(); 
    1728       } 
    1729       else  
    1730       { 
    1731         for (i = 0; i < nbIndex; ++i) 
    1732         { 
    1733           i_ind=i_index(i); 
    1734           j_ind=j_index(i); 
    1735  
    1736           if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
    1737           { 
    1738             ++globalIndexCountZoom; 
    1739           } 
    1740         } 
    1741       } 
    1742  
    1743  
    1744       // Fill in index 
    1745       CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom); 
    1746       CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom); 
    1747       CArray<size_t,1> globalIndexDomain(nbIndex); 
    1748       size_t globalIndex; 
    1749       int globalIndexCount = 0; 
    1750  
    1751       for (i = 0; i < nbIndex; ++i) 
    1752       { 
    1753         i_ind=i_index(i); 
    1754         j_ind=j_index(i); 
    1755         globalIndex = i_ind + j_ind * ni_glo; 
    1756         globalIndexDomain(i) = globalIndex;                 
    1757       } 
    1758  
    1759       if (globalLocalIndexMap_.empty()) 
    1760       { 
    1761         for (i = 0; i < nbIndex; ++i) 
    1762           globalLocalIndexMap_[globalIndexDomain(i)] = i; 
    1763       } 
    1764  
    1765       globalIndexCountZoom = 0; 
    1766       if (doZoomByIndex_)  
    1767       { 
    1768         int nbIndexZoom = zoom_i_index.numElements();         
    1769          
    1770         for (i = 0; i < nbIndexZoom; ++i) 
    1771         { 
    1772           i_ind=zoom_i_index(i); 
    1773           j_ind=zoom_j_index(i); 
    1774           globalIndex = i_ind + j_ind * ni_glo; 
    1775           globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
    1776           ++globalIndexCountZoom; 
    1777         } 
    1778       } 
    1779       else  
    1780       { 
    1781           int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1782           int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1783           for (i = 0; i < nbIndex; ++i) 
    1784           { 
     1718      if (indSrv_.find(nbServer) == indSrv_.end()) 
     1719      { 
     1720         int i,j,i_ind,j_ind, nbIndex, nbIndexZoom; 
     1721         int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
     1722         int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
     1723 
     1724         // Precompute number of index 
     1725         int globalIndexCountZoom = 0; 
     1726         nbIndex = i_index.numElements(); 
     1727 
     1728         if (doZoomByIndex_) 
     1729         { 
     1730            globalIndexCountZoom = zoom_i_index.numElements(); 
     1731         } 
     1732         else 
     1733         { 
     1734            for (i = 0; i < nbIndex; ++i) 
     1735            { 
     1736               i_ind=i_index(i); 
     1737               j_ind=j_index(i); 
     1738 
     1739               if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
     1740               { 
     1741                  ++globalIndexCountZoom; 
     1742               } 
     1743            } 
     1744         } 
     1745 
     1746 
     1747         // Fill in index 
     1748         CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom); 
     1749         CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom); 
     1750         CArray<size_t,1> globalIndexDomain(nbIndex); 
     1751         size_t globalIndex; 
     1752         int globalIndexCount = 0; 
     1753 
     1754         for (i = 0; i < nbIndex; ++i) 
     1755         { 
    17851756            i_ind=i_index(i); 
    17861757            j_ind=j_index(i); 
    17871758            globalIndex = i_ind + j_ind * ni_glo; 
    1788             if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
     1759            globalIndexDomain(i) = globalIndex; 
     1760         } 
     1761 
     1762         if (globalLocalIndexMap_.empty()) 
     1763         { 
     1764            for (i = 0; i < nbIndex; ++i) 
     1765               globalLocalIndexMap_[globalIndexDomain(i)] = i; 
     1766         } 
     1767 
     1768         globalIndexCountZoom = 0; 
     1769         if (doZoomByIndex_) 
     1770         { 
     1771            int nbIndexZoom = zoom_i_index.numElements(); 
     1772 
     1773            for (i = 0; i < nbIndexZoom; ++i) 
    17891774            { 
    1790               globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
    1791               ++globalIndexCountZoom; 
     1775               i_ind=zoom_i_index(i); 
     1776               j_ind=zoom_j_index(i); 
     1777               globalIndex = i_ind + j_ind * ni_glo; 
     1778               globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
     1779               ++globalIndexCountZoom; 
    17921780            } 
    1793           } 
    1794  
    1795           int iend = ibegin + ni -1; 
    1796           int jend = jbegin + nj -1; 
    1797           zoom_ibegin = global_zoom_ibegin > ibegin ? global_zoom_ibegin : ibegin; 
    1798           int zoom_iend  = global_zoom_iend < iend ? zoom_iend : iend ; 
    1799           zoom_ni     = zoom_iend-zoom_ibegin+1 ; 
    1800  
    1801           zoom_jbegin = global_zoom_jbegin > jbegin ? global_zoom_jbegin : jbegin ; 
    1802           int zoom_jend   = global_zoom_jend < jend ? zoom_jend : jend; 
    1803           zoom_nj     = zoom_jend-zoom_jbegin+1; 
    1804       } 
    1805  
    1806  
    1807       size_t globalSizeIndex = 1, indexBegin, indexEnd; 
    1808       int range, clientSize = client->clientSize; 
    1809       std::vector<int> nGlobDomain(2); 
    1810       nGlobDomain[0] = this->ni_glo; 
    1811       nGlobDomain[1] = this->nj_glo; 
    1812       for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
    1813       indexBegin = 0; 
    1814       if (globalSizeIndex <= clientSize) 
    1815       { 
    1816         indexBegin = rank%globalSizeIndex; 
    1817         indexEnd = indexBegin; 
    1818       } 
    1819       else 
    1820       { 
    1821         for (int i = 0; i < clientSize; ++i) 
    1822         { 
    1823           range = globalSizeIndex / clientSize; 
    1824           if (i < (globalSizeIndex%clientSize)) ++range; 
    1825           if (i == client->clientRank) break; 
    1826           indexBegin += range; 
    1827         } 
    1828         indexEnd = indexBegin + range - 1; 
    1829       } 
    1830  
    1831        // Even if servers have no index, they must received something from client 
    1832        // We only use several client to send "empty" message to these servers 
    1833       CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
    1834       std::vector<int> serverZeroIndex; 
    1835       if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0); 
    1836       else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1); 
    1837  
    1838        std::list<int> serverZeroIndexLeader; 
    1839        std::list<int> serverZeroIndexNotLeader;  
    1840        CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
    1841        for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1842          *it = serverZeroIndex[*it]; 
    1843  
    1844       CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), 
    1845                                                                                   client->intraComm); 
    1846       clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
    1847       CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
    1848  
    1849       CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
    1850                                                            ite = globalIndexDomainOnServer.end(); 
    1851       indSrv_[client].swap(globalIndexDomainOnServer); 
    1852       connectedServerRank_[client].clear(); 
    1853       for (it = indSrv_[client].begin(); it != ite; ++it)  
    1854         connectedServerRank_[client].push_back(it->first); 
    1855  
    1856       for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1857         connectedServerRank_[client].push_back(*it); 
    1858  
    1859        // Even if a client has no index, it must connect to at least one server and  
    1860        // send an "empty" data to this server 
    1861        if (connectedServerRank_[client].empty()) 
    1862         connectedServerRank_[client].push_back(client->clientRank % client->serverSize); 
    1863  
    1864       nbSenders[client] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
    1865  
    1866       delete clientServerMap; 
     1781         } 
     1782         else 
     1783         { 
     1784            int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
     1785            int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
     1786            for (i = 0; i < nbIndex; ++i) 
     1787            { 
     1788               i_ind=i_index(i); 
     1789               j_ind=j_index(i); 
     1790               globalIndex = i_ind + j_ind * ni_glo; 
     1791               if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend) 
     1792               { 
     1793                  globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
     1794                  ++globalIndexCountZoom; 
     1795               } 
     1796            } 
     1797 
     1798            int iend = ibegin + ni -1; 
     1799            int jend = jbegin + nj -1; 
     1800            zoom_ibegin = global_zoom_ibegin > ibegin ? global_zoom_ibegin : ibegin; 
     1801            int zoom_iend  = global_zoom_iend < iend ? zoom_iend : iend ; 
     1802            zoom_ni     = zoom_iend-zoom_ibegin+1 ; 
     1803 
     1804            zoom_jbegin = global_zoom_jbegin > jbegin ? global_zoom_jbegin : jbegin ; 
     1805            int zoom_jend   = global_zoom_jend < jend ? zoom_jend : jend; 
     1806            zoom_nj     = zoom_jend-zoom_jbegin+1; 
     1807         } 
     1808 
     1809 
     1810         size_t globalSizeIndex = 1, indexBegin, indexEnd; 
     1811         int range, clientSize = client->clientSize; 
     1812         std::vector<int> nGlobDomain(2); 
     1813         nGlobDomain[0] = this->ni_glo; 
     1814         nGlobDomain[1] = this->nj_glo; 
     1815         for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
     1816         indexBegin = 0; 
     1817         if (globalSizeIndex <= clientSize) 
     1818         { 
     1819            indexBegin = rank%globalSizeIndex; 
     1820            indexEnd = indexBegin; 
     1821         } 
     1822         else 
     1823         { 
     1824            for (int i = 0; i < clientSize; ++i) 
     1825            { 
     1826               range = globalSizeIndex / clientSize; 
     1827               if (i < (globalSizeIndex%clientSize)) ++range; 
     1828               if (i == client->clientRank) break; 
     1829               indexBegin += range; 
     1830            } 
     1831            indexEnd = indexBegin + range - 1; 
     1832         } 
     1833 
     1834         // Even if servers have no index, they must received something from client 
     1835         // We only use several client to send "empty" message to these servers 
     1836         CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
     1837         std::vector<int> serverZeroIndex; 
     1838         if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0); 
     1839         else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1); 
     1840 
     1841         std::list<int> serverZeroIndexLeader; 
     1842         std::list<int> serverZeroIndexNotLeader; 
     1843         CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
     1844         for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1845            *it = serverZeroIndex[*it]; 
     1846 
     1847         CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), 
     1848               client->intraComm); 
     1849         clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
     1850         CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
     1851 
     1852         CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
     1853               ite = globalIndexDomainOnServer.end(); 
     1854//         indSrv_[client].swap(globalIndexDomainOnServer); 
     1855//         connectedServerRank_[client].clear(); 
     1856//         for (it = indSrv_[client].begin(); it != ite; ++it) 
     1857//            connectedServerRank_[client].push_back(it->first); 
     1858         indSrv_[nbServer].swap(globalIndexDomainOnServer); 
     1859         connectedServerRank_[nbServer].clear(); 
     1860         for (it = indSrv_[nbServer].begin(); it != ite; ++it) 
     1861            connectedServerRank_[nbServer].push_back(it->first); 
     1862 
     1863         for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1864            connectedServerRank_[nbServer].push_back(*it); 
     1865 
     1866         // Even if a client has no index, it must connect to at least one server and 
     1867        // send an "empty" data to this server 
     1868         if (connectedServerRank_[nbServer].empty()) 
     1869            connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
     1870 
     1871         nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
     1872//         if (connectedServerRank_[client].empty()) 
     1873//            connectedServerRank_[client].push_back(client->clientRank % client->serverSize); 
     1874// 
     1875//         nbSenders[client] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
     1876 
     1877         delete clientServerMap; 
     1878      } 
    18671879    } 
    18681880  } 
     
    20602072    { 
    20612073      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
    2062  
     2074      int serverSize = client->serverSize; 
    20632075      CEventClient eventIndex(getType(), EVENT_ID_INDEX); 
    20642076 
     
    20672079 
    20682080      boost::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex; 
    2069       iteIndex = indSrv_[client].end(); 
    2070       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     2081      iteIndex = indSrv_[serverSize].end(); 
     2082      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    20712083      { 
    20722084        int nbIndGlob = 0; 
    2073         int rank = connectedServerRank_[client][k]; 
    2074         itIndex = indSrv_[client].find(rank); 
     2085        int rank = connectedServerRank_[serverSize][k]; 
     2086        itIndex = indSrv_[serverSize].find(rank); 
    20752087        if (iteIndex != itIndex) 
    20762088          nbIndGlob = itIndex->second.size(); 
     
    20892101        list_msgsIndex.back() << list_indGlob.back(); //list_indi.back() << list_indj.back(); 
    20902102        
    2091         eventIndex.push(rank, nbSenders[client][rank], list_msgsIndex.back()); 
     2103        eventIndex.push(rank, nbSenders[serverSize][rank], list_msgsIndex.back()); 
    20922104      } 
    20932105 
     
    21652177    { 
    21662178      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     2179      int serverSize = client->serverSize; 
    21672180 
    21682181      // send area for each connected server 
     
    21732186 
    21742187      boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    2175       iteMap = indSrv_[client].end(); 
    2176       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     2188      iteMap = indSrv_[serverSize].end(); 
     2189      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    21772190      { 
    21782191        int nbData = 0; 
    2179         int rank = connectedServerRank_[client][k]; 
    2180         it = indSrv_[client].find(rank); 
     2192        int rank = connectedServerRank_[serverSize][k]; 
     2193        it = indSrv_[serverSize].find(rank); 
    21812194        if (iteMap != it) 
    21822195          nbData = it->second.size(); 
     
    21922205        list_msgsMask.push_back(CMessage()); 
    21932206        list_msgsMask.back() << this->getId() << list_mask.back(); 
    2194         eventMask.push(rank, nbSenders[client][rank], list_msgsMask.back()); 
     2207        eventMask.push(rank, nbSenders[serverSize][rank], list_msgsMask.back()); 
    21952208      } 
    21962209      client->sendEvent(eventMask); 
     
    22132226    { 
    22142227      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     2228      int serverSize = client->serverSize; 
    22152229 
    22162230      // send area for each connected server 
     
    22212235 
    22222236      boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    2223       iteMap = indSrv_[client].end(); 
    2224       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     2237      iteMap = indSrv_[serverSize].end(); 
     2238      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    22252239      { 
    22262240        int nbData = 0; 
    2227         int rank = connectedServerRank_[client][k]; 
    2228         it = indSrv_[client].find(rank); 
     2241        int rank = connectedServerRank_[serverSize][k]; 
     2242        it = indSrv_[serverSize].find(rank); 
    22292243        if (iteMap != it) 
    22302244          nbData = it->second.size(); 
     
    22412255        list_msgsArea.back() << this->getId() << hasArea; 
    22422256        list_msgsArea.back() << list_area.back(); 
    2243         eventArea.push(rank, nbSenders[client][rank], list_msgsArea.back()); 
     2257        eventArea.push(rank, nbSenders[serverSize][rank], list_msgsArea.back()); 
    22442258      } 
    22452259      client->sendEvent(eventArea); 
     
    22642278    { 
    22652279      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     2280      int serverSize = client->serverSize; 
    22662281 
    22672282      // send lon lat for each connected server 
     
    22742289 
    22752290      boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    2276       iteMap = indSrv_[client].end(); 
    2277       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     2291      iteMap = indSrv_[serverSize].end(); 
     2292      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    22782293      { 
    22792294        int nbData = 0; 
    2280         int rank = connectedServerRank_[client][k]; 
    2281         it = indSrv_[client].find(rank); 
     2295        int rank = connectedServerRank_[serverSize][k]; 
     2296        it = indSrv_[serverSize].find(rank); 
    22822297        if (iteMap != it) 
    22832298          nbData = it->second.size(); 
     
    23362351        } 
    23372352 
    2338         eventLon.push(rank, nbSenders[client][rank], list_msgsLon.back()); 
    2339         eventLat.push(rank, nbSenders[client][rank], list_msgsLat.back()); 
     2353        eventLon.push(rank, nbSenders[serverSize][rank], list_msgsLon.back()); 
     2354        eventLat.push(rank, nbSenders[serverSize][rank], list_msgsLat.back()); 
    23402355      } 
    23412356      client->sendEvent(eventLon); 
     
    23602375    { 
    23612376      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client; 
     2377      int serverSize = client->serverSize; 
    23622378 
    23632379      // send area for each connected server 
     
    23922408 
    23932409      boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap; 
    2394       iteMap = indSrv_[client].end(); 
    2395       for (int k = 0; k < connectedServerRank_[client].size(); ++k) 
     2410      iteMap = indSrv_[serverSize].end(); 
     2411      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k) 
    23962412      { 
    23972413        int nbData = 0; 
    2398         int rank = connectedServerRank_[client][k]; 
    2399         it = indSrv_[client].find(rank); 
     2414        int rank = connectedServerRank_[serverSize][k]; 
     2415        it = indSrv_[serverSize].find(rank); 
    24002416        if (iteMap != it) 
    24012417          nbData = it->second.size(); 
     
    24152431        list_msgsDataIndex.back() << this->getId(); 
    24162432        list_msgsDataIndex.back() << list_data_i_index.back() << list_data_j_index.back(); 
    2417         eventDataIndex.push(rank, nbSenders[client][rank], list_msgsDataIndex.back()); 
     2433        eventDataIndex.push(rank, nbSenders[serverSize][rank], list_msgsDataIndex.back()); 
    24182434      } 
    24192435      client->sendEvent(eventDataIndex); 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/domain.hpp

    r1330 r1337  
    205205         bool isClientAfterTransformationChecked; 
    206206         std::map<int, CArray<int,1> > indGlob_; 
    207          std::map<CContextClient*, map<int,int> > nbSenders; // Mapping of number of communicating client to a server 
    208  
    209          std::map<CContextClient*, boost::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server          
     207         std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server 
     208 
     209/** Global index of each client sent to server: map<serverSize, map<serverRank, indexes>> */ 
     210         std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_; 
    210211         // std::map<CContextClient*, std::map<int, vector<int> > > indWrittenSrv_; // Global written index of each client sent to server 
    211212         std::vector<int> indexesToWrite; 
     
    213214         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
    214215         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer;      
    215          std::map<CContextClient*, std::map<int,size_t> > connectedDataSize_; 
    216          std::map<CContextClient*, std::vector<int> > connectedServerRank_; 
     216         std::map<int, std::map<int,size_t> > connectedDataSize_; 
     217         std::map<int, std::vector<int> > connectedServerRank_; 
    217218 
    218219         //! True if and only if the data defined on the domain can be outputted in a compressed way 
Note: See TracChangeset for help on using the changeset viewer.