Ignore:
Timestamp:
10/28/20 16:24:06 (4 years ago)
Author:
oabramkina
Message:

dev_oa: first working version for tiled domains

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_oa/src/node/grid.cpp

    r1927 r1966  
    3333      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
    3434      , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_() 
    35           , isDataDistributed_(true), isCompressible_(false) 
     35      , isDataDistributed_(true), isCompressible_(false) 
    3636      , transformations_(0), isTransformed_(false) 
    3737      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false) 
    … …  
    3939      , computedWrittenIndex_(false) 
    4040      , clients() 
     41      , nTiles_(0) 
     42      , isTiled_(false) 
     43      , storeTileIndex() 
    4144   { 
    4245     setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group")); 
    … …  
    5457      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0) 
    5558      , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_() 
    56           , isDataDistributed_(true), isCompressible_(false) 
     59      , isDataDistributed_(true), isCompressible_(false) 
    5760      , transformations_(0), isTransformed_(false) 
    5861      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false) 
    … …  
    6063      , computedWrittenIndex_(false) 
    6164      , clients() 
     65      , nTiles_(0) 
     66      , isTiled_(false) 
     67      , storeTileIndex() 
    6268   { 
    6369     setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group")); 
    … …  
    102108   } 
    103109   CATCH 
     110 
     111   //--------------------------------------------------------------- 
     112   /*! 
     113    * Returns size of tile data 
     114    */ 
     115 
     116   StdSize CGrid::getTileDataSize(int tileId) 
     117   TRY 
     118   { 
     119     StdSize tileGridSize =1 ; 
     120     int numElement = axis_domain_order.numElements(); 
     121 
     122     std::vector<CAxis*> axisListP = this->getAxis(); 
     123     std::vector<CDomain*> domainListP = this->getDomains(); 
     124 
     125     int axisIndex = 0, domIndex = 0; 
     126     for (int idx = 0; idx < numElement; ++idx) 
     127     { 
     128       int eleDim = axis_domain_order(idx); 
     129       if (2 == eleDim) 
     130       { 
     131         tileGridSize *= domainListP[domIndex]->tile_data_ni(tileId); 
     132         tileGridSize *= domainListP[domIndex]->tile_data_nj(tileId); 
     133         ++domIndex; 
     134          } 
     135       else if (1 == eleDim) 
     136       { 
     137         tileGridSize *= axisListP[axisIndex]->n.getValue(); 
     138         ++axisIndex; 
     139       } 
     140     } // loop over grid elements 
     141     return tileGridSize; 
     142   } 
     143   CATCH 
     144 
     145   //--------------------------------------------------------------- 
     146   /*! 
     147    * Returns tile size 
     148    */ 
     149 
     150   StdSize CGrid::getTileSize(int tileId) 
     151   TRY 
     152   { 
     153     StdSize tileGridSize =1 ; 
     154     int numElement = axis_domain_order.numElements(); 
     155 
     156     std::vector<CAxis*> axisListP = this->getAxis(); 
     157     std::vector<CDomain*> domainListP = this->getDomains(); 
     158 
     159     int axisIndex = 0, domIndex = 0; 
     160     for (int idx = 0; idx < numElement; ++idx) 
     161     { 
     162       int eleDim = axis_domain_order(idx); 
     163       if (2 == eleDim) 
     164       { 
     165         tileGridSize *= domainListP[domIndex]->tile_ni(tileId); 
     166         tileGridSize *= domainListP[domIndex]->tile_nj(tileId); 
     167         ++domIndex; 
     168          } 
     169       else if (1 == eleDim)// So it's an axis 
     170       { 
     171         tileGridSize *= axisListP[axisIndex]->n.getValue(); 
     172         ++axisIndex; 
     173       } 
     174     } // loop over grid elements 
     175     return tileGridSize; 
     176   } 
     177   CATCH 
     178 
     179   //--------------------------------------------------------------- 
    104180 
    105181   /*! 
    … …  
    561637          if (sendAtt) domListP[i]->sendCheckedAttributes(); 
    562638          else domListP[i]->checkAttributesOnClient(); 
     639          if (domListP[i]->isTiled()) this->isTiled_ = true; 
    563640        } 
    564641      } 
    … …  
    902979     { 
    903980       computeClientIndex(); 
     981       if (this->isTiled_) computeTileIndex(); 
    904982       if (context->hasClient) 
    905983       { 
    … …  
    10971175   } 
    10981176   CATCH_DUMP_ATTR 
     1177 
     1178   //--------------------------------------------------------------- 
     1179 
     1180   /* 
     1181   */ 
     1182   void CGrid::computeTileIndex() 
     1183   TRY 
     1184   { 
     1185     int numElement = axis_domain_order.numElements(); 
     1186     storeTileIndex.resize(nTiles_); 
     1187 
     1188     std::vector<CAxis*> axisListP = this->getAxis(); 
     1189     std::vector<CDomain*> domainListP = this->getDomains(); 
     1190 
     1191     // First, allocate storeTileIndex[0..ntiles] 
     1192     for (int iTile = 0; iTile < nTiles_; ++iTile) 
     1193     { 
     1194       int tileGridSize = 1; 
     1195       int axisIndex = 0, domIndex = 0; 
     1196       for (int idx = 0; idx < numElement; ++idx) 
     1197       { 
     1198         int eleDim = axis_domain_order(idx); 
     1199         if (2 == eleDim) 
     1200         { 
     1201           tileGridSize *= domainListP[domIndex]->getTileDataISize(iTile); 
     1202           tileGridSize *= domainListP[domIndex]->getTileDataJSize(iTile); 
     1203           ++domIndex; 
     1204         } 
     1205         else if (1 == eleDim)// So it's an axis 
     1206         { 
     1207           tileGridSize *= axisListP[axisIndex]->n.getValue(); 
     1208           ++axisIndex; 
     1209         } 
     1210       } // loop over grid elements 
     1211       storeTileIndex[iTile].resize(tileGridSize); 
     1212       storeTileIndex[iTile] = -1; 
     1213     } // loop over tiles 
     1214 
     1215     // Now fill in storeTileIndex 
     1216     // Currently assuming two possible situations : (1) domain x axis or (2) domain 
     1217     std::vector<int> tileIndexCount (nTiles_,0); 
     1218     int axisSize = 1; 
     1219     if (axisListP.size() != 0) axisSize = axisListP[0]->n.getValue(); 
     1220     int ni = domainListP[0]->ni.getValue(); 
     1221     int nj = domainListP[0]->nj.getValue(); 
     1222 
     1223     for (int idxAxis = 0; idxAxis < axisSize; ++idxAxis) 
     1224     { 
     1225       for (int jIdxDom = 0; jIdxDom < nj; ++jIdxDom) 
     1226       { 
     1227         for (int iIdxDom = 0; iIdxDom < ni; ++iIdxDom) 
     1228         { 
     1229           int tile = domainListP[0]->getTileId(iIdxDom, jIdxDom); 
     1230           int tileOffset =  domainListP[0]->tile_data_ibegin(tile);  // only sign of offset matters 
     1231 
     1232           // case 1: data size corresponds to tile size 
     1233           if (tileOffset == 0) 
     1234           { 
     1235             storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom * ni + iIdxDom; 
     1236             ++tileIndexCount[tile]; 
     1237           } 
     1238           // case 2: masked data 
     1239           else if (tileOffset > 0) 
     1240           { 
     1241             int iBegin = domainListP[0]->tile_ibegin(tile) + domainListP[0]->tile_data_ibegin(tile); // tile data relative to domain 
     1242             int jBegin = domainListP[0]->tile_jbegin(tile) + domainListP[0]->tile_data_jbegin(tile); // tile data relative to domain 
     1243             int iEnd = iBegin + domainListP[0]->tile_data_ni(tile); 
     1244             int jEnd = jBegin + domainListP[0]->tile_data_nj(tile); 
     1245             if ((jIdxDom >= jBegin) && (jIdxDom < jEnd) && (iIdxDom >= iBegin) && (iIdxDom < iEnd)) 
     1246             { 
     1247               storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom * ni + iIdxDom; 
     1248             } 
     1249             ++tileIndexCount[tile]; 
     1250           } 
     1251           // case 3: ghost zones 
     1252           else 
     1253           { 
     1254             int tileDataNi = domainListP[0]->tile_data_ni(tile); 
     1255             int tileDataNj = domainListP[0]->tile_data_nj(tile); 
     1256             int tileDomSize = tileDataNi * tileDataNj; 
     1257             int tileNi = domainListP[0]->tile_ni(tile); 
     1258             int iBegin = domainListP[0]->tile_data_ibegin(tile); 
     1259             int jBegin = domainListP[0]->tile_data_jbegin(tile); 
     1260 
     1261             // add the ghost zone at the beginning of a domain tile 
     1262             if (tileIndexCount[tile] % tileDomSize == 0) 
     1263               tileIndexCount[tile] += (abs(jBegin)*tileDataNi + abs(iBegin)); 
     1264 
     1265             storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom*ni + iIdxDom; 
     1266              
     1267             // add two ghost zones at the right end of a tile 
     1268             if ( (iIdxDom+1) % tileNi == 0 ) 
     1269               tileIndexCount[tile] += (2*abs(iBegin)); 
     1270 
     1271             // add ghost zone at the end of a domain tile 
     1272             if ((tileIndexCount[tile] + abs(jBegin)*tileDataNi-abs(iBegin) + 1) % tileDomSize == 0) 
     1273               tileIndexCount[tile] += (abs(jBegin)*tileDataNi -abs(iBegin)); 
     1274 
     1275             ++tileIndexCount[tile]; 
     1276           } 
     1277         } // loop over domain first dimension 
     1278       } // loop over domain second dimension 
     1279     } // loop over axis dimension 
     1280 
     1281   } 
     1282   CATCH_DUMP_ATTR 
     1283 
    10991284//---------------------------------------------------------------- 
    11001285 
    … …  
    13591544 
    13601545   void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored) const 
     1546   TRY 
    13611547   { 
    13621548      const StdSize size = storeIndex_client.numElements(); 
    … …  
    13691555        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)]; 
    13701556   } 
     1557   CATCH 
     1558 
     1559   void CGrid::copyTile_arr(const double* const tileData, CArray<double, 1>& stored, int tileId) 
     1560   TRY 
     1561   { 
     1562     StdSize tileSize = this->getTileSize(tileId); 
     1563     const StdSize tileDataSize = this->getTileDataSize(tileId); 
     1564 
     1565     // case 1: data correspond in size to a tile 
     1566     if (tileSize == tileDataSize) 
     1567     { 
     1568       for(StdSize i = 0; i < tileDataSize; i++) 
     1569         stored(storeTileIndex[tileId](i)) = tileData[i]; 
     1570     } 
     1571     // case 2: masked data 
     1572     else if (tileSize > tileDataSize) 
     1573     { 
     1574       int tileDataCount = 0; 
     1575       for(StdSize i = 0; i < tileSize; i++) 
     1576         if (storeTileIndex[tileId](i) >= 0) 
     1577         { 
     1578           stored(storeTileIndex[tileId](i)) = tileData[tileDataCount]; 
     1579           ++tileDataCount; 
     1580         } 
     1581     } 
     1582     // case 3: ghost zones 
     1583     else 
     1584     { 
     1585       for(StdSize i = 0; i < tileDataSize; i++) 
     1586         if (storeTileIndex[tileId](i) >= 0) 
     1587         { 
     1588           stored(storeTileIndex[tileId](i)) = tileData[i]; 
     1589         } 
     1590 
     1591     } 
     1592   } 
     1593   CATCH 
    13711594 
    13721595   void CGrid::uncompressField_arr(const double* const data, CArray<double, 1>& out) const 
    … …  
    22532476        pDom->solveRefInheritance(apply); 
    22542477        pDom->solveInheritanceTransformation(); 
     2478        if (!pDom->ntiles.isEmpty() && pDom->ntiles.getValue()>0) nTiles_=pDom->ntiles.getValue(); 
    22552479      } 
    22562480    } 
    … …  
    22792503      } 
    22802504    } 
     2505  } 
     2506  CATCH_DUMP_ATTR 
     2507 
     2508  int CGrid::getNTiles() 
     2509  TRY 
     2510  { 
     2511    return nTiles_; 
    22812512  } 
    22822513  CATCH_DUMP_ATTR 
Note: See TracChangeset for help on using the changeset viewer.