Changeset 1249


Ignore:
Timestamp:
08/30/17 15:33:51 (3 years ago)
Author:
mhnguyen
Message:

Various bug fixes on mask and zoom

+) Rearrange local index on the receiving side to be coherent global index
+) Include masking information in compress data (data_index) on the receiving side
+) Correct zoom to work in case there are several (not all) processes participating to write data

Test
+) On Curie
+) Simple test

Location:
XIOS/dev/XIOS_DEV_CMIP6/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/XIOS_DEV_CMIP6/src/config/domain_attribute.conf

    r1158 r1249  
    2222/* LOCAL */ 
    2323DECLARE_ARRAY(bool, 1 , mask_1d, false) 
    24 DECLARE_ARRAY(bool, 2 , mask_2d) 
     24DECLARE_ARRAY(bool, 2 , mask_2d, false) 
    2525 
    2626/* GLOBAL */ 
  • XIOS/dev/XIOS_DEV_CMIP6/src/filter/source_filter.cpp

    r1242 r1249  
    3333 
    3434    packet->data.resize(grid->storeIndex_client.numElements()); 
    35     if (compression) grid->inputField(data, packet->data) ; 
    36     else 
    37     { 
    38       // just make a flat copy 
    39       CArray<double, N> data_tmp(data.copy()) ; // supress const attribute 
    40       CArray<double,1> dataTmp2(data_tmp.dataFirst(),shape(data.numElements()),neverDeleteData) ; 
    41       packet->data = dataTmp2 ; 
    42     } 
     35    grid->inputField(data, packet->data) ; 
     36    // if (compression) grid->inputField(data, packet->data) ; 
     37    // else 
     38    // { 
     39    //   // just make a flat copy 
     40    //   CArray<double, N> data_tmp(data.copy()) ; // supress const attribute 
     41    //   CArray<double,1> dataTmp2(data_tmp.dataFirst(),shape(data.numElements()),neverDeleteData) ; 
     42    //   packet->data = dataTmp2 ; 
     43    // } 
    4344    // Convert missing values to NaN 
    4445    if (hasMissingValue) 
     
    7273    packet->timestamp = date; 
    7374    packet->status = CDataPacket::NO_ERROR; 
    74  
    75     // if (data.size() != grid->storeIndex_toSrv.size()) 
     75     
    7676    if (data.size() != grid->storeIndex_fromSrv.size()) 
    7777      ERROR("CSourceFilter::streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data)", 
     
    8282    std::map<int, CArray<double, 1> >::const_iterator it, itEnd = data.end(); 
    8383    for (it = data.begin(); it != itEnd; it++) 
    84     { 
    85       // CArray<int,1>& index = grid->storeIndex_toSrv[it->first]; 
     84    {       
    8685      CArray<int,1>& index = grid->storeIndex_fromSrv[it->first]; 
    8786      for (int n = 0; n < index.numElements(); n++) 
  • XIOS/dev/XIOS_DEV_CMIP6/src/io/nc4_data_output.cpp

    r1235 r1249  
    5454      { 
    5555        domain->computeWrittenIndex(); 
     56        domain->computeWrittenCompressedIndex(comm_file); 
     57 
    5658        if (domain->type == CDomain::type_attr::unstructured) 
    5759        { 
     
    11331135 
    11341136        axis->computeWrittenIndex(); 
     1137        axis->computeWrittenCompressedIndex(comm_file); 
    11351138        
    11361139        int zoom_size  = (MULTI_FILE == SuperClass::type) ? axis->zoom_n 
     
    11871190 
    11881191            StdString axisBoundsId = axisid + "_bounds"; 
    1189             if (!axis->bounds.isEmpty()) 
     1192            if (!axis->bounds.isEmpty() && axis->label.isEmpty()) 
    11901193            { 
    11911194              dims.push_back("axis_nbounds"); 
     
    14881491               } 
    14891492 
    1490                indexes.resize(domain->compressedIndexToWriteOnServer.numElements()); 
    1491                indexes = domain->compressedIndexToWriteOnServer; 
     1493               // indexes.resize(domain->compressedIndexToWriteOnServer[comm_file].numElements()); 
     1494               // indexes = domain->compressedIndexToWriteOnServer[com_file]; 
     1495               indexes.resize(domain->getCompressedIndexToWriteOnServer(comm_file).numElements()); 
     1496               indexes = domain->getCompressedIndexToWriteOnServer(comm_file); 
    14921497 
    14931498               isDistributed = domain->isDistributed(); 
    1494                nbIndexes = domain->getNumberWrittenIndexes(); 
    1495                totalNbIndexes = domain->getTotalNumberWrittenIndexes(); 
    1496                offset = domain->getOffsetWrittenIndexes(); 
     1499               nbIndexes = domain->getNumberWrittenIndexes(comm_file); 
     1500               totalNbIndexes = domain->getTotalNumberWrittenIndexes(comm_file); 
     1501               offset = domain->getOffsetWrittenIndexes(comm_file); 
    14971502               firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo; 
    14981503 
     
    15141519               compress = axisId; 
    15151520 
    1516                indexes.resize(axis->compressedIndexToWriteOnServer.numElements()); 
    1517                indexes = axis->compressedIndexToWriteOnServer; 
     1521               // indexes.resize(axis->compressedIndexToWriteOnServer.numElements()); 
     1522               // indexes = axis->compressedIndexToWriteOnServer; 
     1523 
     1524               indexes.resize(axis->getCompressedIndexToWriteOnServer(comm_file).numElements()); 
     1525               indexes = axis->getCompressedIndexToWriteOnServer(comm_file); 
    15181526 
    15191527               isDistributed = axis->isDistributed(); 
    1520                nbIndexes = axis->getNumberWrittenIndexes(); 
    1521                totalNbIndexes = axis->getTotalNumberWrittenIndexes(); 
    1522                offset = axis->getOffsetWrittenIndexes(); 
     1528               nbIndexes = axis->getNumberWrittenIndexes(comm_file); 
     1529               totalNbIndexes = axis->getTotalNumberWrittenIndexes(comm_file); 
     1530               offset = axis->getOffsetWrittenIndexes(comm_file); 
    15231531               firstGlobalIndex = axis->begin; 
    15241532 
     
    22912299                        if (domain->isCompressible()) 
    22922300                        { 
    2293                           start.push_back(domain->getOffsetWrittenIndexes()); 
    2294                           count.push_back(domain->getNumberWrittenIndexes()); 
     2301                          start.push_back(domain->getOffsetWrittenIndexes(comm_file)); 
     2302                          count.push_back(domain->getNumberWrittenIndexes(comm_file)); 
    22952303                          idx -= 2; 
    22962304                        } 
     
    23152323                        if (axis->isCompressible()) 
    23162324                        { 
    2317                           start.push_back(axis->getOffsetWrittenIndexes()); 
    2318                           count.push_back(axis->getNumberWrittenIndexes()); 
     2325                          start.push_back(axis->getOffsetWrittenIndexes(comm_file)); 
     2326                          count.push_back(axis->getNumberWrittenIndexes(comm_file)); 
    23192327                        } 
    23202328                        else 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/axis.cpp

    r1236 r1249  
    2323      , isClientAfterTransformationChecked(false) 
    2424      , hasBounds(false), isCompressible_(false) 
    25       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
     25      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_() 
    2626      , transformationMap_(), hasValue(false), hasLabel(false) 
    2727      , computedWrittenIndex_(false) 
     
    3434      , isClientAfterTransformationChecked(false) 
    3535      , hasBounds(false), isCompressible_(false) 
    36       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
     36      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_() 
    3737      , transformationMap_(), hasValue(false), hasLabel(false) 
    3838      , computedWrittenIndex_(false) 
     
    107107     \return the number of indexes written by each server 
    108108   */ 
    109    int CAxis::getNumberWrittenIndexes() const 
    110    { 
    111      return numberWrittenIndexes_; 
     109   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     110   { 
     111     int writtenSize; 
     112     MPI_Comm_size(writtenCom, &writtenSize); 
     113     return numberWrittenIndexes_[writtenSize]; 
    112114   } 
    113115 
     
    116118     \return the total number of indexes written by the servers 
    117119   */ 
    118    int CAxis::getTotalNumberWrittenIndexes() const 
    119    { 
    120      return totalNumberWrittenIndexes_; 
     120   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     121   { 
     122     int writtenSize; 
     123     MPI_Comm_size(writtenCom, &writtenSize); 
     124     return totalNumberWrittenIndexes_[writtenSize]; 
    121125   } 
    122126 
     
    125129     \return the offset of indexes written by each server 
    126130   */ 
    127    int CAxis::getOffsetWrittenIndexes() const 
    128    { 
    129      return offsetWrittenIndexes_; 
    130    } 
    131  
     131   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     132   { 
     133     int writtenSize; 
     134     MPI_Comm_size(writtenCom, &writtenSize); 
     135     return offsetWrittenIndexes_[writtenSize]; 
     136   } 
     137 
     138   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     139   { 
     140     int writtenSize; 
     141     MPI_Comm_size(writtenCom, &writtenSize); 
     142     return compressedIndexToWriteOnServer[writtenSize]; 
     143   } 
    132144   //---------------------------------------------------------------- 
    133145 
     
    692704    } 
    693705 
     706    // if (isCompressible()) 
     707    // { 
     708    //   nbWritten = 0; 
     709    //   boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     710    //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     711    //   { 
     712    //     indGlo = *itSrv; 
     713    //     if (ite != globalLocalIndexMap_.find(indGlo)) 
     714    //     { 
     715    //       localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo; 
     716    //       ++nbWritten; 
     717    //     }                  
     718    //   } 
     719 
     720    //   nbWritten = 0; 
     721    //   for (int idx = 0; idx < data_index.numElements(); ++idx) 
     722    //   { 
     723    //     if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx))) 
     724    //     { 
     725    //       ++nbWritten; 
     726    //     } 
     727    //   } 
     728 
     729    //   compressedIndexToWriteOnServer.resize(nbWritten); 
     730    //   nbWritten = 0; 
     731    //   for (int idx = 0; idx < data_index.numElements(); ++idx) 
     732    //   { 
     733    //     if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx))) 
     734    //     { 
     735    //       compressedIndexToWriteOnServer(nbWritten) = localGlobalIndexMap[data_index(idx)]; 
     736    //       ++nbWritten; 
     737    //     } 
     738    //   } 
     739 
     740    //   numberWrittenIndexes_ = nbWritten; 
     741    //   if (isDistributed()) 
     742    //   { 
     743              
     744    //     MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     745    //     MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     746    //     offsetWrittenIndexes_ -= numberWrittenIndexes_; 
     747    //   } 
     748    //   else 
     749    //     totalNumberWrittenIndexes_ = numberWrittenIndexes_; 
     750    // } 
     751  } 
     752 
     753  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     754  { 
     755    int writtenCommSize; 
     756    MPI_Comm_size(writtenComm, &writtenCommSize); 
     757    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
     758      return; 
     759 
    694760    if (isCompressible()) 
    695761    { 
    696       nbWritten = 0; 
     762      size_t nbWritten = 0, indGlo; 
     763      CContext* context=CContext::getCurrent();       
     764      CContextServer* server = context->server;  
     765 
     766      // We describe the distribution of client (server) on which data are written 
     767      std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1); 
     768      nBegin[0]       = zoom_begin; 
     769      nSize[0]        = zoom_n;    
     770      nBeginGlobal[0] = 0;  
     771      nGlob[0]        = n_glo; 
     772      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);  
     773      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
     774      boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     775                                                          ite = globalLocalIndexMap_.end(), it;    
     776 
     777      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
     778                                       itSrve = writtenGlobalIndex.end(), itSrv; 
    697779      boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
    698780      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     
    715797      } 
    716798 
    717       compressedIndexToWriteOnServer.resize(nbWritten); 
     799      compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten); 
    718800      nbWritten = 0; 
    719801      for (int idx = 0; idx < data_index.numElements(); ++idx) 
     
    721803        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx))) 
    722804        { 
    723           compressedIndexToWriteOnServer(nbWritten) = localGlobalIndexMap[data_index(idx)]; 
     805          compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_index(idx)]; 
    724806          ++nbWritten; 
    725807        } 
    726808      } 
    727809 
    728       numberWrittenIndexes_ = nbWritten; 
     810      numberWrittenIndexes_[writtenCommSize] = nbWritten; 
    729811      if (isDistributed()) 
    730812      { 
    731813              
    732         MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    733         MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    734         offsetWrittenIndexes_ -= numberWrittenIndexes_; 
     814        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     815        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     816        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
    735817      } 
    736818      else 
    737         totalNumberWrittenIndexes_ = numberWrittenIndexes_; 
    738     } 
    739   } 
    740  
     819        totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize]; 
     820    } 
     821  } 
    741822 
    742823  /*! 
     
    853934    if (zoom_n<=0) 
    854935    { 
    855       zoom_begin = 0; zoom_n = 0; 
     936      zoom_n = 0; zoom_begin=global_zoom_begin; //0; zoom_begin = 0;  
    856937    } 
    857938 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/axis.hpp

    r1236 r1249  
    6969         const std::set<StdString> & getRelFiles(void) const; 
    7070 
    71          int getNumberWrittenIndexes() const; 
    72          int getTotalNumberWrittenIndexes() const; 
    73          int getOffsetWrittenIndexes() const; 
     71         int getNumberWrittenIndexes(MPI_Comm writtenCom); 
     72         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
     73         int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
     74         CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
    7475 
    7576         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client); 
     
    110111 
    111112         void computeWrittenIndex(); 
     113         void computeWrittenCompressedIndex(MPI_Comm); 
    112114         bool hasTransformation(); 
    113115         void solveInheritanceTransformation(); 
     
    120122      public:  
    121123        bool hasValue;         
    122         CArray<size_t,1> localIndexToWriteOnServer; 
    123         CArray<int, 1> compressedIndexToWriteOnServer; 
     124        CArray<size_t,1> localIndexToWriteOnServer;         
    124125 
    125126      private: 
     
    161162         boost::unordered_map<size_t,size_t> globalLocalIndexMap_; 
    162163         std::vector<int> indexesToWrite; 
    163          int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
     164         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
     165         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer; 
    164166         std::map<CContextClient*, std::vector<int> > connectedServerRank_;          
    165167         bool hasBounds; 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/domain.cpp

    r1236 r1249  
    8686     \return the number of indexes written by each server 
    8787   */ 
    88    int CDomain::getNumberWrittenIndexes() const 
    89    { 
    90      return numberWrittenIndexes_; 
     88   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     89   { 
     90     int writtenSize; 
     91     MPI_Comm_size(writtenCom, &writtenSize); 
     92     return numberWrittenIndexes_[writtenSize]; 
    9193   } 
    9294 
     
    9597     \return the total number of indexes written by the servers 
    9698   */ 
    97    int CDomain::getTotalNumberWrittenIndexes() const 
    98    { 
    99      return totalNumberWrittenIndexes_; 
     99   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     100   { 
     101     int writtenSize; 
     102     MPI_Comm_size(writtenCom, &writtenSize); 
     103     return totalNumberWrittenIndexes_[writtenSize]; 
    100104   } 
    101105 
     
    104108     \return the offset of indexes written by each server 
    105109   */ 
    106    int CDomain::getOffsetWrittenIndexes() const 
    107    { 
    108      return offsetWrittenIndexes_; 
     110   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     111   { 
     112     int writtenSize; 
     113     MPI_Comm_size(writtenCom, &writtenSize); 
     114     return offsetWrittenIndexes_[writtenSize]; 
     115   } 
     116 
     117   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     118   { 
     119     int writtenSize; 
     120     MPI_Comm_size(writtenCom, &writtenSize); 
     121     return compressedIndexToWriteOnServer[writtenSize]; 
    109122   } 
    110123 
     
    14971510   void CDomain::checkArea(void) 
    14981511   { 
    1499      bool hasAreaValue = (0 != areavalue.numElements()); 
    1500      hasArea = !area.isEmpty() || !areavalue.isEmpty(); 
    1501      if (hasArea) 
     1512     bool hasAreaValue = (!areavalue.isEmpty() && 0 != areavalue.numElements()); 
     1513     hasArea = !area.isEmpty(); 
     1514     if (hasArea && !hasAreaValue) 
    15021515     { 
    15031516       if (area.extent(0) != ni || area.extent(1) != nj) 
     
    19021915      } 
    19031916       
    1904       if (isCompressible()) 
    1905       { 
    1906         nbWritten = 0; 
    1907         boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
    1908         for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
    1909         { 
    1910           indGlo = *itSrv; 
    1911           if (ite != globalLocalIndexMap_.find(indGlo)) 
    1912           { 
    1913             localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo; 
    1914             ++nbWritten; 
    1915           }                  
    1916         } 
    1917  
    1918         nbWritten = 0; 
    1919         for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
    1920         { 
    1921           if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
    1922           { 
    1923             ++nbWritten; 
    1924           } 
    1925         } 
    1926  
    1927         compressedIndexToWriteOnServer.resize(nbWritten); 
    1928         nbWritten = 0; 
    1929         for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
    1930         { 
    1931           if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
    1932           { 
    1933             compressedIndexToWriteOnServer(nbWritten) = localGlobalIndexMap[data_i_index(idx)]; 
    1934             ++nbWritten; 
    1935           } 
    1936         } 
    1937  
    1938         numberWrittenIndexes_ = nbWritten; 
    1939         if (isDistributed()) 
    1940         {             
    1941           MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    1942           MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    1943           offsetWrittenIndexes_ -= numberWrittenIndexes_; 
    1944         } 
    1945         else 
    1946           totalNumberWrittenIndexes_ = numberWrittenIndexes_; 
    1947       }       
    1948    } 
     1917      // if (isCompressible()) 
     1918      // { 
     1919      //   nbWritten = 0; 
     1920      //   boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     1921      //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     1922      //   { 
     1923      //     indGlo = *itSrv; 
     1924      //     if (ite != globalLocalIndexMap_.find(indGlo)) 
     1925      //     { 
     1926      //       localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo; 
     1927      //       ++nbWritten; 
     1928      //     }                  
     1929      //   } 
     1930 
     1931      //   nbWritten = 0; 
     1932      //   for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
     1933      //   { 
     1934      //     if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
     1935      //     { 
     1936      //       ++nbWritten; 
     1937      //     } 
     1938      //   } 
     1939 
     1940      //   compressedIndexToWriteOnServer.resize(nbWritten); 
     1941      //   nbWritten = 0; 
     1942      //   for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
     1943      //   { 
     1944      //     if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
     1945      //     { 
     1946      //       compressedIndexToWriteOnServer(nbWritten) = localGlobalIndexMap[data_i_index(idx)]; 
     1947      //       ++nbWritten; 
     1948      //     } 
     1949      //   } 
     1950 
     1951      //   numberWrittenIndexes_ = nbWritten; 
     1952      //   if (isDistributed()) 
     1953      //   {             
     1954      //     MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     1955      //     MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     1956      //     offsetWrittenIndexes_ -= numberWrittenIndexes_; 
     1957      //   } 
     1958      //   else 
     1959      //     totalNumberWrittenIndexes_ = numberWrittenIndexes_; 
     1960      // }       
     1961   } 
     1962 
     1963  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     1964  { 
     1965    int writtenCommSize; 
     1966    MPI_Comm_size(writtenComm, &writtenCommSize); 
     1967    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end()) 
     1968      return; 
     1969 
     1970    if (isCompressible()) 
     1971    { 
     1972      size_t nbWritten = 0, indGlo; 
     1973      CContext* context=CContext::getCurrent();       
     1974      CContextServer* server = context->server;   
     1975 
     1976      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2); 
     1977      nBegin[0]       = zoom_ibegin;  nBegin[1] = zoom_jbegin; 
     1978      nSize[0]        = zoom_ni;      nSize[1]  = zoom_nj; 
     1979      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0; 
     1980      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo; 
     1981      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);  
     1982      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex(); 
     1983 
     1984      boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(), 
     1985                                                          ite = globalLocalIndexMap_.end(), it;    
     1986      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(), 
     1987                                       itSrve = writtenGlobalIndex.end(), itSrv; 
     1988      boost::unordered_map<size_t,size_t> localGlobalIndexMap; 
     1989      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv) 
     1990      { 
     1991        indGlo = *itSrv; 
     1992        if (ite != globalLocalIndexMap_.find(indGlo)) 
     1993        { 
     1994          localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo; 
     1995          ++nbWritten; 
     1996        }                  
     1997      } 
     1998 
     1999      nbWritten = 0; 
     2000      for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
     2001      { 
     2002        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
     2003        { 
     2004          ++nbWritten; 
     2005        } 
     2006      } 
     2007 
     2008      compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten); 
     2009      nbWritten = 0; 
     2010      for (int idx = 0; idx < data_i_index.numElements(); ++idx) 
     2011      { 
     2012        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx))) 
     2013        { 
     2014          compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_i_index(idx)]; 
     2015          ++nbWritten; 
     2016        } 
     2017      } 
     2018 
     2019      numberWrittenIndexes_[writtenCommSize] = nbWritten; 
     2020      if (isDistributed()) 
     2021      { 
     2022              
     2023        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2024        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm); 
     2025        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize]; 
     2026      } 
     2027      else 
     2028        totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize]; 
     2029      } 
     2030  } 
    19492031 
    19502032  /*! 
     
    24062488  void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers) 
    24072489  { 
    2408     int nbReceived = rankBuffers.size(), i, ind, index, type_int; 
     2490    int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex; 
    24092491    recvClientRanks_.resize(nbReceived);         
    24102492 
     
    24262508    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor())); 
    24272509    i_index.resize(nbIndGlob); 
    2428     j_index.resize(nbIndGlob);     
     2510    j_index.resize(nbIndGlob);    
     2511    int nbIndexGlobMax = nbIndGlob, nbIndLoc; 
     2512 
    24292513    nbIndGlob = 0; 
    24302514    for (i = 0; i < nbReceived; ++i) 
     
    24362520         if (0 == globalLocalIndexMap_.count(index)) 
    24372521         { 
    2438            i_index(nbIndGlob) = index % ni_glo; 
    2439            j_index(nbIndGlob) = index / ni_glo; 
    2440            globalLocalIndexMap_[index] = nbIndGlob;   
    2441            ++nbIndGlob; 
     2522           iIndex = (index%ni_glo)-ibegin; 
     2523           iIndex = (iIndex < 0) ? 0 : iIndex; 
     2524           jIndex = (index/ni_glo)-jbegin; 
     2525           jIndex = (jIndex < 0) ? 0 : jIndex; 
     2526           nbIndLoc = iIndex + ni * jIndex; 
     2527           if (nbIndLoc < nbIndexGlobMax) 
     2528           { 
     2529             i_index(nbIndLoc) = index % ni_glo; 
     2530             j_index(nbIndLoc) = index / ni_glo; 
     2531             globalLocalIndexMap_[index] = nbIndLoc;   
     2532             ++nbIndGlob; 
     2533           } 
     2534           // i_index(nbIndGlob) = index % ni_glo; 
     2535           // j_index(nbIndGlob) = index / ni_glo; 
     2536           // globalLocalIndexMap_[index] = nbIndGlob;   
     2537           // ++nbIndGlob; 
    24422538         }  
    24432539      }  
     
    24972593    if (zoom_ni<=0 || zoom_nj<=0) 
    24982594    { 
    2499       zoom_ibegin=0 ; zoom_iend=0 ; zoom_ni=0 ; 
    2500       zoom_jbegin=0 ; zoom_jend=0 ; zoom_nj=0 ; 
     2595      zoom_ni=0 ; zoom_ibegin=global_zoom_ibegin ; //=0; zoom_iend=0 ;  
     2596      zoom_nj=0 ; zoom_jbegin=global_zoom_jbegin ; //=0; zoom_jend=0 ; 
    25012597    } 
    25022598 
     
    25552651    nbMaskInd = globalLocalIndexMap_.size(); 
    25562652    mask_1d.resize(nbMaskInd); 
     2653    mask_1d = false; 
    25572654     
    25582655    for (i = 0; i < nbReceived; ++i) 
     
    28622959    Receive data index information from client(s) 
    28632960    A client receives data index from different clients to rebuild its own data index. 
     2961    Because we use global index + mask info to calculate the sending data to client(s),  
     2962    this data index must be updated with mask info (maybe it will change in the future) 
    28642963    Because the data index is local, to rebuild data index of received client, we should use global index along with.  
     2964 
    28652965    \param[in] rankBuffers rank of sending client and the corresponding receive buffer      
    28662966  */ 
     
    29013001         lInd = globalLocalIndexMap_[size_t(tmpInd(ind))]; 
    29023002         dataIIndex(lInd) = (-1 == dataIIndex(lInd)) ? tmpI(ind) : dataIIndex(lInd); // Only fill in dataIndex if there is no data 
    2903          dataJIndex(lInd) = (-1 == dataJIndex(lInd)) ? tmpJ(ind) : dataJIndex(lInd);          
     3003         dataJIndex(lInd) = (-1 == dataJIndex(lInd)) ? tmpJ(ind) : dataJIndex(lInd);   
     3004 
     3005         if (!mask_1d(lInd))   // Include mask info into data index on the RECEIVE getServerDimensionSizes     
     3006         { 
     3007           dataIIndex(lInd) = dataJIndex(lInd) = -1; 
     3008         } 
    29043009      }  
    29053010    } 
  • XIOS/dev/XIOS_DEV_CMIP6/src/node/domain.hpp

    r1236 r1249  
    9292         bool isWrittenCompressed(const StdString& filename) const; 
    9393          
    94          int getNumberWrittenIndexes() const; 
    95          int getTotalNumberWrittenIndexes() const; 
    96          int getOffsetWrittenIndexes() const; 
     94         int getNumberWrittenIndexes(MPI_Comm writtenCom); 
     95         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom); 
     96         int getOffsetWrittenIndexes(MPI_Comm writtenCom); 
     97         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom); 
    9798 
    9899         std::map<int, StdSize> getAttributesBufferSize(CContextClient* client); 
     
    113114          
    114115         void computeWrittenIndex(); 
     116         void computeWrittenCompressedIndex(MPI_Comm); 
    115117 
    116118         void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
     
    138140         CArray<double, 1> areavalue; 
    139141 
    140          CArray<size_t,1> localIndexToWriteOnServer; 
    141          CArray<int, 1> compressedIndexToWriteOnServer; 
     142         CArray<size_t,1> localIndexToWriteOnServer;          
    142143 
    143144         CArray<bool, 1> localMask; 
     
    209210         std::vector<int> indexesToWrite; 
    210211         std::vector<int> recvClientRanks_; 
    211          int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;          
     212         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_; 
     213         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer;      
    212214         std::map<CContextClient*, std::map<int,size_t> > connectedDataSize_; 
    213215         std::map<CContextClient*, std::vector<int> > connectedServerRank_; 
Note: See TracChangeset for help on using the changeset viewer.