Changeset 1346


Ignore:
Timestamp:
11/25/17 00:19:11 (3 years ago)
Author:
oabramkina
Message:

Fixing a bug introduced in r1337.

toy_cnrmcm: ok.

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

Legend:

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

    r1345 r1346  
    530530      int rank = client->clientRank; 
    531531 
    532       size_t ni = this->n.getValue(); 
    533       size_t ibegin = this->begin.getValue(); 
    534       size_t global_zoom_end = global_zoom_begin+global_zoom_n-1; 
    535       size_t nZoomCount = 0; 
    536       size_t nbIndex = index.numElements(); 
    537  
    538       // First of all, we should compute the mapping of the global index and local index of the current client 
    539       if (globalLocalIndexMap_.empty()) 
    540       { 
    541         for (size_t idx = 0; idx < nbIndex; ++idx) 
    542         { 
    543           globalLocalIndexMap_[index(idx)] = idx; 
    544         } 
    545       } 
    546  
    547       // Calculate the compressed index if any 
    548       std::set<int> writtenInd; 
    549       if (isCompressible_) 
    550       { 
    551         for (int idx = 0; idx < data_index.numElements(); ++idx) 
    552         { 
    553           int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni); 
    554  
    555           if (ind >= 0 && ind < ni && mask(ind)) 
     532      if (connectedServerRank_.find(nbServer) == connectedServerRank_.end()) 
     533      { 
     534        size_t ni = this->n.getValue(); 
     535        size_t ibegin = this->begin.getValue(); 
     536        size_t global_zoom_end = global_zoom_begin+global_zoom_n-1; 
     537        size_t nZoomCount = 0; 
     538        size_t nbIndex = index.numElements(); 
     539 
     540        // First of all, we should compute the mapping of the global index and local index of the current client 
     541        if (globalLocalIndexMap_.empty()) 
     542        { 
     543          for (size_t idx = 0; idx < nbIndex; ++idx) 
    556544          { 
    557             ind += ibegin; 
    558             if (ind >= global_zoom_begin && ind <= global_zoom_end) 
    559               writtenInd.insert(ind); 
     545            globalLocalIndexMap_[index(idx)] = idx; 
    560546          } 
    561547        } 
    562       } 
    563  
    564       // Compute the global index of the current client (process) hold 
    565       std::vector<int> nGlobAxis(1); 
    566       nGlobAxis[0] = n_glo.getValue(); 
    567  
    568       size_t globalSizeIndex = 1, indexBegin, indexEnd; 
    569       for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[i]; 
    570       indexBegin = 0; 
    571       if (globalSizeIndex <= clientSize) 
    572       { 
    573         indexBegin = rank%globalSizeIndex; 
    574         indexEnd = indexBegin; 
    575       } 
    576       else 
    577       { 
    578         for (int i = 0; i < clientSize; ++i) 
    579         { 
    580           range = globalSizeIndex / clientSize; 
    581           if (i < (globalSizeIndex%clientSize)) ++range; 
    582           if (i == client->clientRank) break; 
    583           indexBegin += range; 
    584         } 
    585         indexEnd = indexBegin + range - 1; 
    586       } 
    587  
    588       CArray<size_t,1> globalIndex(index.numElements()); 
    589       for (size_t idx = 0; idx < globalIndex.numElements(); ++idx) 
    590         globalIndex(idx) = index(idx); 
    591  
    592       // Describe the distribution of server side 
    593  
    594       CServerDistributionDescription serverDescription(nGlobAxis, nbServer, distType); 
     548 
     549        // Calculate the compressed index if any 
     550        std::set<int> writtenInd; 
     551        if (isCompressible_) 
     552        { 
     553          for (int idx = 0; idx < data_index.numElements(); ++idx) 
     554          { 
     555            int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni); 
     556 
     557            if (ind >= 0 && ind < ni && mask(ind)) 
     558            { 
     559              ind += ibegin; 
     560              if (ind >= global_zoom_begin && ind <= global_zoom_end) 
     561                writtenInd.insert(ind); 
     562            } 
     563          } 
     564        } 
     565 
     566        // Compute the global index of the current client (process) hold 
     567        std::vector<int> nGlobAxis(1); 
     568        nGlobAxis[0] = n_glo.getValue(); 
     569 
     570        size_t globalSizeIndex = 1, indexBegin, indexEnd; 
     571        for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[i]; 
     572        indexBegin = 0; 
     573        if (globalSizeIndex <= clientSize) 
     574        { 
     575          indexBegin = rank%globalSizeIndex; 
     576          indexEnd = indexBegin; 
     577        } 
     578        else 
     579        { 
     580          for (int i = 0; i < clientSize; ++i) 
     581          { 
     582            range = globalSizeIndex / clientSize; 
     583            if (i < (globalSizeIndex%clientSize)) ++range; 
     584            if (i == client->clientRank) break; 
     585            indexBegin += range; 
     586          } 
     587          indexEnd = indexBegin + range - 1; 
     588        } 
     589 
     590        CArray<size_t,1> globalIndex(index.numElements()); 
     591        for (size_t idx = 0; idx < globalIndex.numElements(); ++idx) 
     592          globalIndex(idx) = index(idx); 
     593 
     594        // Describe the distribution of server side 
     595 
     596        CServerDistributionDescription serverDescription(nGlobAxis, nbServer, distType); 
    595597       
    596       std::vector<int> serverZeroIndex; 
    597       serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);       
    598  
    599       std::list<int> serverZeroIndexLeader; 
    600       std::list<int> serverZeroIndexNotLeader;  
    601       CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
    602       for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    603         *it = serverZeroIndex[*it]; 
    604  
    605       // Find out the connection between client and server side 
    606       CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm); 
    607       clientServerMap->computeServerIndexMapping(globalIndex, nbServer); 
    608       CClientServerMapping::GlobalIndexMap& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();       
    609  
    610  
    611       indSrv_[nbServer].swap(globalIndexAxisOnServer); 
    612  
    613       if (distType==CServerDistributionDescription::ROOT_DISTRIBUTION) 
    614       { 
    615         for(int i=1; i<nbServer; ++i) indSrv_[nbServer].insert(pair<int, vector<size_t> >(i,indSrv_[nbServer][0]) ) ; 
    616         serverZeroIndexLeader.clear() ; 
    617       } 
     598        std::vector<int> serverZeroIndex; 
     599        serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);       
     600 
     601        std::list<int> serverZeroIndexLeader; 
     602        std::list<int> serverZeroIndexNotLeader;  
     603        CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
     604        for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     605          *it = serverZeroIndex[*it]; 
     606 
     607        // Find out the connection between client and server side 
     608        CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm); 
     609        clientServerMap->computeServerIndexMapping(globalIndex, nbServer); 
     610        CClientServerMapping::GlobalIndexMap& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();       
     611 
     612        indSrv_[nbServer].swap(globalIndexAxisOnServer); 
     613 
     614        if (distType==CServerDistributionDescription::ROOT_DISTRIBUTION) 
     615        { 
     616          for(int i=1; i<nbServer; ++i) indSrv_[nbServer].insert(pair<int, vector<size_t> >(i,indSrv_[nbServer][0]) ) ; 
     617          serverZeroIndexLeader.clear() ; 
     618        } 
    618619          
    619       CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_[nbServer].begin(), 
    620                                                            ite = indSrv_[nbServer].end(); 
    621  
    622       for (it = indSrv_[nbServer].begin(); it != ite; ++it) connectedServerRank_[nbServer].push_back(it->first); 
    623  
    624       for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    625         connectedServerRank_[nbServer].push_back(*it); 
    626  
    627        // Even if a client has no index, it must connect to at least one server and  
    628        // send an "empty" data to this server 
    629        if (connectedServerRank_[nbServer].empty()) 
    630         connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
    631  
    632 //       nbSenders[client] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
    633        nbSenders[nbServer] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
    634  
    635       delete clientServerMap; 
     620        CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_[nbServer].begin(), 
     621                                                             ite = indSrv_[nbServer].end(); 
     622 
     623        for (it = indSrv_[nbServer].begin(); it != ite; ++it) connectedServerRank_[nbServer].push_back(it->first); 
     624 
     625        for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     626          connectedServerRank_[nbServer].push_back(*it); 
     627 
     628         // Even if a client has no index, it must connect to at least one server and  
     629         // send an "empty" data to this server 
     630         if (connectedServerRank_[nbServer].empty()) 
     631          connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
     632 
     633         nbSenders[nbServer] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
     634 
     635        delete clientServerMap; 
     636      } 
    636637    } 
    637638  } 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/domain.cpp

    r1345 r1346  
    17181718      bool doComputeGlobalIndexServer = true; 
    17191719 
    1720       if (indSrv_.find(nbServer) == indSrv_.end()) 
    1721       { 
    1722          int i,j,i_ind,j_ind, nbIndex, nbIndexZoom; 
    1723          int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1724          int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1725  
    1726          // Precompute number of index 
    1727          int globalIndexCountZoom = 0; 
    1728          nbIndex = i_index.numElements(); 
    1729  
    1730          if (doZoomByIndex_) 
    1731          { 
    1732             globalIndexCountZoom = zoom_i_index.numElements(); 
    1733          } 
    1734          else 
    1735          { 
    1736             for (i = 0; i < nbIndex; ++i) 
    1737             { 
     1720      if (connectedServerRank_.find(nbServer) == connectedServerRank_.end()) 
     1721      { 
     1722 
     1723        if (indSrv_.find(nbServer) == indSrv_.end()) 
     1724        { 
     1725          int i,j,i_ind,j_ind, nbIndex, nbIndexZoom; 
     1726          int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
     1727          int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
     1728 
     1729           // Precompute number of index 
     1730           int globalIndexCountZoom = 0; 
     1731           nbIndex = i_index.numElements(); 
     1732 
     1733           if (doZoomByIndex_) 
     1734           { 
     1735             globalIndexCountZoom = zoom_i_index.numElements(); 
     1736           } 
     1737           else 
     1738           { 
     1739             for (i = 0; i < nbIndex; ++i) 
     1740             { 
    17381741               i_ind=i_index(i); 
    17391742               j_ind=j_index(i); 
     
    17431746                  ++globalIndexCountZoom; 
    17441747               } 
    1745             } 
    1746          } 
    1747  
    1748  
    1749          // Fill in index 
    1750          CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom); 
    1751          CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom); 
    1752          CArray<size_t,1> globalIndexDomain(nbIndex); 
    1753          size_t globalIndex; 
    1754          int globalIndexCount = 0; 
    1755  
    1756          for (i = 0; i < nbIndex; ++i) 
    1757          { 
    1758             i_ind=i_index(i); 
    1759             j_ind=j_index(i); 
    1760             globalIndex = i_ind + j_ind * ni_glo; 
    1761             globalIndexDomain(i) = globalIndex; 
    1762          } 
    1763  
    1764          if (globalLocalIndexMap_.empty()) 
    1765          { 
    1766             for (i = 0; i < nbIndex; ++i) 
     1748             } 
     1749           } 
     1750 
     1751           // Fill in index 
     1752           CArray<size_t,1> globalIndexDomainZoom(globalIndexCountZoom); 
     1753           CArray<size_t,1> localIndexDomainZoom(globalIndexCountZoom); 
     1754           CArray<size_t,1> globalIndexDomain(nbIndex); 
     1755           size_t globalIndex; 
     1756           int globalIndexCount = 0; 
     1757 
     1758           for (i = 0; i < nbIndex; ++i) 
     1759           { 
     1760             i_ind=i_index(i); 
     1761             j_ind=j_index(i); 
     1762             globalIndex = i_ind + j_ind * ni_glo; 
     1763             globalIndexDomain(i) = globalIndex; 
     1764           } 
     1765 
     1766           if (globalLocalIndexMap_.empty()) 
     1767           { 
     1768             for (i = 0; i < nbIndex; ++i) 
    17671769               globalLocalIndexMap_[globalIndexDomain(i)] = i; 
    1768          } 
    1769  
    1770          globalIndexCountZoom = 0; 
    1771          if (doZoomByIndex_) 
    1772          { 
    1773             int nbIndexZoom = zoom_i_index.numElements(); 
    1774  
    1775             for (i = 0; i < nbIndexZoom; ++i) 
    1776             { 
     1770           } 
     1771 
     1772           globalIndexCountZoom = 0; 
     1773           if (doZoomByIndex_) 
     1774           { 
     1775             int nbIndexZoom = zoom_i_index.numElements(); 
     1776 
     1777             for (i = 0; i < nbIndexZoom; ++i) 
     1778             { 
    17771779               i_ind=zoom_i_index(i); 
    17781780               j_ind=zoom_j_index(i); 
     
    17801782               globalIndexDomainZoom(globalIndexCountZoom) = globalIndex; 
    17811783               ++globalIndexCountZoom; 
    1782             } 
    1783          } 
    1784          else 
    1785          { 
    1786             int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
    1787             int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
    1788             for (i = 0; i < nbIndex; ++i) 
    1789             { 
     1784             } 
     1785           } 
     1786           else 
     1787           { 
     1788             int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1; 
     1789             int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1; 
     1790             for (i = 0; i < nbIndex; ++i) 
     1791             { 
    17901792               i_ind=i_index(i); 
    17911793               j_ind=j_index(i); 
     
    17961798                  ++globalIndexCountZoom; 
    17971799               } 
    1798             } 
    1799  
    1800             int iend = ibegin + ni -1; 
    1801             int jend = jbegin + nj -1; 
    1802             zoom_ibegin = global_zoom_ibegin > ibegin ? global_zoom_ibegin : ibegin; 
    1803             int zoom_iend  = global_zoom_iend < iend ? zoom_iend : iend ; 
    1804             zoom_ni     = zoom_iend-zoom_ibegin+1 ; 
    1805  
    1806             zoom_jbegin = global_zoom_jbegin > jbegin ? global_zoom_jbegin : jbegin ; 
    1807             int zoom_jend   = global_zoom_jend < jend ? zoom_jend : jend; 
    1808             zoom_nj     = zoom_jend-zoom_jbegin+1; 
    1809          } 
    1810  
    1811  
    1812          size_t globalSizeIndex = 1, indexBegin, indexEnd; 
    1813          int range, clientSize = client->clientSize; 
    1814          std::vector<int> nGlobDomain(2); 
    1815          nGlobDomain[0] = this->ni_glo; 
    1816          nGlobDomain[1] = this->nj_glo; 
    1817          for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
    1818          indexBegin = 0; 
    1819          if (globalSizeIndex <= clientSize) 
    1820          { 
    1821             indexBegin = rank%globalSizeIndex; 
    1822             indexEnd = indexBegin; 
    1823          } 
    1824          else 
    1825          { 
    1826             for (int i = 0; i < clientSize; ++i) 
    1827             { 
     1800             } 
     1801 
     1802             int iend = ibegin + ni -1; 
     1803             int jend = jbegin + nj -1; 
     1804             zoom_ibegin = global_zoom_ibegin > ibegin ? global_zoom_ibegin : ibegin; 
     1805             int zoom_iend  = global_zoom_iend < iend ? zoom_iend : iend ; 
     1806             zoom_ni     = zoom_iend-zoom_ibegin+1 ; 
     1807 
     1808             zoom_jbegin = global_zoom_jbegin > jbegin ? global_zoom_jbegin : jbegin ; 
     1809             int zoom_jend   = global_zoom_jend < jend ? zoom_jend : jend; 
     1810             zoom_nj     = zoom_jend-zoom_jbegin+1; 
     1811           } 
     1812 
     1813           size_t globalSizeIndex = 1, indexBegin, indexEnd; 
     1814           int range, clientSize = client->clientSize; 
     1815           std::vector<int> nGlobDomain(2); 
     1816           nGlobDomain[0] = this->ni_glo; 
     1817           nGlobDomain[1] = this->nj_glo; 
     1818           for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[i]; 
     1819           indexBegin = 0; 
     1820           if (globalSizeIndex <= clientSize) 
     1821           { 
     1822             indexBegin = rank%globalSizeIndex; 
     1823             indexEnd = indexBegin; 
     1824           } 
     1825           else 
     1826           { 
     1827             for (int i = 0; i < clientSize; ++i) 
     1828             { 
    18281829               range = globalSizeIndex / clientSize; 
    18291830               if (i < (globalSizeIndex%clientSize)) ++range; 
    18301831               if (i == client->clientRank) break; 
    18311832               indexBegin += range; 
    1832             } 
    1833             indexEnd = indexBegin + range - 1; 
    1834          } 
    1835  
    1836          // Even if servers have no index, they must received something from client 
    1837          // We only use several client to send "empty" message to these servers 
    1838          CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
    1839          std::vector<int> serverZeroIndex; 
    1840          if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0); 
    1841          else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1); 
    1842  
    1843          std::list<int> serverZeroIndexLeader; 
    1844          std::list<int> serverZeroIndexNotLeader; 
    1845          CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
    1846          for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1847             *it = serverZeroIndex[*it]; 
    1848  
    1849          CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), 
    1850                client->intraComm); 
    1851          clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
    1852          CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
    1853  
    1854          CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
    1855                ite = globalIndexDomainOnServer.end(); 
    1856 //         indSrv_[client].swap(globalIndexDomainOnServer); 
    1857 //         connectedServerRank_[client].clear(); 
    1858 //         for (it = indSrv_[client].begin(); it != ite; ++it) 
    1859 //            connectedServerRank_[client].push_back(it->first); 
    1860          indSrv_[nbServer].swap(globalIndexDomainOnServer); 
    1861          connectedServerRank_[nbServer].clear(); 
    1862          for (it = indSrv_[nbServer].begin(); it != ite; ++it) 
    1863             connectedServerRank_[nbServer].push_back(it->first); 
    1864  
    1865          for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
    1866             connectedServerRank_[nbServer].push_back(*it); 
    1867  
    1868          // Even if a client has no index, it must connect to at least one server and 
    1869         // send an "empty" data to this server 
    1870          if (connectedServerRank_[nbServer].empty()) 
    1871             connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
    1872  
    1873          nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
    1874 //         if (connectedServerRank_[client].empty()) 
    1875 //            connectedServerRank_[client].push_back(client->clientRank % client->serverSize); 
    1876 // 
    1877 //         nbSenders[client] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[client]); 
    1878  
    1879          delete clientServerMap; 
     1833             } 
     1834             indexEnd = indexBegin + range - 1; 
     1835           } 
     1836 
     1837           // Even if servers have no index, they must received something from client 
     1838           // We only use several client to send "empty" message to these servers 
     1839           CServerDistributionDescription serverDescription(nGlobDomain, nbServer); 
     1840           std::vector<int> serverZeroIndex; 
     1841           if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0); 
     1842           else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1); 
     1843 
     1844           std::list<int> serverZeroIndexLeader; 
     1845           std::list<int> serverZeroIndexNotLeader; 
     1846           CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader); 
     1847           for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1848              *it = serverZeroIndex[*it]; 
     1849 
     1850           CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), 
     1851                 client->intraComm); 
     1852           clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer); 
     1853           CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
     1854 
     1855           CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(), 
     1856                 ite = globalIndexDomainOnServer.end(); 
     1857           indSrv_[nbServer].swap(globalIndexDomainOnServer); 
     1858           connectedServerRank_[nbServer].clear(); 
     1859           for (it = indSrv_[nbServer].begin(); it != ite; ++it) 
     1860             connectedServerRank_[nbServer].push_back(it->first); 
     1861 
     1862           for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it) 
     1863              connectedServerRank_[nbServer].push_back(*it); 
     1864 
     1865           // Even if a client has no index, it must connect to at least one server and 
     1866           // send an "empty" data to this server 
     1867           if (connectedServerRank_[nbServer].empty()) 
     1868              connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize); 
     1869 
     1870           nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]); 
     1871           delete clientServerMap; 
     1872        } 
    18801873      } 
    18811874    } 
Note: See TracChangeset for help on using the changeset viewer.