Changeset 650


Ignore:
Timestamp:
07/24/15 16:40:05 (6 years ago)
Author:
rlacroix
Message:

Grid: Avoid some heap allocations and do various cleanups.

Location:
XIOS/trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/filter/source_filter.cpp

    r643 r650  
    4747    for (it = data.begin(); it != itEnd; it++) 
    4848    { 
    49       CArray<int,1>& index = *grid->storeIndex_toSrv[it->first]; 
     49      CArray<int,1>& index = grid->storeIndex_toSrv[it->first]; 
    5050 
    5151      for (int n = 0; n < index.numElements(); n++) 
  • XIOS/trunk/src/node/field.cpp

    r645 r650  
    130130    CEventClient event(getType(), EVENT_ID_UPDATE_DATA); 
    131131 
    132     map<int, CArray<int,1>* >::iterator it; 
     132    map<int, CArray<int,1> >::iterator it; 
    133133    list<CMessage> list_msg; 
    134134    list<CArray<double,1> > list_data; 
     
    140140          for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
    141141          { 
    142             int rank = (*it).first; 
    143             CArray<int,1>& index = *(it->second); 
     142            int rank = it->first; 
     143            CArray<int,1>& index = it->second; 
    144144 
    145145            list_msg.push_back(CMessage()); 
     
    159159      for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++) 
    160160      { 
    161         int rank = (*it).first; 
    162         CArray<int,1>& index = *(it->second); 
     161        int rank = it->first; 
     162        CArray<int,1>& index = it->second; 
    163163 
    164164        list_msg.push_back(CMessage()); 
     
    200200    if (data_srv.empty()) 
    201201    { 
    202       for (map<int, CArray<size_t, 1>* >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
     202      for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
    203203      { 
    204204        int rank = it->first; 
    205         CArray<double,1> data_tmp(it->second->numElements()); 
    206         data_srv.insert( pair<int, CArray<double,1>* >(rank, new CArray<double,1>(data_tmp))); 
     205        data_srv.insert( pair<int, CArray<double,1>* >(rank, new CArray<double,1>(it->second.numElements()))); 
    207206        foperation_srv.insert(pair<int,boost::shared_ptr<func::CFunctor> >(rank,boost::shared_ptr<func::CFunctor>(new func::CInstant(*data_srv[rank])))); 
    208207      } 
     
    329328        if (data_srv.empty()) 
    330329        { 
    331           for (map<int, CArray<size_t, 1>* >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
    332             data_srv.insert(pair<int, CArray<double,1>*>(it->first, new CArray<double,1>(it->second->numElements()))); 
     330          for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it) 
     331            data_srv.insert(pair<int, CArray<double,1>*>(it->first, new CArray<double,1>(it->second.numElements()))); 
    333332        } 
    334333 
  • XIOS/trunk/src/node/grid.cpp

    r632 r650  
    2121   CGrid::CGrid(void) 
    2222      : CObjectTemplate<CGrid>(), CGridAttributes() 
    23       , isChecked(false), isDomainAxisChecked(false), storeIndex(1) 
     23      , isChecked(false), isDomainAxisChecked(false) 
    2424      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    2525      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
     
    3131   } 
    3232 
    33    CGrid::CGrid(const StdString & id) 
     33   CGrid::CGrid(const StdString& id) 
    3434      : CObjectTemplate<CGrid>(id), CGridAttributes() 
    35       , isChecked(false), isDomainAxisChecked(false), storeIndex(1) 
     35      , isChecked(false), isDomainAxisChecked(false) 
    3636      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false) 
    3737      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_() 
     
    4545   CGrid::~CGrid(void) 
    4646   { 
    47     deque< CArray<int, 1>* >::iterator it ; 
    48  
    49     for(deque< CArray<int,1>* >::iterator it=storeIndex.begin(); it!=storeIndex.end();it++)  delete *it ; 
    50     for(map<int,CArray<size_t,1>* >::iterator it=outIndexFromClient.begin();it!=outIndexFromClient.end();++it) delete (it->second); 
    51  
    5247    if (0 != clientDistribution_) delete clientDistribution_; 
    5348    if (0 != serverDistribution_) delete serverDistribution_; 
     
    5853   ///--------------------------------------------------------------- 
    5954 
    60    StdString CGrid::GetName(void)    { return (StdString("grid")); } 
    61    StdString CGrid::GetDefName(void) { return (CGrid::GetName()); } 
    62    ENodeType CGrid::GetType(void)    { return (eGrid); } 
    63  
    64    //---------------------------------------------------------------- 
    65  
    66    const std::deque< CArray<int,1>* > & CGrid::getStoreIndex(void) const 
    67    { 
    68       return (this->storeIndex ); 
    69    } 
     55   StdString CGrid::GetName(void)    { return StdString("grid"); } 
     56   StdString CGrid::GetDefName(void) { return CGrid::GetName(); } 
     57   ENodeType CGrid::GetType(void)    { return eGrid; } 
    7058 
    7159   //--------------------------------------------------------------- 
    72 // 
    73 //   const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const 
    74 //   { 
    75 //      return (this->out_i_index ); 
    76 //   } 
    77 // 
    78 //   //--------------------------------------------------------------- 
    79 // 
    80 //   const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const 
    81 //   { 
    82 //      return (this->out_j_index ); 
    83 //   } 
    84 // 
    85 //   //--------------------------------------------------------------- 
    86 // 
    87 //   const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const 
    88 //   { 
    89 //      return (this->out_l_index ); 
    90 //   } 
    91 // 
    92 //   //--------------------------------------------------------------- 
    93 // 
    94 //   const CAxis*   CGrid::getRelAxis  (void) const 
    95 //   { 
    96 //      return (this->axis ); 
    97 //   } 
    98  
    99 //   //--------------------------------------------------------------- 
    100 // 
    101 //   const CDomain* CGrid::getRelDomain(void) const 
    102 //   { 
    103 //      return (this->domain ); 
    104 //   } 
     60 
     61   StdSize CGrid::getDimension(void) const 
     62   { 
     63      return globalDim_.size(); 
     64   } 
    10565 
    10666   //--------------------------------------------------------------- 
    10767 
    108 //   bool CGrid::hasAxis(void) const 
    109 //   { 
    110 //      return (this->withAxis); 
    111 //   } 
    112  
    113    //--------------------------------------------------------------- 
    114  
    115    StdSize CGrid::getDimension(void) const 
    116    { 
    117       return (globalDim_.size()); 
    118    } 
    119  
    120    //--------------------------------------------------------------- 
    121  
    122 /* 
    123    std::vector<StdSize> CGrid::getLocalShape(void) const 
    124    { 
    125       std::vector<StdSize> retvalue; 
    126       retvalue.push_back(domain->zoom_ni_loc.getValue()); 
    127       retvalue.push_back(domain->zoom_nj_loc.getValue()); 
    128       if (this->withAxis) 
    129          retvalue.push_back(this->axis->zoom_size.getValue()); 
    130       return (retvalue); 
    131    } 
    132 */ 
    133    //--------------------------------------------------------------- 
    134  
    135 /* 
    136    StdSize CGrid::getLocalSize(void) const 
    137    { 
    138       StdSize retvalue = 1; 
    139       std::vector<StdSize> shape_ = this->getLocalShape(); 
    140       for (StdSize s = 0; s < shape_.size(); s++) 
    141          retvalue *= shape_[s]; 
    142       return (retvalue); 
    143    } 
    144 */ 
    145    //--------------------------------------------------------------- 
    146 /* 
    147    std::vector<StdSize> CGrid::getGlobalShape(void) const 
    148    { 
    149       std::vector<StdSize> retvalue; 
    150       retvalue.push_back(domain->ni.getValue()); 
    151       retvalue.push_back(domain->nj.getValue()); 
    152       if (this->withAxis) 
    153          retvalue.push_back(this->axis->size.getValue()); 
    154       return (retvalue); 
    155    } 
    156 */ 
    157    //--------------------------------------------------------------- 
    158  
    159 /* 
    160    StdSize CGrid::getGlobalSize(void) const 
    161    { 
    162       StdSize retvalue = 1; 
    163       std::vector<StdSize> shape_ = this->getGlobalShape(); 
    164       for (StdSize s = 0; s < shape_.size(); s++) 
    165          retvalue *= shape_[s]; 
    166       return (retvalue); 
    167    } 
    168 */ 
    16968   StdSize CGrid::getDataSize(void) const 
    17069   { 
     
    228127   void CGrid::checkMaskIndex(bool doSendingIndex) 
    229128   { 
    230      CContext* context = CContext::getCurrent() ; 
    231      CContextClient* client=context->client ; 
     129     CContext* context = CContext::getCurrent(); 
     130     CContextClient* client=context->client; 
    232131 
    233132     if (isScalarGrid()) 
     
    253152     if (context->hasClient) 
    254153     { 
    255         checkMask() ; 
    256         this->computeIndex() ; 
    257         this->storeIndex.push_front(new CArray<int,1>() ); 
     154        checkMask(); 
     155        this->computeIndex(); 
    258156     } 
    259157     this->isChecked = true; 
     
    382280   void CGrid::computeIndex(void) 
    383281   { 
    384      CContext* context = CContext::getCurrent() ; 
    385      CContextClient* client=context->client ; 
     282     CContext* context = CContext::getCurrent(); 
     283     CContextClient* client = context->client; 
    386284 
    387285     // First of all, compute distribution on client side 
     
    477375      CGrid* grid = createGrid(vecDom, vecAxis, axisDomainOrder); 
    478376 
    479       return (grid); 
     377      return grid; 
    480378   } 
    481379 
     
    487385      CGrid* grid = createGrid(vecDom, vecAxis, axisDomainOrder); 
    488386 
    489       return (grid); 
     387      return grid; 
    490388   } 
    491389 
     
    494392      StdString new_id = StdString("__"); 
    495393      if (!domains.empty()) for (int i = 0; i < domains.size(); ++i) new_id += domains[i]->getId() + StdString("_"); 
    496       if (!axis.empty()) for (int i = 0; i < axis.size(); ++i) new_id += axis[i]->getId() + StdString("_") ; 
     394      if (!axis.empty()) for (int i = 0; i < axis.size(); ++i) new_id += axis[i]->getId() + StdString("_"); 
    497395      if (domains.empty() && axis.empty()) new_id += StdString("scalar_grid"); 
    498396      new_id += StdString("_"); 
    499397 
    500       CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
     398      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id); 
    501399      grid->setDomainList(domains); 
    502400      grid->setAxisList(axis); 
     
    521419      grid->computeGridGlobalDimension(domains, axis, grid->axis_domain_order); 
    522420 
    523       return (grid); 
     421      return grid; 
    524422   } 
    525423 
    526424   CDomainGroup* CGrid::getVirtualDomainGroup() const 
    527425   { 
    528      return (this->vDomainGroup_); 
     426     return this->vDomainGroup_; 
    529427   } 
    530428 
    531429   CAxisGroup* CGrid::getVirtualAxisGroup() const 
    532430   { 
    533      return (this->vAxisGroup_); 
     431     return this->vAxisGroup_; 
    534432   } 
    535433 
    536434   void CGrid::outputField(int rank, const CArray<double, 1>& stored, double* field) 
    537435   { 
    538      CArray<size_t,1>& out_i=*outIndexFromClient[rank]; 
     436     const CArray<size_t,1>& out_i = outIndexFromClient[rank]; 
    539437     StdSize numElements = stored.numElements(); 
    540438     for (StdSize n = 0; n < numElements; ++n) 
    541439     { 
    542        *(field+out_i(n)) = stored(n); 
     440       field[out_i(n)] = stored(n); 
    543441     } 
    544442   } 
     
    546444   void CGrid::inputField(int rank, const double* const field, CArray<double,1>& stored) 
    547445   { 
    548      CArray<size_t,1>& out_i = *outIndexFromClient[rank]; 
     446     const CArray<size_t,1>& out_i = outIndexFromClient[rank]; 
    549447     StdSize numElements = stored.numElements(); 
    550448     for (StdSize n = 0; n < numElements; ++n) 
    551449     { 
    552        stored(n) = *(field+out_i(n)); 
     450       stored(n) = field[out_i(n)]; 
    553451     } 
    554452   } 
     
    556454   //---------------------------------------------------------------- 
    557455 
    558  
    559    void CGrid::storeField_arr 
    560       (const double * const data, CArray<double, 1>& stored) const 
    561    { 
    562       const StdSize size = storeIndex_client.numElements() ; 
    563  
    564       stored.resize(size) ; 
    565       for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)] ; 
    566    } 
    567  
    568    void CGrid::restoreField_arr 
    569       (const CArray<double, 1>& stored, double * const data) const 
    570    { 
    571       const StdSize size = storeIndex_client.numElements() ; 
    572  
    573       for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i) ; 
     456   void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const 
     457   { 
     458      const StdSize size = storeIndex_client.numElements(); 
     459 
     460      stored.resize(size); 
     461      for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)]; 
     462   } 
     463 
     464   void CGrid::restoreField_arr(const CArray<double, 1>& stored, double* const data) const 
     465   { 
     466      const StdSize size = storeIndex_client.numElements(); 
     467 
     468      for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i); 
    574469   } 
    575470 
     
    591486  void CGrid::sendIndexScalarGrid() 
    592487  { 
    593     CContext* context = CContext::getCurrent() ; 
    594     CContextClient* client=context->client ; 
    595  
    596     CEventClient event(getType(),EVENT_ID_INDEX); 
    597     list<shared_ptr<CMessage> > list_msg ; 
    598     list< CArray<size_t,1>* > listOutIndex; 
     488    CContext* context = CContext::getCurrent(); 
     489    CContextClient* client = context->client; 
     490 
     491    CEventClient event(getType(), EVENT_ID_INDEX); 
     492    list<CMessage> listMsg; 
     493    list<CArray<size_t,1> > listOutIndex; 
     494 
    599495    if (0 == client->clientRank) 
    600496    { 
     
    602498      { 
    603499        int nb = 1; 
    604         CArray<size_t, 1> outGlobalIndexOnServer(nb); 
    605         CArray<int, 1> outLocalIndexToServer(nb); 
     500        storeIndex_toSrv.insert(std::make_pair(rank, CArray<int,1>(nb))); 
     501        listOutIndex.push_back(CArray<size_t,1>(nb)); 
     502 
     503        CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv[rank]; 
     504        CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
     505 
    606506        for (int k = 0; k < nb; ++k) 
    607507        { 
     
    610510        } 
    611511 
    612         storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) )); 
    613         listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
    614  
    615         list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
    616         *list_msg.back()<<getId()<<isDataDistributed_<<*listOutIndex.back(); 
    617  
    618         event.push(rank, 1, *list_msg.back()); 
    619       } 
     512        listMsg.push_back(CMessage()); 
     513        listMsg.back() << getId( )<< isDataDistributed_ << listOutIndex.back(); 
     514 
     515        event.push(rank, 1, listMsg.back()); 
     516      } 
     517 
    620518      client->sendEvent(event); 
    621519    } 
    622520    else 
    623521      client->sendEvent(event); 
    624  
    625     for(list<CArray<size_t,1>* >::iterator it=listOutIndex.begin();it!=listOutIndex.end();++it) delete *it ; 
    626522  } 
    627523 
    628524  void CGrid::sendIndex(void) 
    629525  { 
    630     CContext* context = CContext::getCurrent() ; 
    631     CContextClient* client=context->client ; 
    632  
    633     CEventClient event(getType(),EVENT_ID_INDEX) ; 
    634     int rank ; 
    635     list<shared_ptr<CMessage> > list_msg ; 
    636     list< CArray<size_t,1>* > listOutIndex; 
     526    CContext* context = CContext::getCurrent(); 
     527    CContextClient* client = context->client; 
     528 
     529    CEventClient event(getType(), EVENT_ID_INDEX); 
     530    int rank; 
     531    list<CMessage> listMsg; 
     532    list<CArray<size_t,1> > listOutIndex; 
    637533    const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_->getGlobalIndexOnServer(); 
    638534    const CArray<int,1>& localIndexSendToServer = clientDistribution_->getLocalDataIndexSendToServer(); 
     
    643539      if (0 == client->clientRank) 
    644540      { 
    645         CArray<size_t, 1> outGlobalIndexOnServer = globalIndexSendToServer; 
    646         CArray<int,1> outLocalIndexToServer = localIndexSendToServer; 
     541        const CArray<size_t, 1>& outGlobalIndexOnServer = globalIndexSendToServer; 
     542        const CArray<int,1>& outLocalIndexToServer = localIndexSendToServer; 
     543 
    647544        for (rank = 0; rank < client->serverSize; ++rank) 
    648545        { 
    649           storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer))); 
    650           listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
    651  
    652           list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
    653           *list_msg.back()<<getId()<<isDataDistributed_<<*listOutIndex.back(); 
    654  
    655           event.push(rank, 1, *list_msg.back()); 
    656         } 
     546          storeIndex_toSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer))); 
     547          listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer)); 
     548 
     549          listMsg.push_back(CMessage()); 
     550          listMsg.back() << getId() << isDataDistributed_ << listOutIndex.back(); 
     551 
     552          event.push(rank, 1, listMsg.back()); 
     553        } 
     554 
    657555        client->sendEvent(event); 
    658556      } 
     
    669567      std::map<int,std::vector<int> >localIndexTmp; 
    670568      std::map<int,std::vector<size_t> > globalIndexTmp; 
     569 
    671570      for (; itGlobalMap != iteGlobalMap; ++itGlobalMap) 
    672571      { 
     
    691590          nb = globalIndexTmp[rank].size(); 
    692591 
    693         CArray<size_t, 1> outGlobalIndexOnServer(nb); 
    694         CArray<int, 1> outLocalIndexToServer(nb); 
     592        storeIndex_toSrv.insert(make_pair(rank, CArray<int,1>(nb))); 
     593        listOutIndex.push_back(CArray<size_t,1>(nb)); 
     594 
     595        CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv[rank]; 
     596        CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back(); 
     597 
    695598        for (int k = 0; k < nb; ++k) 
    696599        { 
     
    699602        } 
    700603 
    701         storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) )); 
    702         listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer)); 
    703  
    704         list_msg.push_back(shared_ptr<CMessage>(new CMessage)); 
    705         *list_msg.back()<<getId()<<isDataDistributed_<<*listOutIndex.back(); 
    706  
    707         event.push(rank, nbSenders[rank], *list_msg.back()); 
     604        listMsg.push_back(CMessage()); 
     605        listMsg.back() << getId() << isDataDistributed_ << listOutIndex.back(); 
     606 
     607        event.push(rank, nbSenders[rank], listMsg.back()); 
    708608      } 
    709609 
    710610      client->sendEvent(event); 
    711611    } 
    712  
    713     for(list<CArray<size_t,1>* >::iterator it=listOutIndex.begin();it!=listOutIndex.end();++it) delete *it ; 
    714612  } 
    715613 
     
    721619 
    722620    list<CEventServer::SSubEvent>::iterator it; 
    723     for (it=event.subEvents.begin();it!=event.subEvents.end();++it) 
     621    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it) 
    724622    { 
    725623      ranks.push_back(it->rank); 
     
    728626      buffers.push_back(buffer); 
    729627    } 
    730     get(gridId)->recvIndex(ranks, buffers) ; 
     628    get(gridId)->recvIndex(ranks, buffers); 
    731629  } 
    732630 
     
    768666    Verify whether one server need to write data 
    769667    There are some cases on which one server has nodata to write. For example, when we 
    770   just only want to zoom on a domain. 
     668    just only want to zoom on a domain. 
    771669  */ 
    772670  bool CGrid::doGridHaveDataToWrite() 
    773671  { 
    774 //    size_t ssize = 0; 
    775 //    for (map<int, CArray<size_t, 1>* >::const_iterator it = outIndexFromClient.begin(); 
    776 //                                                       it != outIndexFromClient.end(); ++it) 
    777 //    { 
    778 //      ssize += (it->second)->numElements(); 
    779 //    } 
    780 //    return (0 != ssize); 
    781672     return (0 != writtenDataSize_); 
    782673  } 
     
    785676    Return size of data which is written on each server 
    786677    Whatever dimension of a grid, data which are written on server must be presented as 
    787   an one dimension array. 
    788   \return size of data written on server 
     678    an one dimension array. 
     679    \return size of data written on server 
    789680  */ 
    790681  size_t CGrid::getWrittenDataSize() const 
     
    828719        CArray<size_t,1> outIndex; 
    829720        buffer >> outIndex; 
    830         outIndexFromClient.insert(std::pair<int, CArray<size_t,1>* >(rank, new CArray<size_t,1>(outIndex))); 
     721        outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
    831722        std::vector<int> nZoomBegin(1,0), nZoomSize(1,1), nGlob(1,1), nZoomBeginGlobal(1,0); 
    832723        serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, 
     
    899790      writtenDataSize_ += dataSize; 
    900791 
    901       outIndexFromClient.insert(std::pair<int, CArray<size_t,1>* >(rank, new CArray<size_t,1>(outIndex))); 
     792      outIndexFromClient.insert(std::make_pair(rank, outIndex)); 
    902793      connectedDataSize_[rank] = outIndex.numElements(); 
    903794    } 
     
    916807  { 
    917808 
    918     if (SuperClass::dispatchEvent(event)) return true ; 
     809    if (SuperClass::dispatchEvent(event)) return true; 
    919810    else 
    920811    { 
     
    922813      { 
    923814        case EVENT_ID_INDEX : 
    924           recvIndex(event) ; 
    925           return true ; 
    926           break ; 
     815          recvIndex(event); 
     816          return true; 
     817          break; 
    927818 
    928819         case EVENT_ID_ADD_DOMAIN : 
    929            recvAddDomain(event) ; 
    930            return true ; 
    931            break ; 
     820           recvAddDomain(event); 
     821           return true; 
     822           break; 
    932823 
    933824         case EVENT_ID_ADD_AXIS : 
    934            recvAddAxis(event) ; 
    935            return true ; 
    936            break ; 
     825           recvAddAxis(event); 
     826           return true; 
     827           break; 
    937828        default : 
    938829          ERROR("bool CDomain::dispatchEvent(CEventServer& event)", 
    939                 <<"Unknown Event") ; 
    940           return false ; 
    941       } 
    942     } 
    943   } 
    944  
    945    void CGrid::inputFieldServer(const std::deque< CArray<double, 1>* > storedClient, CArray<double, 1>&  storedServer) const 
    946    { 
    947       if ((this->storeIndex.size()-1 ) != storedClient.size()) 
    948          ERROR("void CGrid::inputFieldServer(const std::deque< CArray<double, 1>* > storedClient, CArray<double, 1>&  storedServer) const", 
    949                 << "[ Expected received field = " << (this->storeIndex.size()-1) << ", " 
    950                 << "[ received fiedl = "    << storedClient.size() << "] " 
    951                 << "Data from clients are missing!") ; 
    952       storedServer.resize(storeIndex[0]->numElements()); 
    953  
    954       for (StdSize i = 0, n = 0; i < storedClient.size(); i++) 
    955          for (StdSize j = 0; j < storedClient[i]->numElements(); j++) 
    956             storedServer(n++) = (*storedClient[i])(j); 
    957    } 
    958  
    959    void CGrid::outputFieldToServer(CArray<double,1>& fieldIn, int rank, CArray<double,1>& fieldOut) 
    960    { 
    961      CArray<int,1>& index = *storeIndex_toSrv[rank] ; 
    962      int nb=index.numElements() ; 
    963      fieldOut.resize(nb) ; 
    964  
    965      for(int k=0;k<nb;k++) fieldOut(k)=fieldIn(index(k)) ; 
    966     } 
     830                << "Unknown Event"); 
     831          return false; 
     832      } 
     833    } 
     834  } 
     835 
    967836   ///--------------------------------------------------------------- 
    968837 
    969838   CDomain* CGrid::addDomain(const std::string& id) 
    970839   { 
    971      return vDomainGroup_->createChild(id) ; 
     840     return vDomainGroup_->createChild(id); 
    972841   } 
    973842 
    974843   CAxis* CGrid::addAxis(const std::string& id) 
    975844   { 
    976      return vAxisGroup_->createChild(id) ; 
     845     return vAxisGroup_->createChild(id); 
    977846   } 
    978847 
     
    1008877   void CGrid::sendAddDomain(const string& id) 
    1009878   { 
    1010     CContext* context=CContext::getCurrent() ; 
     879    CContext* context=CContext::getCurrent(); 
    1011880 
    1012881    if (! context->hasServer ) 
    1013882    { 
    1014        CContextClient* client=context->client ; 
    1015  
    1016        CEventClient event(this->getType(),EVENT_ID_ADD_DOMAIN) ; 
     883       CContextClient* client=context->client; 
     884 
     885       CEventClient event(this->getType(),EVENT_ID_ADD_DOMAIN); 
    1017886       if (client->isServerLeader()) 
    1018887       { 
    1019          CMessage msg ; 
    1020          msg<<this->getId() ; 
    1021          msg<<id ; 
     888         CMessage msg; 
     889         msg<<this->getId(); 
     890         msg<<id; 
    1022891         const std::list<int>& ranks = client->getRanksServerLeader(); 
    1023892         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1024893           event.push(*itRank,1,msg); 
    1025          client->sendEvent(event) ; 
     894         client->sendEvent(event); 
    1026895       } 
    1027        else client->sendEvent(event) ; 
     896       else client->sendEvent(event); 
    1028897    } 
    1029898   } 
     
    1035904   void CGrid::sendAddAxis(const string& id) 
    1036905   { 
    1037     CContext* context=CContext::getCurrent() ; 
     906    CContext* context=CContext::getCurrent(); 
    1038907 
    1039908    if (! context->hasServer ) 
    1040909    { 
    1041        CContextClient* client=context->client ; 
    1042  
    1043        CEventClient event(this->getType(),EVENT_ID_ADD_AXIS) ; 
     910       CContextClient* client=context->client; 
     911 
     912       CEventClient event(this->getType(),EVENT_ID_ADD_AXIS); 
    1044913       if (client->isServerLeader()) 
    1045914       { 
    1046          CMessage msg ; 
    1047          msg<<this->getId() ; 
    1048          msg<<id ; 
     915         CMessage msg; 
     916         msg<<this->getId(); 
     917         msg<<id; 
    1049918         const std::list<int>& ranks = client->getRanksServerLeader(); 
    1050919         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1051920           event.push(*itRank,1,msg); 
    1052          client->sendEvent(event) ; 
     921         client->sendEvent(event); 
    1053922       } 
    1054        else client->sendEvent(event) ; 
     923       else client->sendEvent(event); 
    1055924    } 
    1056925   } 
     
    1063932   { 
    1064933 
    1065       CBufferIn* buffer=event.subEvents.begin()->buffer; 
     934      CBufferIn* buffer = event.subEvents.begin()->buffer; 
    1066935      string id; 
    1067       *buffer>>id ; 
    1068       get(id)->recvAddDomain(*buffer) ; 
     936      *buffer >> id; 
     937      get(id)->recvAddDomain(*buffer); 
    1069938   } 
    1070939 
     
    1075944   void CGrid::recvAddDomain(CBufferIn& buffer) 
    1076945   { 
    1077       string id ; 
    1078       buffer>>id ; 
    1079       addDomain(id) ; 
     946      string id; 
     947      buffer >> id; 
     948      addDomain(id); 
    1080949   } 
    1081950 
     
    1087956   { 
    1088957 
    1089       CBufferIn* buffer=event.subEvents.begin()->buffer; 
     958      CBufferIn* buffer = event.subEvents.begin()->buffer; 
    1090959      string id; 
    1091       *buffer>>id ; 
    1092       get(id)->recvAddAxis(*buffer) ; 
     960      *buffer >> id; 
     961      get(id)->recvAddAxis(*buffer); 
    1093962   } 
    1094963 
     
    1099968   void CGrid::recvAddAxis(CBufferIn& buffer) 
    1100969   { 
    1101       string id ; 
    1102       buffer>>id ; 
    1103       addAxis(id) ; 
     970      string id; 
     971      buffer >> id; 
     972      addAxis(id); 
    1104973   } 
    1105974 
     
    11691038      ERROR("CGrid::transformGrid(CGrid* transformGridSrc)", 
    11701039           << "Two grids have different dimension size" 
    1171            << "Dimension of grid destination " <<this->getId() << " is " << axis_domain_order.numElements() << std::endl 
    1172            << "Dimension of grid source " <<transformGridSrc->getId() << " is " << transformGridSrc->axis_domain_order.numElements()); 
     1040           << "Dimension of grid destination " << this->getId() << " is " << axis_domain_order.numElements() << std::endl 
     1041           << "Dimension of grid source " << transformGridSrc->getId() << " is " << transformGridSrc->axis_domain_order.numElements()); 
    11731042    } 
    11741043    else 
     
    11781047        if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i)) 
    11791048          ERROR("CGrid::transformGrid(CGrid* transformGridSrc)", 
    1180                 << "Grids " <<this->getId() <<" and " << transformGridSrc->getId() 
     1049                << "Grids " << this->getId() << " and " << transformGridSrc->getId() 
    11811050                << " don't have elements in the same order"); 
    11821051    } 
     
    12291098      int sizeDom = domList.size(); 
    12301099      domList_.resize(sizeDom); 
    1231       for (int i = 0 ; i < sizeDom; ++i) 
     1100      for (int i = 0; i < sizeDom; ++i) 
    12321101      { 
    12331102        domList_[i] = domList[i]->getId(); 
     
    13021171  } 
    13031172 
    1304   void CGrid::parse(xml::CXMLNode & node) 
     1173  void CGrid::parse(xml::CXMLNode& node) 
    13051174  { 
    13061175    SuperClass::parse(node); 
     
    13231192          this->getVirtualAxisGroup()->parseChild(node); 
    13241193        } 
    1325       } while (node.goToNextElement()) ; 
     1194      } while (node.goToNextElement()); 
    13261195      node.goToParentElement(); 
    13271196    } 
     
    13401209    setAxisList(); 
    13411210   } 
    1342  
    13431211} // namespace xios 
  • XIOS/trunk/src/node/grid.hpp

    r632 r650  
    5959         { 
    6060           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS 
    61          } ; 
     61         }; 
    6262 
    6363         enum EElementType 
     
    6868         /// Constructeurs /// 
    6969         CGrid(void); 
    70          explicit CGrid(const StdString & id); 
    71          CGrid(const CGrid & grid);       // Not implemented yet. 
    72          CGrid(const CGrid * const grid); // Not implemented yet. 
     70         explicit CGrid(const StdString& id); 
     71         CGrid(const CGrid& grid);       // Not implemented yet. 
     72         CGrid(const CGrid* const grid); // Not implemented yet. 
    7373 
    7474         /// Traitements /// 
     
    7979         void checkMaskIndex(bool doCalculateIndex); 
    8080 
    81  //        virtual void toBinary  (StdOStream & os) const; 
    82 //         virtual void fromBinary(StdIStream & is); 
     81 //        virtual void toBinary  (StdOStream& os) const; 
     82//         virtual void fromBinary(StdIStream& is); 
    8383 
    8484         /// Tests /// 
     
    8888 
    8989         /// Accesseurs /// 
    90          const std::deque< CArray<int, 1>* > & getStoreIndex(void) const; 
    91          const std::deque< CArray<int, 1>* > & getOutIIndex(void)  const; 
    92          const std::deque< CArray<int, 1>* > & getOutJIndex(void)  const; 
    93          const std::deque< CArray<int, 1>* > & getOutLIndex(void)  const; 
    94  
    95          const CAxis*   getRelAxis  (void) const; 
    96          const CDomain* getRelDomain(void) const; 
    97  
    9890         StdSize getDimension(void) const; 
    9991 
    100 //         StdSize getLocalSize(void) const; 
    101 //         StdSize getGlobalSize(void) const; 
    10292         StdSize  getDataSize(void) const; 
    103 //         std::vector<StdSize> getLocalShape(void) const; 
    104 //         std::vector<StdSize> getGlobalShape(void) const; 
    10593 
    10694         /// Entrées-sorties de champs /// 
     
    11098         void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const; 
    11199 
    112          void inputFieldServer(const std::deque< CArray<double, 1>* > storedClient, 
    113                                CArray<double, 1>&  storedServer) const; 
    114  
    115100         void outputField(int rank, const CArray<double,1>& stored, double* field); 
    116101         void inputField(int rank, const double* const field, CArray<double,1>& stored); 
    117102 
    118          virtual void parse(xml::CXMLNode & node); 
     103         virtual void parse(xml::CXMLNode& node); 
    119104 
    120105         /// Destructeur /// 
     
    137122 
    138123         /// Entrées-sorties de champs (interne) /// 
    139          void storeField_arr(const double * const data, CArray<double,1>& stored) const; 
    140          void restoreField_arr(const CArray<double,1>& stored, double * const data) const; 
     124         void storeField_arr(const double* const data, CArray<double,1>& stored) const; 
     125         void restoreField_arr(const CArray<double,1>& stored, double* const data) const; 
    141126 
    142127         /// Traitements protégés /// 
     
    155140         void sendAllAxis(); 
    156141 
    157          static void recvAddDomain(CEventServer& event) ; 
    158          void recvAddDomain(CBufferIn& buffer) ; 
    159          static void recvAddAxis(CEventServer& event) ; 
    160          void recvAddAxis(CBufferIn& buffer) ; 
    161  
    162          static bool dispatchEvent(CEventServer& event) ; 
    163          void outputFieldToServer(CArray<double,1>& fieldIn, int rank, CArray<double,1>& fieldOut) ; 
    164          static void recvIndex(CEventServer& event) ; 
    165          void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers) ; 
    166          void sendIndex(void) ; 
     142         static void recvAddDomain(CEventServer& event); 
     143         void recvAddDomain(CBufferIn& buffer); 
     144         static void recvAddAxis(CEventServer& event); 
     145         void recvAddAxis(CBufferIn& buffer); 
     146 
     147         static bool dispatchEvent(CEventServer& event); 
     148         static void recvIndex(CEventServer& event); 
     149         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers); 
     150         void sendIndex(void); 
    167151         void sendIndexScalarGrid(); 
    168152 
     
    198182         bool isIndexSent; 
    199183 
    200          std::deque< CArray<int, 1>* > storeIndex ; 
    201         CArray<int, 1>  storeIndex_client ; 
    202  
    203          map<int, CArray<int, 1>* >  storeIndex_toSrv ; 
    204          map<int,int> nbSenders ; 
    205  
    206          map<int, CArray<size_t, 1>* > outIndexFromClient; 
    207          void checkMask(void) ; 
     184         CArray<int, 1> storeIndex_client; 
     185 
     186         map<int, CArray<int, 1> > storeIndex_toSrv; 
     187         map<int,int> nbSenders; 
     188 
     189         map<int, CArray<size_t, 1> > outIndexFromClient; 
     190         void checkMask(void); 
    208191         void modifyMask(const CArray<int,1>& indexToModify); 
    209192 
     
    254237        bool isDataDistributed_; 
    255238 
    256  
    257 //        std::vector<ETransformationType> transformations_; 
    258239        bool isTransformed_; 
    259240        std::vector<int> axisPositionInGrid_; 
     
    271252                << "Received data size = "      << field.numElements() << " ] " 
    272253                << "The array of data has not the good size !") 
    273       this->storeField_arr(field.dataFirst(), stored) ; 
     254      this->storeField_arr(field.dataFirst(), stored); 
    274255   } 
    275256 
     
    293274     int idx = 0; 
    294275     int numElement = axisDomainOrder.numElements(); 
    295      int dim = domainMasks.size()*2 + axisMasks.size(); 
     276     int dim = domainMasks.size() * 2 + axisMasks.size(); 
    296277 
    297278     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim); 
Note: See TracChangeset for help on using the changeset viewer.