Ignore:
Timestamp:
12/01/21 16:52:24 (3 years ago)
Author:
ymipsl
Message:

tracking memory leak
Elements, views, and connectors are now managed with shared pointer.
YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src/node
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.cpp

    r2206 r2267  
    747747      for (int i=0;i<n;i++) ind(i)=index(i) ; 
    748748 
    749       localElement_ = new CLocalElement(rank, n_glo, ind) ; 
     749      localElement_ = make_shared<CLocalElement>(rank, n_glo, ind) ; 
    750750   } 
    751751 
    … …  
    783783   void CAxis::computeModelToWorkflowConnector(void) 
    784784   {  
    785      CLocalView* srcView=getLocalView(CElementView::MODEL) ; 
    786      CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ; 
    787      modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);  
     785     shared_ptr<CLocalView> srcView=getLocalView(CElementView::MODEL) ; 
     786     shared_ptr<CLocalView> dstView=getLocalView(CElementView::WORKFLOW) ; 
     787     modelToWorkflowConnector_ = make_shared<CLocalConnector>(srcView, dstView);  
    788788     modelToWorkflowConnector_->computeConnector() ; 
    789789   } 
    … …  
    834834      for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer].reference(indGlo.copy());  
    835835    } 
    836     remoteElement_[client] = new CDistributedElement(n_glo, globalIndex) ; 
     836    remoteElement_[client] = make_shared<CDistributedElement>(n_glo, globalIndex) ; 
    837837    remoteElement_[client]->addFullView() ; 
    838838  } 
    839839  
    840840  void CAxis::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,  
    841                                  CScattererConnector* &scattererConnector, const string& axisId) 
     841                                 shared_ptr<CScattererConnector> &scattererConnector, const string& axisId) 
    842842  { 
    843843    string serverAxisId = axisId.empty() ? this->getId() : axisId ; 
    … …  
    846846    this->sendAllAttributesToServer(client, serverAxisId)  ; 
    847847 
    848     CDistributedElement scatteredElement(n_glo,globalIndex) ; 
    849     scatteredElement.addFullView() ; 
    850     scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
    851                                                  context->getIntraComm(), client->getRemoteSize()) ; 
     848    auto scatteredElement = make_shared<CDistributedElement>(n_glo,globalIndex) ; 
     849    scatteredElement->addFullView() ; 
     850    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     851                                                          context->getIntraComm(), client->getRemoteSize()) ; 
    852852    scattererConnector->computeConnector() ; 
    853853     
    … …  
    866866    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ; 
    867867 
    868     sendDistributedAttributes(client, *scattererConnector, axisId) ; 
     868    sendDistributedAttributes(client, scattererConnector, axisId) ; 
    869869   
    870870    // phase 2 send the mask : data index + mask2D 
    871871    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    872872    CArray<bool,1> maskOut ; 
    873     CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    874     workflowToFull.computeConnector() ; 
     873    auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     874    workflowToFull->computeConnector() ; 
    875875    maskIn=true ; 
    876     workflowToFull.transfer(maskIn,maskOut,false) ; 
     876    workflowToFull->transfer(maskIn,maskOut,false) ; 
    877877 
    878878    // phase 3 : prepare grid scatterer connector to send data from client to server 
    … …  
    880880    map<int,CArray<bool,1>> maskOut2 ;  
    881881    scattererConnector->transfer(maskOut, maskOut2) ; 
    882     scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ; 
    883     scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     882    scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     883    scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    884884    // create new workflow view for scattered element 
    885     CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ; 
    886     clientToServerElement.addFullView() ; 
     885    auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     886    clientToServerElement->addFullView() ; 
    887887    CEventClient event2(getType(), EVENT_ID_AXIS_DISTRIBUTION); 
    888888    CMessage message2 ; 
    889889    message2<<serverAxisId<<2 ;  
    890     clientToServerElement.sendToServer(client, event2, message2) ;  
    891     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL),  
    892                                                               context->getIntraComm(), client->getRemoteSize()) ; 
     890    clientToServerElement->sendToServer(client, event2, message2) ;  
     891    clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL),  
     892                                                                        context->getIntraComm(), client->getRemoteSize()) ; 
    893893    clientToServerConnector_[client]->computeConnector() ; 
    894894 
    895     clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     895    clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    896896    clientFromServerConnector_[client]->computeConnector() ; 
    897897 
    … …  
    916916    if (phasis==0) // receive the remote element to construct the full view 
    917917    { 
    918       localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ; 
     918      localElement_ = make_shared<CLocalElement>(context->getIntraCommRank(),event) ; 
    919919      localElement_->addFullView() ; 
    920920      // construct the local dimension and indexes 
    … …  
    937937    { 
    938938      CContext* context = CContext::getCurrent(); 
    939       CDistributedElement* elementFrom = new  CDistributedElement(event) ; 
     939      shared_ptr<CDistributedElement> elementFrom = make_shared<CDistributedElement>(event) ; 
    940940      elementFrom->addFullView() ; 
    941       gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     941      gathererConnector_ = make_shared<CGathererConnector>(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    942942      gathererConnector_->computeConnector() ;  
    943943    } 
    … …  
    945945    { 
    946946//      delete gathererConnector_ ; 
    947       elementFrom_ = new  CDistributedElement(event) ; 
     947      elementFrom_ = make_shared<CDistributedElement>(event) ; 
    948948      elementFrom_->addFullView() ; 
    949 //      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     949//      gathererConnector_ =  make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    950950//      gathererConnector_ -> computeConnector() ; 
    951951    } 
    … …  
    961961    mask.reference(serverMask.copy()) ; 
    962962  
    963     serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     963    serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    964964    serverFromClientConnector_->computeConnector() ; 
    965965       
    966     serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    967                                                          context->getIntraComm(), client->getRemoteSize()) ; 
     966    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     967                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    968968    serverToClientConnector_->computeConnector() ; 
    969969  } 
    970970  CATCH_DUMP_ATTR 
    971971 
    972   void CAxis::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId) 
     972  void CAxis::sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector, const string& axisId) 
    973973  { 
    974974    string serverAxisId = axisId.empty() ? this->getId() : axisId ; 
    … …  
    981981        CMessage message ; 
    982982        message<<serverAxisId<<string("value") ;  
    983         scattererConnector.transfer(value, client, event,message) ; 
     983        scattererConnector->transfer(value, client, event,message) ; 
    984984      } 
    985985    } 
    … …  
    991991        CMessage message ; 
    992992        message<<serverAxisId<<string("bounds") ;  
    993         scattererConnector.transfer(2, bounds, client, event,message) ; 
     993        scattererConnector->transfer(2, bounds, client, event,message) ; 
    994994      } 
    995995    } 
    … …  
    10161016        CMessage message ; 
    10171017        message<<serverAxisId<<string("label")<<maxSize ; 
    1018         scattererConnector.transfer(maxSize, charArray, client, event,message) ; 
     1018        scattererConnector->transfer(maxSize, charArray, client, event,message) ; 
    10191019      } 
    10201020    } 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/axis.hpp

    r2206 r2267  
    222222          
    223223        private: 
    224          CLocalElement* localElement_ = nullptr ; 
     224         shared_ptr<CLocalElement> localElement_ ; 
    225225         void initializeLocalElement(void) ; 
    226226        public:  
    227          CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
    228          CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
     227         shared_ptr<CLocalElement> getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
     228         shared_ptr<CLocalView> getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
    229229        private: 
    230230         void addFullView(void) ; 
    … …  
    233233 
    234234        private: 
    235          CLocalConnector* modelToWorkflowConnector_ ; 
     235         shared_ptr<CLocalConnector> modelToWorkflowConnector_ ; 
    236236         void computeModelToWorkflowConnector(void)  ; 
    237237        public: 
    238          CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
     238         shared_ptr<CLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
    239239        
    240240       public: 
    241241         void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    242          void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector, 
     242         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector>& scattererConnector, 
    243243                                 const string& axisId="") ; 
    244244 
    … …  
    246246         void receivedAxisDistribution(CEventServer& event, int phasis) ; 
    247247         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client ) ; 
    248          void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId) ; 
     248         void sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector, const string& axisId) ; 
    249249         static void recvDistributedAttributes(CEventServer& event) ; 
    250250         void recvDistributedAttributes(CEventServer& event, const string& type) ; 
    251251       private: 
    252          map<CContextClient*, CDistributedElement*> remoteElement_ ; 
    253        public:  
    254          CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
    255        private: 
    256          map<CContextClient*, CScattererConnector*> clientToServerConnector_ ; 
    257        public:  
    258          CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
    259        private: 
    260          CGathererConnector*  gathererConnector_ ; 
     252         map<CContextClient*, shared_ptr<CDistributedElement>> remoteElement_ ; 
     253       public:  
     254         shared_ptr<CDistributedElement> getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
     255       private: 
     256         map<CContextClient*, shared_ptr<CScattererConnector>> clientToServerConnector_ ; 
     257       public:  
     258         shared_ptr<CScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
     259       private: 
     260         shared_ptr<CGathererConnector>  gathererConnector_ ; 
    261261       public: 
    262          CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
    263        private: 
    264          CGathererConnector* serverFromClientConnector_ ; 
    265          CDistributedElement* elementFrom_ ; 
     262         shared_ptr<CGathererConnector> getGathererConnector(void) { return gathererConnector_ ;} 
     263       private: 
     264         shared_ptr<CGathererConnector> serverFromClientConnector_ ; 
     265         shared_ptr<CDistributedElement> elementFrom_ ; 
    266266       public: 
    267         CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
    268  
    269        private: 
    270          CScattererConnector* serverToClientConnector_ = nullptr ; 
    271        public:  
    272          CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}  
    273  
    274        private: 
    275           map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ; 
    276        public:  
    277          CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}  
     267        shared_ptr<CGathererConnector> getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
     268 
     269       private: 
     270         shared_ptr<CScattererConnector> serverToClientConnector_ = nullptr ; 
     271       public:  
     272         shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  
     273 
     274       private: 
     275          map<CContextClient*,shared_ptr<CGathererConnector>>  clientFromServerConnector_  ; 
     276       public:  
     277        shared_ptr<CGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}  
    278278 
    279279         DECLARE_REF_FUNC(Axis,axis) 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.cpp

    r2249 r2267  
    17401740      // testing ? 
    17411741     /* 
    1742       CLocalView* local = localElement_->getView(CElementView::WORKFLOW) ; 
    1743       CLocalView* model = localElement_->getView(CElementView::MODEL) ; 
     1742      shared_ptr<CLocalView> local = localElement_->getView(CElementView::WORKFLOW) ; 
     1743      shared_ptr<CLocalView> model = localElement_->getView(CElementView::MODEL) ; 
    17441744 
    17451745      CLocalConnector test1(model, local) ; 
    … …  
    17731773      for(int ij=0; ij<nij ; ij++) ij_index(ij) = i_index(ij)+j_index(ij)*ni_glo ; 
    17741774      int rank = CContext::getCurrent()->getIntraCommRank() ; 
    1775       localElement_ = new CLocalElement(rank, ni_glo*nj_glo, ij_index) ; 
     1775      localElement_ = make_shared<CLocalElement>(rank, ni_glo*nj_glo, ij_index) ; 
    17761776   } 
    17771777 
    … …  
    18301830   void CDomain::computeModelToWorkflowConnector(void) 
    18311831   {  
    1832      CLocalView* srcView=getLocalView(CElementView::MODEL) ; 
    1833      CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ; 
    1834      modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);  
     1832     shared_ptr<CLocalView> srcView=getLocalView(CElementView::MODEL) ; 
     1833     shared_ptr<CLocalView> dstView=getLocalView(CElementView::WORKFLOW) ; 
     1834     modelToWorkflowConnector_ = make_shared<CLocalConnector>(srcView, dstView);  
    18351835     modelToWorkflowConnector_->computeConnector() ; 
    18361836   } 
    … …  
    19891989      for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer] = indGlo ;  
    19901990    } 
    1991     remoteElement_[client] = new CDistributedElement(ni_glo*nj_glo, globalIndex) ; 
     1991    remoteElement_[client] = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndex) ; 
    19921992    remoteElement_[client]->addFullView() ; 
    19931993  } 
    … …  
    19971997 
    19981998  void CDomain::distributeToServer(CContextClient* client, map<int, CArray<size_t,1>>& globalIndex, 
    1999                                    CScattererConnector* &scattererConnector, const string& domainId) 
     1999                                   shared_ptr<CScattererConnector> &scattererConnector, const string& domainId) 
    20002000  TRY 
    20012001  { 
    … …  
    20052005    this->sendAllAttributesToServer(client, serverDomainId)  ; 
    20062006 
    2007     CDistributedElement scatteredElement(ni_glo*nj_glo, globalIndex) ; 
    2008     scatteredElement.addFullView() ; 
    2009     scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
    2010                                            context->getIntraComm(), client->getRemoteSize()) ; 
     2007    auto scatteredElement = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndex) ; 
     2008    scatteredElement->addFullView() ; 
     2009    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     2010                                                          context->getIntraComm(), client->getRemoteSize()) ; 
    20112011    scattererConnector->computeConnector() ; 
    20122012 
    … …  
    20252025    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ; 
    20262026     
    2027     sendDistributedAttributes(client, *scattererConnector, domainId) ; 
     2027    sendDistributedAttributes(client, scattererConnector, domainId) ; 
    20282028 
    20292029   
    … …  
    20312031    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    20322032    CArray<bool,1> maskOut ; 
    2033     CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    2034     workflowToFull.computeConnector() ; 
     2033    auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     2034    workflowToFull->computeConnector() ; 
    20352035    maskIn=true ; 
    2036     workflowToFull.transfer(maskIn,maskOut,false) ; 
     2036    workflowToFull->transfer(maskIn,maskOut,false) ; 
    20372037 
    20382038 
    … …  
    20412041    map<int,CArray<bool,1>> maskOut2 ;  
    20422042    scattererConnector->transfer(maskOut, maskOut2, false) ; 
    2043     scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ; 
    2044     scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     2043    scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     2044    scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    20452045    // create new workflow view for scattered element 
    2046     CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ; 
    2047     clientToServerElement.addFullView() ; 
     2046    auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     2047    clientToServerElement->addFullView() ; 
    20482048    CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
    20492049    CMessage message2 ; 
    20502050    message2<<serverDomainId<<2 ;  
    2051     clientToServerElement.sendToServer(client, event2, message2) ;  
    2052     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL), 
    2053                                                                context->getIntraComm(), client->getRemoteSize()) ; 
     2051    clientToServerElement->sendToServer(client, event2, message2) ;  
     2052    clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
     2053                                                                        context->getIntraComm(), client->getRemoteSize()) ; 
    20542054    clientToServerConnector_[client]->computeConnector() ; 
    20552055 
    2056     clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     2056    clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    20572057    clientFromServerConnector_[client]->computeConnector() ; 
    20582058 
    … …  
    20762076    if (phasis==0) // receive the remote element to construct the full view 
    20772077    { 
    2078       localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ; 
     2078      localElement_ = make_shared<CLocalElement>(context->getIntraCommRank(),event) ; 
    20792079      localElement_->addFullView() ; 
    20802080      // construct the local dimension and indexes 
    … …  
    21022102    { 
    21032103      CContext* context = CContext::getCurrent(); 
    2104       CDistributedElement* elementFrom = new  CDistributedElement(event) ; 
     2104      shared_ptr<CDistributedElement> elementFrom = make_shared<CDistributedElement>(event) ; 
    21052105      elementFrom->addFullView() ; 
    2106       gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     2106      gathererConnector_ = make_shared<CGathererConnector>(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    21072107      gathererConnector_->computeConnector() ;  
    21082108    } 
    … …  
    21102110    { 
    21112111//      delete gathererConnector_ ; 
    2112       elementFrom_ = new  CDistributedElement(event) ; 
     2112      elementFrom_ = make_shared<CDistributedElement>(event) ; 
    21132113      elementFrom_->addFullView() ; 
    2114 //      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     2114//      gathererConnector_ =  make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    21152115//      gathererConnector_ -> computeConnector() ; 
    21162116    } 
    … …  
    21272127    mask_1d.reference(serverMask.copy()) ; 
    21282128  
    2129     serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     2129    serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    21302130    serverFromClientConnector_->computeConnector() ; 
    21312131       
    2132     serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    2133                                                        context->getIntraComm(), client->getRemoteSize()) ; 
     2132    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     2133                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    21342134    serverToClientConnector_->computeConnector() ; 
    21352135  } 
    … …  
    21372137 
    21382138 
    2139   void CDomain::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector,  const string& domainId) 
     2139  void CDomain::sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector,  const string& domainId) 
    21402140  { 
    21412141    string serverDomainId = domainId.empty() ? this->getId() : domainId ; 
    … …  
    21482148        CMessage message ; 
    21492149        message<<serverDomainId<<string("lon") ;  
    2150         scattererConnector.transfer(lonvalue, client, event,message) ; 
     2150        scattererConnector->transfer(lonvalue, client, event,message) ; 
    21512151      } 
    21522152       
    … …  
    21552155        CMessage message ; 
    21562156        message<<serverDomainId<<string("lat") ;  
    2157         scattererConnector.transfer(latvalue, client, event, message) ; 
     2157        scattererConnector->transfer(latvalue, client, event, message) ; 
    21582158      } 
    21592159    } 
    … …  
    21652165        CMessage message ; 
    21662166        message<<serverDomainId<<string("boundslon") ;  
    2167         scattererConnector.transfer(nvertex, bounds_lonvalue, client, event, message ) ; 
     2167        scattererConnector->transfer(nvertex, bounds_lonvalue, client, event, message ) ; 
    21682168      } 
    21692169 
    … …  
    21722172        CMessage message ; 
    21732173        message<<serverDomainId<<string("boundslat") ;  
    2174         scattererConnector.transfer(nvertex, bounds_latvalue, client, event, message ) ; 
     2174        scattererConnector->transfer(nvertex, bounds_latvalue, client, event, message ) ; 
    21752175      } 
    21762176    } 
    … …  
    21812181      CMessage message ; 
    21822182      message<<serverDomainId<<string("area") ;  
    2183       scattererConnector.transfer(areavalue, client, event,message) ; 
     2183      scattererConnector->transfer(areavalue, client, event,message) ; 
    21842184    } 
    21852185  } 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/domain.hpp

    r2206 r2267  
    285285       ////////////////////////////////////////////////////////////////////////////////////// 
    286286       private: 
    287          CLocalElement* localElement_ = nullptr ; 
     287         shared_ptr<CLocalElement> localElement_ = nullptr ; 
    288288         void initializeLocalElement(void) ; 
    289289        
    290290       public:   
    291          CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
    292          CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
     291         shared_ptr<CLocalElement> getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
     292         shared_ptr<CLocalView> getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
    293293        
    294294       private:   
    … …  
    298298         
    299299       private: 
    300          CLocalConnector* modelToWorkflowConnector_ ; 
     300         shared_ptr<CLocalConnector> modelToWorkflowConnector_ ; 
    301301         void computeModelToWorkflowConnector(void)  ; 
    302302       public: 
    303          CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
     303         shared_ptr<CLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
    304304 
    305305       public: 
    306306         void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    307          void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector, 
     307         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector> &scattererConnector, 
    308308                                 const string& domainId="") ; 
    309309 
    … …  
    311311         void receivedDomainDistribution(CEventServer& event, int phasis) ; 
    312312 
    313          void sendDistributedAttributes(CContextClient* client, CScattererConnector& scaterrerConnector, const string& domainId) ; 
     313         void sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scaterrerConnector, const string& domainId) ; 
    314314         static void recvDistributedAttributes(CEventServer& event) ; 
    315315         void recvDistributedAttributes(CEventServer& event, const string& type) ; 
    … …  
    317317 
    318318       private: 
    319          map<CContextClient*, CDistributedElement*> remoteElement_ ; 
     319         map<CContextClient*, shared_ptr<CDistributedElement>> remoteElement_ ; 
    320320       public:  
    321          CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
    322        private: 
    323          map<CContextClient*, CScattererConnector*> clientToServerConnector_ ; 
     321         shared_ptr<CDistributedElement> getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
     322       private: 
     323         map<CContextClient*, shared_ptr<CScattererConnector>> clientToServerConnector_ ; 
    324324       public:  
    325          CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
    326         
    327        private: 
    328          CGathererConnector*  gathererConnector_ ; 
    329        public: 
    330          CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
     325         shared_ptr<CScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
     326        
     327       private: 
     328         shared_ptr<CGathererConnector>  gathererConnector_ ; 
     329       public: 
     330         shared_ptr<CGathererConnector> getGathererConnector(void) { return gathererConnector_ ;} 
    331331        private: 
    332          CGathererConnector* serverFromClientConnector_ ; 
    333          CDistributedElement* elementFrom_ ; 
    334        public: 
    335          CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
    336  
    337        private: 
    338          CScattererConnector*  serverToClientConnector_ = nullptr ; 
     332         shared_ptr<CGathererConnector> serverFromClientConnector_ ; 
     333         shared_ptr<CDistributedElement> elementFrom_ ; 
     334       public: 
     335         shared_ptr<CGathererConnector> getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
     336 
     337       private: 
     338         shared_ptr<CScattererConnector>  serverToClientConnector_ = nullptr ; 
    339339       public:  
    340          CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}  
    341  
    342        private: 
    343          map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ; 
     340         shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  
     341 
     342       private: 
     343         map<CContextClient*,shared_ptr<CGathererConnector>>  clientFromServerConnector_  ; 
    344344       public:  
    345          CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}         
     345         shared_ptr<CGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}         
    346346          
    347347 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp

    r2264 r2267  
    14291429    if (posDistributed==elements.size()) posDistributed=0 ; // grid composed only of scalar 
    14301430     
    1431     vector<CLocalView*> localViews ; 
    1432     vector<CLocalView*> workflowView ; 
    1433     vector<CDistributedView*> remoteViews ; 
     1431    vector<shared_ptr<CLocalView>> localViews ; 
     1432    vector<shared_ptr<CLocalView>> workflowView ; 
     1433    vector<shared_ptr<CDistributedView>> remoteViews ; 
    14341434 
    14351435    for(int i=0 ; i<elements.size() ; i++) 
    … …  
    14621462     
    14631463    // CGridClientServerRemoteConnector : workflowView is added to avoid spurious optimisation with only the fullview 
    1464     CGridClientServerRemoteConnector gridRemoteConnector(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ; 
    1465     gridRemoteConnector.computeConnector() ; 
     1464    auto gridRemoteConnector = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ; 
     1465    gridRemoteConnector->computeConnector() ; 
    14661466     
    1467     vector<CScattererConnector*> scattererConnectors ; 
    1468     CScattererConnector* scattererConnector; 
     1467    vector<shared_ptr<CScattererConnector>> scattererConnectors ; 
     1468    shared_ptr<CScattererConnector> scattererConnector; 
    14691469    for(int i=0 ; i<elements.size() ; i++) 
    14701470    { 
    … …  
    14721472      {  
    14731473        CDomain* domain = (CDomain*) elements[i].ptr ; 
    1474         if (isCoupling) domain->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector,  domain->getCouplingAlias(fieldId,i)) ; 
     1474        if (isCoupling) domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  domain->getCouplingAlias(fieldId,i)) ; 
    14751475        else  
    14761476        { 
    14771477          sendAddDomain(domain->getId(),client) ; 
    1478           domain->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ; 
     1478          domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
    14791479        } 
    14801480        scattererConnectors.push_back(scattererConnector) ; 
    … …  
    14831483      { 
    14841484        CAxis* axis = (CAxis*) elements[i].ptr ; 
    1485         if (isCoupling) axis->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector,  axis->getCouplingAlias(fieldId,i)) ; 
     1485        if (isCoupling) axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  axis->getCouplingAlias(fieldId,i)) ; 
    14861486        else  
    14871487        { 
    14881488          sendAddAxis(axis->getId(),client) ; 
    1489           axis->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ; 
     1489          axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
    14901490        } 
    14911491        scattererConnectors.push_back(scattererConnector) ; 
    … …  
    14941494      { 
    14951495        CScalar* scalar = (CScalar*) elements[i].ptr ; 
    1496         if (isCoupling) scalar->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector,  scalar->getCouplingAlias(fieldId,i)) ; 
     1496        if (isCoupling) scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  scalar->getCouplingAlias(fieldId,i)) ; 
    14971497        else  
    14981498        { 
    14991499          sendAddScalar(scalar->getId(),client) ; 
    1500           scalar->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ; 
     1500          scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
    15011501        } 
    15021502        scattererConnectors.push_back(scattererConnector) ; 
    … …  
    15041504    } 
    15051505 
    1506     CGridScattererConnector gridScattererConnector(scattererConnectors) ; 
    1507     CGridLocalConnector* workflowToFull = getGridLocalElements()->getConnector(CElementView::WORKFLOW, CElementView::FULL) ; 
     1506    auto gridScattererConnector = make_shared<CGridScattererConnector>(scattererConnectors) ; 
     1507    shared_ptr<CGridLocalConnector> workflowToFull = getGridLocalElements()->getConnector(CElementView::WORKFLOW, CElementView::FULL) ; 
    15081508    CArray<bool,1> maskIn(workflowToFull->getSrcSize()) ; 
    15091509    CArray<bool,1> maskOut(workflowToFull->getDstSize()) ; 
    … …  
    15151515    if (isCoupling) message<<getCouplingAlias(fieldId) ; 
    15161516    else message<<getId() ;  
    1517     gridScattererConnector.transfer(maskOut, client, event, message) ; 
    1518     for(auto& it : scattererConnectors) delete it ; 
    1519  
    1520     vector<CScattererConnector*> clientToServerConnectors ; 
    1521     vector<CGathererConnector*>  clientFromServerConnectors ; 
     1517    gridScattererConnector->transfer(maskOut, client, event, message) ; 
     1518    
     1519    vector<shared_ptr<CScattererConnector>> clientToServerConnectors ; 
     1520    vector<shared_ptr<CGathererConnector>>  clientFromServerConnectors ; 
    15221521    for(auto& element : elements) 
    15231522    { 
    … …  
    15411540     
    15421541    // compute the grid clientToServerConnector to send flux from client to servers 
    1543     clientToServerConnector_[client] = new CGridScattererConnector(clientToServerConnectors) ; 
    1544     clientFromServerConnector_[client] = new CGridGathererConnector(clientFromServerConnectors) ; 
     1542    clientToServerConnector_[client] = make_shared<CGridScattererConnector>(clientToServerConnectors) ; 
     1543    clientFromServerConnector_[client] = make_shared<CGridGathererConnector>(clientFromServerConnectors) ; 
    15451544 
    15461545  } 
    … …  
    15561555  void CGrid::receiveMask(CEventServer& event) 
    15571556  { 
    1558     vector<CGathererConnector*> gathererConnectors ; 
    1559     vector<CLocalView*> fullViews ; 
     1557    vector<shared_ptr<CGathererConnector>> gathererConnectors ; 
     1558    vector<shared_ptr<CLocalView>> fullViews ; 
    15601559 
    15611560    for(auto& element : getElements()) 
    … …  
    15781577      } 
    15791578    } 
    1580     CGridGathererConnector gridGathererConnector(gathererConnectors) ; 
    1581     CGridMaskConnector gridMaskConnector(fullViews) ; 
     1579    auto gridGathererConnector = make_shared<CGridGathererConnector>(gathererConnectors) ; 
     1580    auto gridMaskConnector = make_shared<CGridMaskConnector>(fullViews) ; 
    15821581 
    15831582    CArray<bool,1> maskOut ; 
    1584     gridGathererConnector.transfer_or(event,maskOut) ; 
    1585     gridMaskConnector.computeConnector(maskOut) ; 
     1583    gridGathererConnector->transfer_or(event,maskOut) ; 
     1584    gridMaskConnector->computeConnector(maskOut) ; 
    15861585 
    15871586    CContextClient* client = event.getContextServer()->getAssociatedClient() ; 
    … …  
    15891588    for(auto& element : getElements()) 
    15901589    { 
    1591       if (element.type==TYPE_DOMAIN) element.domain->setServerMask(gridMaskConnector.getElementMask(i),client); 
    1592       else if (element.type==TYPE_AXIS) element.axis->setServerMask(gridMaskConnector.getElementMask(i),client); 
    1593       else if (element.type==TYPE_SCALAR) element.scalar->setServerMask(gridMaskConnector.getElementMask(i),client); 
     1590      if (element.type==TYPE_DOMAIN) element.domain->setServerMask(gridMaskConnector->getElementMask(i),client); 
     1591      else if (element.type==TYPE_AXIS) element.axis->setServerMask(gridMaskConnector->getElementMask(i),client); 
     1592      else if (element.type==TYPE_SCALAR) element.scalar->setServerMask(gridMaskConnector->getElementMask(i),client); 
    15941593      i++ ; 
    15951594    } 
    … …  
    23102309    auto axis=axisList.begin() ; 
    23112310    auto scalar=scalarList.begin() ; 
    2312     vector<CLocalElement*> elements; 
     2311    vector<shared_ptr<CLocalElement>> elements; 
    23132312    for(auto order : order_) 
    23142313    { 
    … …  
    23322331    { 
    23332332      vector<bool> mask(getMask().getVector()) ; 
    2334       gridLocalElements_ = new CGridLocalElements(elements, mask) ;   
    2335     } 
    2336     else gridLocalElements_ = new CGridLocalElements(elements) ;   
     2333      gridLocalElements_ = make_shared<CGridLocalElements>(elements, mask) ;   
     2334    } 
     2335    else gridLocalElements_ = make_shared<CGridLocalElements>(elements) ;   
    23372336  } 
    23382337 
    … …  
    23592358  void CGrid::computeServerFromClientConnector(void) 
    23602359  { 
    2361     vector<CGathererConnector*> connectors ; 
     2360    vector<shared_ptr<CGathererConnector>> connectors ; 
    23622361    for(auto& element : getElements()) 
    23632362    { 
    … …  
    23662365      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerFromClientConnector()) ;  
    23672366    } 
    2368     serverFromClientConnector_ = new CGridGathererConnector(connectors) ; 
     2367    serverFromClientConnector_ = make_shared<CGridGathererConnector>(connectors) ; 
    23692368  } 
    23702369 
    23712370  void CGrid::computeServerToClientConnector(void) 
    23722371  { 
    2373     vector<CScattererConnector*> connectors ; 
     2372    vector<shared_ptr<CScattererConnector>> connectors ; 
    23742373    for(auto& element : getElements()) 
    23752374    { 
    … …  
    23782377      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerToClientConnector()) ;  
    23792378    } 
    2380     serverToClientConnector_ = new CGridScattererConnector(connectors) ; 
     2379    serverToClientConnector_ = make_shared<CGridScattererConnector>(connectors) ; 
    23812380  } 
    23822381 
    23832382  void CGrid::computeClientFromClientConnector(void) 
    23842383  { 
    2385     vector<CGathererConnector*> connectors ; 
     2384    vector<shared_ptr<CGathererConnector>> connectors ; 
    23862385    for(auto& element : getElements()) 
    23872386    { 
    … …  
    23902389      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerFromClientConnector()) ;  
    23912390    } 
    2392     clientFromClientConnector_ = new CGridGathererConnector(connectors) ; 
     2391    clientFromClientConnector_ = make_shared<CGridGathererConnector>(connectors) ; 
    23932392  } 
    23942393 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp

    r2206 r2267  
    328328 
    329329      private:   
    330         CGridLocalElements* gridLocalElements_= nullptr ; 
     330       shared_ptr<CGridLocalElements> gridLocalElements_= nullptr ; 
    331331        void computeGridLocalElements(void) ; 
    332332      public: 
    333         CGridLocalElements* getGridLocalElements(void) { if (gridLocalElements_==nullptr) computeGridLocalElements() ; return gridLocalElements_ ;} 
    334  
    335       private: 
    336         CGridLocalConnector* modelToWorkflowConnector_ = nullptr ; 
     333        shared_ptr<CGridLocalElements> getGridLocalElements(void) { if (gridLocalElements_==nullptr) computeGridLocalElements() ; return gridLocalElements_ ;} 
     334 
     335      private: 
     336        shared_ptr<CGridLocalConnector> modelToWorkflowConnector_ = nullptr ; 
    337337      public: 
    338338        void computeModelToWorkflowConnector(void) ; 
    339         CGridLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_;} 
    340  
    341       private: 
    342         CGridLocalConnector* workflowToModelConnector_ = nullptr; 
     339        shared_ptr<CGridLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_;} 
     340 
     341      private: 
     342        shared_ptr<CGridLocalConnector> workflowToModelConnector_ = nullptr; 
    343343      public: 
    344344        void computeWorkflowToModelConnector(void) ; 
    345         CGridLocalConnector* getWorkflowToModelConnector(void) { if (workflowToModelConnector_==nullptr) computeWorkflowToModelConnector() ; return workflowToModelConnector_;} 
     345        shared_ptr<CGridLocalConnector> getWorkflowToModelConnector(void) { if (workflowToModelConnector_==nullptr) computeWorkflowToModelConnector() ; return workflowToModelConnector_;} 
    346346 
    347347      public: //?  
    … …  
    350350             
    351351      private: 
    352         CGridLocalConnector* workflowToFullConnector_ = nullptr; 
     352        shared_ptr<CGridLocalConnector> workflowToFullConnector_ = nullptr; 
    353353      public: 
    354354        void computeWorkflowToFullConnector(void) ; 
    355         CGridLocalConnector* getWorkflowToFullConnector(void) { if (workflowToFullConnector_==nullptr) computeWorkflowToFullConnector() ; return workflowToFullConnector_;} 
    356  
    357       private: 
    358         CGridLocalConnector* fullToWorkflowConnector_ = nullptr; 
     355        shared_ptr<CGridLocalConnector> getWorkflowToFullConnector(void) { if (workflowToFullConnector_==nullptr) computeWorkflowToFullConnector() ; return workflowToFullConnector_;} 
     356 
     357      private: 
     358        shared_ptr<CGridLocalConnector> fullToWorkflowConnector_ = nullptr; 
    359359      public: 
    360360        void computeFullToWorkflowConnector(void) ; 
    361         CGridLocalConnector* getFullToWorkflowConnector(void) { if (fullToWorkflowConnector_==nullptr) computeFullToWorkflowConnector() ; return fullToWorkflowConnector_;} 
     361        shared_ptr<CGridLocalConnector> getFullToWorkflowConnector(void) { if (fullToWorkflowConnector_==nullptr) computeFullToWorkflowConnector() ; return fullToWorkflowConnector_;} 
    362362 
    363363     
    364364 
    365365      private: 
    366          CGridGathererConnector* clientFromClientConnector_ = nullptr ; 
    367       public: 
    368          CGridGathererConnector* getClientFromClientConnector(void) { if (clientFromClientConnector_==nullptr) computeClientFromClientConnector() ; return clientFromClientConnector_;} 
     366         shared_ptr<CGridGathererConnector> clientFromClientConnector_ = nullptr ; 
     367      public: 
     368         shared_ptr<CGridGathererConnector> getClientFromClientConnector(void) { if (clientFromClientConnector_==nullptr) computeClientFromClientConnector() ; return clientFromClientConnector_;} 
    369369         void computeClientFromClientConnector(void) ; 
    370370 
    371371      private: 
    372          map<CContextClient*, CGridScattererConnector*> clientToClientConnector_ ; 
    373       public: 
    374          CGridScattererConnector* getClientToClientConnector(CContextClient* client) { return clientToClientConnector_[client] ;} // make some test to see if connector exits for the given client 
     372         map<CContextClient*, shared_ptr<CGridScattererConnector>> clientToClientConnector_ ; 
     373      public: 
     374         shared_ptr<CGridScattererConnector> getClientToClientConnector(CContextClient* client) { return clientToClientConnector_[client] ;} // make some test to see if connector exits for the given client 
    375375   
    376376 
    377377      private: 
    378          map<CContextClient*,CGridGathererConnector*> clientFromServerConnector_  ; 
    379       public: 
    380          CGridGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client];} 
     378         map<CContextClient*,shared_ptr<CGridGathererConnector>> clientFromServerConnector_  ; 
     379      public: 
     380         shared_ptr<CGridGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client];} 
    381381         void computeClientFromServerConnector(void) ; 
    382382 
    383383      private: 
    384          CGridScattererConnector* serverToClientConnector_=nullptr ; 
    385       public: 
    386          CGridScattererConnector* getServerToClientConnector(void) { if (serverToClientConnector_==nullptr) computeServerToClientConnector() ; return serverToClientConnector_;} 
     384         shared_ptr<CGridScattererConnector> serverToClientConnector_=nullptr ; 
     385      public: 
     386         shared_ptr<CGridScattererConnector> getServerToClientConnector(void) { if (serverToClientConnector_==nullptr) computeServerToClientConnector() ; return serverToClientConnector_;} 
    387387         void computeServerToClientConnector(void) ; 
    388388      private: 
    389          map<CContextClient*, CGridScattererConnector*> clientToServerConnector_ ; 
    390       public: 
    391          CGridScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} // make some test to see if connector exits for the given client 
     389         map<CContextClient*, shared_ptr<CGridScattererConnector>> clientToServerConnector_ ; 
     390      public: 
     391         shared_ptr<CGridScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} // make some test to see if connector exits for the given client 
    392392          
    393393      private: 
    394          CGridGathererConnector* serverFromClientConnector_ = nullptr ; 
    395       public: 
    396          CGridGathererConnector* getServerFromClientConnector(void) { if (serverFromClientConnector_==nullptr) computeServerFromClientConnector() ; return serverFromClientConnector_;} 
     394         shared_ptr<CGridGathererConnector> serverFromClientConnector_ = nullptr ; 
     395      public: 
     396         shared_ptr<CGridGathererConnector> getServerFromClientConnector(void) { if (serverFromClientConnector_==nullptr) computeServerFromClientConnector() ; return serverFromClientConnector_;} 
    397397         void computeServerFromClientConnector(void) ; 
    398398 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/scalar.cpp

    r2264 r2267  
    346346      CArray<size_t,1> index(n) ; 
    347347      if (n==1) index(0)=0 ; 
    348       localElement_ = new CLocalElement(rank, 1, index) ; 
     348      localElement_ = make_shared<CLocalElement>(rank, 1, index) ; 
    349349   } 
    350350 
    … …  
    377377   void CScalar::computeModelToWorkflowConnector(void) 
    378378   {  
    379      CLocalView* srcView=getLocalView(CElementView::MODEL) ; 
    380      CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ; 
    381      modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);  
     379     shared_ptr<CLocalView> srcView=getLocalView(CElementView::MODEL) ; 
     380     shared_ptr<CLocalView> dstView=getLocalView(CElementView::WORKFLOW) ; 
     381     modelToWorkflowConnector_ = make_shared<CLocalConnector>(srcView, dstView);  
    382382     modelToWorkflowConnector_->computeConnector() ; 
    383383   } 
    … …  
    409409      for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer].reference(indGlo.copy()) ;  
    410410    } 
    411     remoteElement_[client] = new CDistributedElement(nglo, globalIndex) ; 
     411    remoteElement_[client] = make_shared<CDistributedElement>(nglo, globalIndex) ; 
    412412    remoteElement_[client]->addFullView() ; 
    413413  } 
    414414  
    415415  void CScalar::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,  
    416                                    CScattererConnector* &scattererConnector, const string& scalarId) 
     416                                   shared_ptr<CScattererConnector> &scattererConnector, const string& scalarId) 
    417417  { 
    418418    string serverScalarId = scalarId.empty() ? this->getId() : scalarId ; 
    … …  
    421421    this->sendAllAttributesToServer(client, serverScalarId)  ; 
    422422 
    423     CDistributedElement scatteredElement(1,globalIndex) ; 
    424     scatteredElement.addFullView() ; 
    425     scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
    426                                                  context->getIntraComm(), client->getRemoteSize()) ; 
     423    auto scatteredElement = make_shared<CDistributedElement>(1,globalIndex) ; 
     424    scatteredElement->addFullView() ; 
     425    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     426                                                          context->getIntraComm(), client->getRemoteSize()) ; 
    427427    scattererConnector->computeConnector() ; 
    428428     
    … …  
    441441    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ; 
    442442 
    443     sendDistributedAttributes(client, *scattererConnector, scalarId) ; 
     443    sendDistributedAttributes(client, scattererConnector, scalarId) ; 
    444444   
    445445    // phase 2 send the mask : data index + mask2D 
    446446    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    447447    CArray<bool,1> maskOut ; 
    448     CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    449     workflowToFull.computeConnector() ; 
     448    auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     449    workflowToFull->computeConnector() ; 
    450450    maskIn=true ; 
    451     workflowToFull.transfer(maskIn,maskOut,false) ; 
     451    workflowToFull->transfer(maskIn,maskOut,false) ; 
    452452 
    453453    // phase 3 : prepare grid scatterer connector to send data from client to server 
    … …  
    455455    map<int,CArray<bool,1>> maskOut2 ;  
    456456    scattererConnector->transfer(maskOut, maskOut2) ; 
    457     scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ; 
    458     scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     457    scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     458    scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    459459    // create new workflow view for scattered element 
    460     CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ; 
    461     clientToServerElement.addFullView() ; 
     460    auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     461    clientToServerElement->addFullView() ; 
    462462    CEventClient event2(getType(), EVENT_ID_SCALAR_DISTRIBUTION); 
    463463    CMessage message2 ; 
    464464    message2<<serverScalarId<<2 ;  
    465     clientToServerElement.sendToServer(client, event2, message2) ;  
    466     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL), 
    467                                                                context->getIntraComm(), client->getRemoteSize()) ; 
     465    clientToServerElement->sendToServer(client, event2, message2) ;  
     466    clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
     467                                                                        context->getIntraComm(), client->getRemoteSize()) ; 
    468468    clientToServerConnector_[client]->computeConnector() ; 
    469469 
    470     clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     470    clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    471471    clientFromServerConnector_[client]->computeConnector() ; 
    472472 
    … …  
    489489    if (phasis==0) // receive the remote element to construct the full view 
    490490    { 
    491       localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ; 
     491      localElement_ = make_shared<CLocalElement>(context->getIntraCommRank(),event) ; 
    492492      localElement_->addFullView() ; 
    493493      // construct the local dimension and indexes 
    … …  
    499499    { 
    500500      CContext* context = CContext::getCurrent(); 
    501       CDistributedElement* elementFrom = new  CDistributedElement(event) ; 
     501      shared_ptr<CDistributedElement> elementFrom = make_shared<CDistributedElement>(event) ; 
    502502      elementFrom->addFullView() ; 
    503       gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     503      gathererConnector_ = make_shared<CGathererConnector>(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    504504      gathererConnector_->computeConnector() ;  
    505505    } 
    … …  
    507507    { 
    508508//      delete gathererConnector_ ; 
    509       elementFrom_ = new  CDistributedElement(event) ; 
     509      elementFrom_ = make_shared<CDistributedElement>(event) ; 
    510510      elementFrom_->addFullView() ; 
    511 //      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
     511//      gathererConnector_ =  make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    512512//      gathererConnector_ -> computeConnector() ; 
    513513    } 
    … …  
    522522    if (serverMask.numElements()==1) mask = serverMask(0) ; 
    523523  
    524     serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     524    serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    525525    serverFromClientConnector_->computeConnector() ; 
    526526       
    527     serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    528                                                          context->getIntraComm(), client->getRemoteSize()) ; 
     527    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     528                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    529529    serverToClientConnector_->computeConnector() ; 
    530530  } 
    531531  CATCH_DUMP_ATTR 
    532532 
    533   void CScalar::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId) 
     533  void CScalar::sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector, const string& scalarId) 
    534534  { 
    535535    string serverScalarId = scalarId.empty() ? this->getId() : scalarId ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/scalar.hpp

    r2206 r2267  
    175175    ////////////////////////////////////////////////////////////////////////////////////// 
    176176    private: 
    177       CLocalElement* localElement_ = nullptr ; 
     177      shared_ptr<CLocalElement> localElement_ = nullptr ; 
    178178      void initializeLocalElement(void) ; 
    179179        
    180180    public:   
    181       CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
    182       CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
     181      shared_ptr<CLocalElement> getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; } 
     182      shared_ptr<CLocalView> getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;} 
    183183        
    184184    private:   
    … …  
    188188         
    189189    private: 
    190       CLocalConnector* modelToWorkflowConnector_ ; 
     190      shared_ptr<CLocalConnector> modelToWorkflowConnector_ ; 
    191191      void computeModelToWorkflowConnector(void)  ; 
    192192    public: 
    193       CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
     193      shared_ptr<CLocalConnector> getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;} 
    194194 
    195195    public: 
    196196      void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    197       void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector, 
     197      void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector> &scattererConnector, 
    198198                                 const string& scalarId="") ; 
    199199 
    … …  
    201201      void receivedScalarDistribution(CEventServer& event, int phasis) ; 
    202202      void setServerMask(CArray<bool,1>& serverMask, CContextClient* client) ; 
    203       void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId) ; 
     203      void sendDistributedAttributes(CContextClient* client, shared_ptr<CScattererConnector> scattererConnector, const string& scalarId) ; 
    204204      static void recvDistributedAttributes(CEventServer& event) ; 
    205205      void recvDistributedAttributes(CEventServer& event, const string& type) ; 
    206206 
    207207    private: 
    208       map<CContextClient*, CDistributedElement*> remoteElement_ ; 
    209     public:  
    210       CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
    211     private: 
    212       map<CContextClient*, CScattererConnector*> clientToServerConnector_ ; 
    213     public:  
    214       CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
    215  
    216     private: 
    217       CGathererConnector*  gathererConnector_ ; 
    218     public: 
    219       CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
    220     private: 
    221       CGathererConnector* serverFromClientConnector_ ; 
    222       CDistributedElement* elementFrom_ ; 
    223     public: 
    224       CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
    225  
    226     private: 
    227       CScattererConnector*  serverToClientConnector_ = nullptr ; 
    228     public:  
    229       CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}  
    230  
    231     private: 
    232       map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ; 
    233     public:  
    234       CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}  
     208      map<CContextClient*, shared_ptr<CDistributedElement>> remoteElement_ ; 
     209    public:  
     210      shared_ptr<CDistributedElement> getRemoteElement(CContextClient* client) {return remoteElement_[client] ;} 
     211    private: 
     212      map<CContextClient*, shared_ptr<CScattererConnector>> clientToServerConnector_ ; 
     213    public:  
     214      shared_ptr<CScattererConnector> getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} 
     215 
     216    private: 
     217      shared_ptr<CGathererConnector>  gathererConnector_ ; 
     218    public: 
     219      shared_ptr<CGathererConnector> getGathererConnector(void) { return gathererConnector_ ;} 
     220    private: 
     221      shared_ptr<CGathererConnector> serverFromClientConnector_ ; 
     222      shared_ptr<CDistributedElement> elementFrom_ ; 
     223    public: 
     224      shared_ptr<CGathererConnector> getServerFromClientConnector(void) { return serverFromClientConnector_ ;} 
     225 
     226    private: 
     227     shared_ptr<CScattererConnector>  serverToClientConnector_ = nullptr ; 
     228    public:  
     229      shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  
     230 
     231    private: 
     232      map<CContextClient*,shared_ptr<CGathererConnector>>  clientFromServerConnector_  ; 
     233    public:  
     234      shared_ptr<CGathererConnector> getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}  
    235235 
    236236    private: 
Note: See TracChangeset for help on using the changeset viewer.