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/distribution
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/distributed_view.cpp

    r1936 r2267  
    66{ 
    77 
    8   CDistributedView::CDistributedView(CDistributedElement* parent, CElementView::type, const std::map<int,CArray<int,1>>& indexView)  
     8  CDistributedView::CDistributedView(shared_ptr<CDistributedElement> parent, CElementView::type, const std::map<int,CArray<int,1>>& indexView)  
    99                                    : globalIndex_(parent->globalIndex_), globalSize_(parent->globalSize_), localSize_(parent->localSize_)  
    1010  { 
    … …  
    1616  } 
    1717 
    18   CDistributedView::CDistributedView(CDistributedElement* parent, CElementView::type, const std::map<int,CArray<bool,1>>& maskView)  
     18  CDistributedView::CDistributedView(shared_ptr<CDistributedElement> parent, CElementView::type, const std::map<int,CArray<bool,1>>& maskView)  
    1919                                    : globalIndex_(parent->globalIndex_), globalSize_(parent->globalSize_), localSize_(parent->localSize_)  
    2020  { 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/distributed_view.hpp

    r2180 r2267  
    1414    public: 
    1515 
    16       CDistributedView(CDistributedElement* parent, CElementView::type type, const std::map<int,CArray<int,1>>& indexView) ; 
    17       CDistributedView(CDistributedElement* parent, CElementView::type type, const std::map<int,CArray<bool,1>>& maskView) ; 
     16      CDistributedView(shared_ptr<CDistributedElement> parent, CElementView::type type, const std::map<int,CArray<int,1>>& indexView) ; 
     17      CDistributedView(shared_ptr<CDistributedElement> parent, CElementView::type type, const std::map<int,CArray<bool,1>>& maskView) ; 
    1818       
    1919      std::map<int,CArray<int,1>>&  getIndex(void) { return index_ ;} 
    … …  
    4848    }    
    4949 
    50     void getGlobalIndex(int rank, vector<size_t>& globalIndex, size_t sliceIndex, size_t* sliceSize, CDistributedView** view, int pos) 
     50    void getGlobalIndex(int rank, vector<size_t>& globalIndex, size_t sliceIndex, size_t* sliceSize, shared_ptr<CDistributedView>* view, int pos) 
    5151    { 
    5252      // using map can be expensive, find an otherway later 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/element.cpp

    r1930 r2267  
    2828  void CDistributedElement::addView(CElementView::type type, std::map<int, CArray<int,1>>& indexView) 
    2929  { 
    30     views_[type] = new CDistributedView(this, type, indexView) ; 
     30    views_[type] = make_shared<CDistributedView>(shared_from_this(), type, indexView) ; 
    3131  }  
    3232 
    3333  void CDistributedElement::addView(CElementView::type type, std::map<int, CArray<bool,1>>& maskView) 
    3434  { 
    35     views_[type] = new CDistributedView(this, type, maskView) ; 
     35    views_[type] = make_shared<CDistributedView>(shared_from_this(), type, maskView) ; 
    3636  }  
    3737 
    … …  
    120120  void CLocalElement::addView(CElementView::type type, CArray<int,1>& indexView) 
    121121  { 
    122     views_[type] = new CLocalView(this, type, indexView) ; 
     122    views_[type] = make_shared<CLocalView>(static_pointer_cast<CLocalElement>(shared_from_this()), type, indexView) ; 
    123123  }  
    124124 
    125125  void CLocalElement::addView(CElementView::type type, CArray<bool,1>& maskView) 
    126126  { 
    127     views_[type] = new CLocalView(this, type, maskView) ; 
     127    views_[type] = make_shared<CLocalView>(static_pointer_cast<CLocalElement>(shared_from_this()), type, maskView) ; 
    128128  }  
    129129 
    … …  
    137137  }  
    138138 
    139   CLocalConnector* CLocalElement::getConnector(CElementView::type srcType, CElementView::type dstType)  
     139  shared_ptr<CLocalView> CLocalElement::getView(CElementView::type type)  
     140  {  
     141    if (views_[(size_t)type]==nullptr) { ERROR("CLocalElement::getView(CElementView::type type)",<<"View is not initialized");}  
     142    else return static_pointer_cast<CLocalView>(views_[(size_t)type]) ; 
     143  } 
     144 
     145  shared_ptr<CLocalConnector> CLocalElement::getConnector(CElementView::type srcType, CElementView::type dstType)  
    140146  {  
    141147    auto newPair = pair<CElementView::type,CElementView::type>(srcType,dstType); 
    … …  
    143149    if (it==connectors_.end())  
    144150    { 
    145       auto insertPair=pair<pair<CElementView::type,CElementView::type>, CLocalConnector*>(newPair,new CLocalConnector(getView(srcType),getView(dstType))) ; 
     151      auto insertPair=pair<pair<CElementView::type,CElementView::type>, shared_ptr<CLocalConnector>>(newPair,make_shared<CLocalConnector>(getView(srcType),getView(dstType))) ; 
    146152      it=connectors_.insert(insertPair).first ; 
    147153      it->second->computeConnector() ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/element.hpp

    r1999 r2267  
    1515  class CLocalConnector ; 
    1616 
    17   class CDistributedElement 
     17  class CDistributedElement : public std::enable_shared_from_this<CDistributedElement> 
    1818  { 
    1919 
    … …  
    2222    std::map<int, int> localSize_ ; 
    2323    size_t globalSize_ ; 
    24     std::vector<CDistributedView*> views_= std::vector<CDistributedView*>(CElementView::numViewType_) ; 
     24    std::vector<shared_ptr<CDistributedView>> views_= std::vector<shared_ptr<CDistributedView>>(CElementView::numViewType_) ; 
    2525    CDistributedElement(void) {} ; 
    2626     
    … …  
    3434    std::map<int, CArray<size_t,1>>& getGlobalIndex(void) { return globalIndex_;} 
    3535     
    36     CDistributedView* getView(CElementView::type type)  
     36    shared_ptr<CDistributedView> getView(CElementView::type type)  
    3737    {  
    3838      if (views_[(size_t)type]==nullptr) { ERROR("CDistributedElement::getView(CElementView::type type)",<<"View is not initialized");}  
    … …  
    5151  { 
    5252    // keep local connector inside     
    53       std::map<pair<CElementView::type,CElementView::type>, CLocalConnector*> connectors_  ; 
     53      std::map<pair<CElementView::type,CElementView::type>, shared_ptr<CLocalConnector>> connectors_  ; 
    5454  
    5555    public:  
    … …  
    6161      void addView(CElementView::type type, CArray<bool,1>& maskView) ; 
    6262      void addFullView(void) ; 
    63       CLocalView* getView(CElementView::type type)  
    64       {  
     63       
     64      shared_ptr<CLocalView> getView(CElementView::type type) ; 
     65 /*     {  
    6566        if (views_[(size_t)type]==nullptr) { ERROR("CLocalElement::getView(CElementView::type type)",<<"View is not initialized");}  
    66         else return (CLocalView*) views_[(size_t)type] ;  
     67        else return static_pointer_cast<CLocalView>(views_[(size_t)type]) ; 
    6768      } 
    68        
    69       CLocalConnector* getConnector(CElementView::type srcType, CElementView::type dstType) ; 
     69*/       
     70      shared_ptr<CLocalConnector> getConnector(CElementView::type srcType, CElementView::type dstType) ; 
    7071 
    7172    private : 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/gatherer_connector.hpp

    r2118 r2267  
    1717  { 
    1818    private: 
    19       CDistributedView* srcView_; 
    20       CLocalView* dstView_; 
     19      shared_ptr<CDistributedView> srcView_; 
     20      shared_ptr<CLocalView> dstView_; 
    2121      map<int, vector<int>> connector_ ; 
    2222      map<int, vector<bool>> mask_ ;  // mask is on src view 
    … …  
    2525 
    2626    public: 
    27       CGathererConnector(CDistributedView* srcView, CLocalView* dstView) : srcView_(srcView), dstView_(dstView) {} ; 
     27      CGathererConnector(shared_ptr<CDistributedView> srcView, shared_ptr<CLocalView> dstView) : srcView_(srcView), dstView_(dstView) {} ; 
    2828      void computeConnector(void) ; 
    2929       
    … …  
    7575 
    7676      template<typename T> 
    77       void transfer(int rank,  CGathererConnector** connectors, int nConnectors, const T* input, T* output) 
     77      void transfer(int rank,  shared_ptr<CGathererConnector>* connectors, int nConnectors, const T* input, T* output) 
    7878      { 
    7979        auto& connector = connector_[rank] ; // probably costly, find a better way to avoid the map 
    … …  
    111111 
    112112      // hook for transfering mask in grid connector, maybe find an other way to doing that... 
    113       void transfer_or(int rank,  CGathererConnector** connectors, int nConnectors, const bool* input, bool* output) 
     113      void transfer_or(int rank,  shared_ptr<CGathererConnector>* connectors, int nConnectors, const bool* input, bool* output) 
    114114      { 
    115115        auto& connector = connector_[rank] ; // probably costly, find a better way to avoid the map 
    … …  
    210210      } 
    211211 
    212     int getSrcSliceSize(int rank, CGathererConnector** connectors, int nConnectors)  
     212    int getSrcSliceSize(int rank, shared_ptr<CGathererConnector>* connectors, int nConnectors)  
    213213    { if (nConnectors==0) return srcSize_[rank] ; else return srcSize_[rank] * (*(connectors-1))->getSrcSliceSize(rank, connectors-1,nConnectors-1) ; } 
    214214 
    215     int getDstSliceSize(CGathererConnector** connectors, int nConnectors)  
     215    int getDstSliceSize(shared_ptr<CGathererConnector>* connectors, int nConnectors)  
    216216    { if (nConnectors==0) return dstSize_ ; else return dstSize_ * (*(connectors-1))->getDstSliceSize(connectors-1,nConnectors-1) ; } 
    217217   

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_client_server_remote_connector.cpp

    r2236 r2267  
    1010   * \param remoteSize Size of the remote communicator 
    1111   */  
    12   CGridClientServerRemoteConnector::CGridClientServerRemoteConnector(vector<CLocalView*>& srcFullView, vector<CLocalView*>& srcWorkflowView, vector<CDistributedView*>& dstView, MPI_Comm localComm, int remoteSize)  
     12  CGridClientServerRemoteConnector::CGridClientServerRemoteConnector( vector<shared_ptr<CLocalView> >& srcFullView, vector<shared_ptr<CLocalView>>& srcWorkflowView,  
     13                                                                      vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize)  
    1314                       : CGridRemoteConnector(srcFullView, dstView, localComm, remoteSize) , srcWorkflowView_(srcWorkflowView) 
    1415  {} 
    … …  
    1718  void CGridClientServerRemoteConnector::computeConnector(void) 
    1819  { 
    19     CGridRemoteConnector workflowRemoteConnector(srcWorkflowView_,dstView_,localComm_,remoteSize_) ; 
    20     workflowRemoteConnector.computeConnector() ; 
     20    auto workflowRemoteConnector=make_shared<CGridRemoteConnector>(srcWorkflowView_,dstView_,localComm_,remoteSize_) ; 
     21    workflowRemoteConnector->computeConnector() ; 
    2122    computeViewDistribution() ; 
    2223     
    23     for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowRemoteConnector.getIsSrcViewDistributed()[i]  ; 
     24    for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowRemoteConnector->getIsSrcViewDistributed()[i]  ; 
    2425    computeConnectorMethods() ; 
    2526    computeRedondantRanks() ; 
    2627 
    2728    for(auto& rank : rankToRemove_) 
    28       if (workflowRemoteConnector.getRankToRemove().count(rank)!=0) 
     29      if (workflowRemoteConnector->getRankToRemove().count(rank)!=0) 
    2930        for(auto& element : elements_) element.erase(rank) ; 
    3031  } 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_client_server_remote_connector.hpp

    r2236 r2267  
    1212    public: 
    1313 
    14       CGridClientServerRemoteConnector(vector<CLocalView*>& srcView, vector<CLocalView*>& worflowSrcView, vector<CDistributedView*>& dstView, MPI_Comm localComm, int remoteSize) ; 
     14      CGridClientServerRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CLocalView>>& worflowSrcView, vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize) ; 
    1515      void computeConnector(void) ; 
    16       vector<CLocalView*> srcWorkflowView_ ;    
     16      vector<shared_ptr<CLocalView>> srcWorkflowView_ ;    
    1717  } ; 
    1818 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_elements.cpp

    r1960 r2267  
    66{ 
    77 
    8   CGridLocalView* CGridLocalElements::getView(CElementView::type type) 
     8  shared_ptr<CGridLocalView> CGridLocalElements::getView(CElementView::type type) 
    99  {  
    10     if (views_[type]==nullptr) views_[type] = new CGridLocalView(this, type) ; 
     10    if (views_[type]==nullptr) views_[type] = make_shared<CGridLocalView>(shared_from_this(), type) ; 
    1111    return views_[type] ; 
    1212  } 
    1313   
    14   CGridLocalConnector* CGridLocalElements::getConnector(CElementView::type srcType, CElementView::type dstType, bool withMask) 
     14  shared_ptr<CGridLocalConnector> CGridLocalElements::getConnector(CElementView::type srcType, CElementView::type dstType, bool withMask) 
    1515  { 
    1616    auto newPair = pair<CElementView::type,CElementView::type>(srcType,dstType); 
    … …  
    1818    if (it==connectors_.end())  
    1919    { 
    20       auto insertPair=pair<pair<CElementView::type,CElementView::type>, CGridLocalConnector*>(newPair,new CGridLocalConnector(this, srcType, dstType, withMask)) ; 
     20      auto insertPair=pair<pair<CElementView::type,CElementView::type>, shared_ptr<CGridLocalConnector>>(newPair, make_shared<CGridLocalConnector>(shared_from_this(), srcType, dstType, withMask)) ; 
    2121      it=connectors_.insert(insertPair).first ; 
    2222    } 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_elements.hpp

    r1960 r2267  
    1111  class CGridLocalConnector ; 
    1212 
    13   class CGridLocalElements   
     13  class CGridLocalElements : public std::enable_shared_from_this<CGridLocalElements> 
    1414  { 
    1515    private: 
    16       std::vector<CLocalElement*> elements_ ; 
    17       std::vector<CGridLocalView*> views_= std::vector<CGridLocalView*>(CElementView::numViewType_) ; 
    18       std::map<pair<CElementView::type,CElementView::type>, CGridLocalConnector*> connectors_ ; 
     16      std::vector<shared_ptr<CLocalElement>> elements_ ; 
     17      std::vector<shared_ptr<CGridLocalView>> views_= std::vector<shared_ptr<CGridLocalView>>(CElementView::numViewType_) ; 
     18      std::map<pair<CElementView::type,CElementView::type>, shared_ptr<CGridLocalConnector>> connectors_ ; 
    1919      vector<bool> localMask_ ; 
    2020   
    2121    public: 
    22       CGridLocalElements(vector<CLocalElement*> elements) : elements_(elements) {} 
    23       CGridLocalElements(vector<CLocalElement*> elements, vector<bool>& localMask) : elements_(elements), localMask_(localMask) {} 
     22      CGridLocalElements(vector<shared_ptr<CLocalElement> > elements) : elements_(elements) {} 
     23      CGridLocalElements(vector<shared_ptr<CLocalElement>> elements, vector<bool>& localMask) : elements_(elements), localMask_(localMask) {} 
    2424 
    2525      bool hasLocalMask() { return !localMask_.empty() ;} 
    2626      vector<bool>& getLocalMask(void) { return localMask_ ;} 
    2727 
    28       std::vector<CLocalElement*>& getElements(void) { return elements_ ; } 
    29       CGridLocalView* getView(CElementView::type type) ; 
    30       CGridLocalConnector* getConnector(CElementView::type srcType, CElementView::type dstType, bool withMask=false) ; 
     28      std::vector<shared_ptr<CLocalElement>>& getElements(void) { return elements_ ; } 
     29      shared_ptr<CGridLocalView> getView(CElementView::type type) ; 
     30      shared_ptr<CGridLocalConnector> getConnector(CElementView::type srcType, CElementView::type dstType, bool withMask=false) ; 
    3131  } ; 
    3232} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_gatherer_connector.hpp

    r2011 r2267  
    1919    private: 
    2020     
    21       vector<CGathererConnector*> elementsConnector_ ; 
     21      vector<shared_ptr<CGathererConnector>> elementsConnector_ ; 
    2222      int dstSize_ ; 
    2323 
    2424    public: 
    25       CGridGathererConnector(vector<CGathererConnector*> elementsConnector) : elementsConnector_(elementsConnector) 
     25      CGridGathererConnector(vector<shared_ptr<CGathererConnector>> elementsConnector) : elementsConnector_(elementsConnector) 
    2626      { 
    2727        dstSize_ = 1 ; 
    … …  
    3333      { 
    3434        int n = elementsConnector_.size()-1 ; 
    35         CGathererConnector** connector = elementsConnector_.data() + n ; 
     35       shared_ptr<CGathererConnector>* connector = elementsConnector_.data() + n ; 
    3636        output.resize(dstSize_) ; 
    3737        for(auto& rankDataIn : input)  
    … …  
    4545      { 
    4646        int n = elementsConnector_.size()-1 ; 
    47         CGathererConnector** connector = elementsConnector_.data() + n ; 
     47        shared_ptr<CGathererConnector>* connector = elementsConnector_.data() + n ; 
    4848        output.resize(dstSize_) ; 
    4949        output = missingValue ; 
    … …  
    9393      { 
    9494        int n = elementsConnector_.size()-1 ; 
    95         CGathererConnector** connector = elementsConnector_.data() + n ; 
     95        shared_ptr<CGathererConnector>* connector = elementsConnector_.data() + n ; 
    9696        output.resize(dstSize_) ; 
    9797        output = false ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_local_connector.cpp

    r1960 r2267  
    88{ 
    99  
    10   CGridLocalConnector::CGridLocalConnector(const std::vector<CLocalConnector*>& elementsConnector) : elementsConnector_(elementsConnector) 
     10  CGridLocalConnector::CGridLocalConnector(const std::vector<shared_ptr<CLocalConnector>>& elementsConnector) : elementsConnector_(elementsConnector) 
    1111  { 
    1212    srcSize_=1 ; 
    … …  
    1616  }  
    1717 
    18   CGridLocalConnector::CGridLocalConnector(CGridLocalElements* parent, CElementView::type srcType, CElementView::type dstType, bool withMask) 
     18  CGridLocalConnector::CGridLocalConnector(shared_ptr<CGridLocalElements> parent, CElementView::type srcType, CElementView::type dstType, bool withMask) 
    1919  { 
    20     CGridLocalView* srcView=parent->getView(srcType) ; 
    21     CGridLocalView* dstView=parent->getView(dstType) ; 
     20    shared_ptr<CGridLocalView> srcView=parent->getView(srcType) ; 
     21    shared_ptr<CGridLocalView> dstView=parent->getView(dstType) ; 
    2222 
    23     vector<CLocalView*> srcViews = srcView->getViews() ;  
    24     vector<CLocalView*> dstViews = dstView->getViews() ; 
     23    vector<shared_ptr<CLocalView>> srcViews = srcView->getViews() ;  
     24    vector<shared_ptr<CLocalView>> dstViews = dstView->getViews() ; 
    2525     
    26     vector<CLocalElement*>& elements = parent->getElements(); 
     26    vector<shared_ptr<CLocalElement>>& elements = parent->getElements(); 
    2727    for(auto element : elements) elementsConnector_.push_back(element->getConnector(srcType, dstType)) ; 
    2828    srcSize_=1 ; 
    … …  
    3333    if (parent->hasLocalMask() && withMask) 
    3434    { 
    35       vector<CLocalConnector*> elementsConnector ; 
     35      vector<shared_ptr<CLocalConnector>> elementsConnector ; 
    3636      for(auto element : elements) elementsConnector.push_back(element->getConnector(CElementView::FULL, dstType)) ; 
    37       CGridLocalConnector localToDst(elementsConnector) ; 
    38       CArray<bool,1> maskIn(localToDst.getSrcSize()) ; 
    39       CArray<bool,1> maskOut1(localToDst.getDstSize()) ; 
    40       CArray<bool,1> maskOut2(localToDst.getDstSize()) ; 
     37      auto localToDst=make_shared<CGridLocalConnector>(elementsConnector) ; 
     38      CArray<bool,1> maskIn(localToDst->getSrcSize()) ; 
     39      CArray<bool,1> maskOut1(localToDst->getDstSize()) ; 
     40      CArray<bool,1> maskOut2(localToDst->getDstSize()) ; 
    4141      maskIn=true ; 
    42       localToDst.transfer(maskIn,maskOut1,false) ; 
     42      localToDst->transfer(maskIn,maskOut1,false) ; 
    4343      auto& localMask = parent->getLocalMask() ; 
    4444      for(int i=0 ; i < maskIn.numElements() ; i++) maskIn(i)=localMask[i] ; 
    45       localToDst.transfer(maskIn,maskOut2,false) ; 
     45      localToDst->transfer(maskIn,maskOut2,false) ; 
    4646      mask_.assign(dstSize_,true) ; 
    4747      for(int i=0;i<dstSize_;i++) if (maskOut1(i)==true && maskOut2(i)==false) mask_[i]=false ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_local_connector.hpp

    r1960 r2267  
    1717 
    1818    private:   
    19       std::vector<CLocalConnector*> elementsConnector_ ; 
     19      std::vector<shared_ptr<CLocalConnector>> elementsConnector_ ; 
    2020      int srcSize_ ; 
    2121      int dstSize_ ; 
    … …  
    2424    public: 
    2525       
    26       CGridLocalConnector(const std::vector<CLocalConnector*>& elementsConnector)  ; 
    27       CGridLocalConnector(CGridLocalElements* parent, CElementView::type srcType, CElementView::type dstType, bool withMask=false) ; 
     26      CGridLocalConnector(const std::vector<shared_ptr<CLocalConnector>>& elementsConnector)  ; 
     27      CGridLocalConnector(shared_ptr<CGridLocalElements> parent, CElementView::type srcType, CElementView::type dstType, bool withMask=false) ; 
    2828      int getSrcSize(void) { return srcSize_ ;} 
    2929      int getDstSize(void) { return dstSize_ ;} 
    … …  
    3737      { 
    3838        int n = elementsConnector_.size()-1 ; 
    39         CLocalConnector** connector = elementsConnector_.data() + n ; 
     39        shared_ptr<CLocalConnector>* connector = elementsConnector_.data() + n ; 
    4040        elementsConnector_[n]->transfer(connector, n, input.dataFirst(), output.dataFirst()) ; 
    4141      } 
    … …  
    4545      { 
    4646        int n = elementsConnector_.size()-1 ; 
    47         CLocalConnector** connector = elementsConnector_.data() + n ; 
     47        shared_ptr<CLocalConnector>* connector = elementsConnector_.data() + n ; 
    4848        elementsConnector_[n]->transfer(connector, n, input.dataFirst(), output.dataFirst(), missingValue) ; 
    4949        if (!computeMask_done_) computeMask() ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_local_view.cpp

    r1930 r2267  
    44namespace xios 
    55{ 
    6   CGridLocalView::CGridLocalView(CGridLocalElements* parent, CElementView::type type) : localMask_(parent->getLocalMask()) 
     6  CGridLocalView::CGridLocalView(shared_ptr<CGridLocalElements> parent, CElementView::type type) : localMask_(parent->getLocalMask()) 
    77  { 
    88    size_ = 1 ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_local_view.hpp

    r1999 r2267  
    1212  { 
    1313    private: 
    14       std::vector<CLocalView*> views_ ; 
     14      std::vector<shared_ptr<CLocalView>> views_ ; 
    1515      std::vector<bool>& localMask_ ; 
    1616      int size_ ; 
    1717     
    1818    public: 
    19       CGridLocalView(CGridLocalElements* parent, CElementView::type type) ; 
    20       std::vector<CLocalView*>& getViews(void) {return views_ ;} 
    21       CLocalView* getView(int i) {return views_[i] ;} 
     19      CGridLocalView(shared_ptr<CGridLocalElements> parent, CElementView::type type) ; 
     20      std::vector<shared_ptr<CLocalView>>& getViews(void) {return views_ ;} 
     21      shared_ptr<CLocalView> getView(int i) {return views_[i] ;} 
    2222      int getSize() { return size_ ;} 
    2323  } ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_mask_connector.hpp

    r1955 r2267  
    1515    public: 
    1616 
    17       CGridMaskConnector(vector<CLocalView*>& views) : views_(views) {} 
     17      CGridMaskConnector(vector<shared_ptr<CLocalView>>& views) : views_(views) {} 
    1818      void computeConnector(CArray<bool,1>& mask) ; 
    1919      
    … …  
    2222     
    2323    private: 
    24       vector<CLocalView*> views_ ; 
     24      vector<shared_ptr<CLocalView>> views_ ; 
    2525      vector<CArray<bool,1>> elementsMask_ ;  
    2626 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_remote_connector.cpp

    r2236 r2267  
    1515   * \param remoteSize Size of the remote communicator 
    1616   */  
    17   CGridRemoteConnector::CGridRemoteConnector(vector<CLocalView*>& srcView, vector<CDistributedView*>& dstView, MPI_Comm localComm, int remoteSize)  
     17  CGridRemoteConnector::CGridRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize)  
    1818                       : srcView_(srcView), dstView_(dstView), localComm_(localComm), remoteSize_(remoteSize)  
    1919  {} 
    … …  
    2626   * \param remoteSize Size of the remote communicator 
    2727   */  
    28   CGridRemoteConnector::CGridRemoteConnector(vector<CLocalView*>& srcView, vector<CLocalView*>& dstView, MPI_Comm localComm, int remoteSize)  
     28  CGridRemoteConnector::CGridRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector< shared_ptr<CLocalView> >& dstView, MPI_Comm localComm, int remoteSize)  
    2929                       : srcView_(srcView), localComm_(localComm), remoteSize_(remoteSize)  
    3030  { 
    31     for(auto& it : dstView) dstView_.push_back((CDistributedView*) it) ;  
     31    for(auto& it : dstView) dstView_.push_back((shared_ptr<CDistributedView>) it) ;  
    3232  } 
    3333 
    … …  
    135135  void CGridRemoteConnector::computeConnectorMethods(void) 
    136136  { 
    137     vector<CLocalView*> srcView ; 
    138     vector<CDistributedView*> dstView ; 
     137    vector<shared_ptr<CLocalView>> srcView ; 
     138    vector<shared_ptr<CDistributedView>> dstView ; 
    139139    vector<int> indElements ; 
    140140    elements_.resize(srcView_.size()) ; 
    … …  
    435435  *  \param indElements Index of the view making the correspondance between all views and views distributed (that are in input) 
    436436  */ 
    437   void CGridRemoteConnector::computeGenericMethod(vector<CLocalView*>& srcView, vector<CDistributedView*>& dstView, vector<int>& indElements) 
     437  void CGridRemoteConnector::computeGenericMethod(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CDistributedView>>& dstView, vector<int>& indElements) 
    438438  { 
    439439    // generic method, every element can be distributed 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_remote_connector.hpp

    r2236 r2267  
    1818    public: 
    1919 
    20       CGridRemoteConnector(vector<CLocalView*>& srcView, vector<CDistributedView*>& dstView, MPI_Comm localComm, int remoteSize) ; 
    21       CGridRemoteConnector(vector<CLocalView*>& srcView, vector<CLocalView*>& dstView, MPI_Comm localComm, int remoteSize) ; 
     20      CGridRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize) ; 
     21      CGridRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CLocalView>>& dstView, MPI_Comm localComm, int remoteSize) ; 
    2222      void computeViewDistribution(void) ; 
    2323      void computeConnector(void) ; 
    2424      void computeConnectorMethods(void) ; 
    25       void computeGenericMethod(vector<CLocalView*>& srcView, vector<CDistributedView*>& dstView, vector<int>& indElements) ; 
     25      void computeGenericMethod(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CDistributedView>>& dstView, vector<int>& indElements) ; 
    2626      void computeSrcDstNonDistributed(int i, map<int,bool>& ranks) ; 
    2727      void computeDstNonDistributed(int i, map<int,bool>& ranks) ; 
    … …  
    3939     * It is feed at construction time 
    4040     */ 
    41       vector<CLocalView*> srcView_ ; 
     41      vector<shared_ptr<CLocalView>> srcView_ ; 
    4242 
    4343    /**  
    … …  
    4545     * It is feed at construction time 
    4646     */ 
    47       vector<CDistributedView*> dstView_ ; 
     47      vector<shared_ptr<CDistributedView>> dstView_ ; 
    4848 
    4949    /**   

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_scatterer_connector.hpp

    r2130 r2267  
    1818  { 
    1919    private: 
    20      vector<CScattererConnector*> elementsConnector_ ; 
     20     vector<shared_ptr<CScattererConnector>> elementsConnector_ ; 
    2121     map<int,int> nbSenders_ ; 
    2222     vector<int> ranks_ ; 
    … …  
    2525 
    2626    public: 
    27       CGridScattererConnector(vector<CScattererConnector*> elementsConnector) : elementsConnector_(elementsConnector)  
     27      CGridScattererConnector(vector<shared_ptr<CScattererConnector>> elementsConnector) : elementsConnector_(elementsConnector)  
    2828      { 
    2929        nbSenders_ = elementsConnector[0]->getNbSenders() ; 
    … …  
    4848      { 
    4949        int n = elementsConnector_.size()-1 ; 
    50         CScattererConnector** connector = elementsConnector_.data() + n ; 
     50        shared_ptr<CScattererConnector>* connector = elementsConnector_.data() + n ; 
    5151        for(int rank : ranks_)  
    5252        { 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_transform_connector.cpp

    r2189 r2267  
    1616    int nElements = srcViews_.size() ; 
    1717 
    18     CGridRemoteConnector remoteConnector(srcViews_, remoteViews_, localComm_, commSize) ;   
    19     remoteConnector.computeConnector() ; 
     18    auto remoteConnector = make_shared<CGridRemoteConnector>(srcViews_, remoteViews_, localComm_, commSize) ;   
     19    remoteConnector->computeConnector() ; 
    2020     
    21     vector<CDistributedElement*> sendElements(nElements) ; 
     21    vector<shared_ptr<CDistributedElement>> sendElements(nElements) ; 
    2222    scattererConnector_.resize(nElements) ; 
    2323    gathererConnector_.resize(nElements) ; 
    … …  
    2525    for(int i=0;i<nElements;i++) 
    2626    { 
    27       sendElements[i] = new CDistributedElement(srcViews_[i]->getGlobalSize(), remoteConnector.getDistributedGlobalIndex(i)) ; 
     27      sendElements[i] = make_shared<CDistributedElement>(srcViews_[i]->getGlobalSize(), remoteConnector->getDistributedGlobalIndex(i)) ; 
    2828      sendElements[i]->addFullView() ; 
    29       scattererConnector_[i] = new CScattererConnector(srcViews_[i], sendElements[i]->getView(CElementView::FULL), localComm_, commSize) ; 
     29      scattererConnector_[i] = make_shared<CScattererConnector>(srcViews_[i], sendElements[i]->getView(CElementView::FULL), localComm_, commSize) ; 
    3030      scattererConnector_[i]->computeConnector() ; 
    3131      std::map<int, CArray<size_t,1>>& sendIndex = sendElements[i]->getGlobalIndex() ; 
    … …  
    7575      // create gatherer connector 
    7676 
    77       CDistributedElement recvElement(remoteViews_[i]->getGlobalSize(), recvIndex) ; 
    78       recvElement.addFullView() ; 
    79       gathererConnector_[i] = new CGathererConnector(recvElement.getView(CElementView::FULL), remoteViews_[i]) ; 
     77      auto recvElement = make_shared<CDistributedElement>(remoteViews_[i]->getGlobalSize(), recvIndex) ; 
     78      recvElement->addFullView() ; 
     79      gathererConnector_[i] = make_shared<CGathererConnector>(recvElement->getView(CElementView::FULL), remoteViews_[i]) ; 
    8080      gathererConnector_[i]->computeConnector() ; 
    8181    } 
    8282 
    83     gridScattererConnector_ = new CGridScattererConnector(scattererConnector_) ; 
    84     gridGathererConnector_  = new CGridGathererConnector(gathererConnector_) ; 
     83    gridScattererConnector_ = make_shared<CGridScattererConnector>(scattererConnector_) ; 
     84    gridGathererConnector_  = make_shared<CGridGathererConnector>(gathererConnector_) ; 
    8585  } 
    8686 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/grid_transform_connector.hpp

    r1999 r2267  
    1818      
    1919    public: 
    20       CGridTransformConnector(vector<CLocalView*> srcViews, vector<CLocalView*> remoteViews, MPI_Comm localComm)  
     20      CGridTransformConnector(vector<shared_ptr<CLocalView>> srcViews, vector<shared_ptr<CLocalView>> remoteViews, MPI_Comm localComm)  
    2121                          : srcViews_(srcViews), remoteViews_(remoteViews), localComm_(localComm)  
    2222                          { computeConnector();} 
    … …  
    2525    protected: 
    2626     MPI_Comm localComm_ ; 
    27      vector<CLocalView*> srcViews_ ; 
    28      vector<CLocalView*> remoteViews_ ; 
     27     vector<shared_ptr<CLocalView>> srcViews_ ; 
     28     vector<shared_ptr<CLocalView>> remoteViews_ ; 
    2929     map<int,int> recvRankSize_ ; 
    3030 
    31      vector<CScattererConnector*> scattererConnector_ ; 
    32      vector<CGathererConnector*>  gathererConnector_ ; 
    33      CGridScattererConnector* gridScattererConnector_ ; 
    34      CGridGathererConnector* gridGathererConnector_ ; 
     31     vector<shared_ptr<CScattererConnector>> scattererConnector_ ; 
     32     vector<shared_ptr<CGathererConnector>>  gathererConnector_ ; 
     33     shared_ptr<CGridScattererConnector> gridScattererConnector_ ; 
     34     shared_ptr<CGridGathererConnector> gridGathererConnector_ ; 
    3535   
    3636    public: 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/local_connector.hpp

    r1918 r2267  
    1515     
    1616    private: 
    17       CLocalView* srcView_; 
    18       CLocalView* dstView_; 
     17      shared_ptr<CLocalView> srcView_; 
     18      shared_ptr<CLocalView> dstView_; 
    1919      int srcSize_ ; 
    2020      int dstSize_ ; 
    … …  
    2424    public: 
    2525     
    26       CLocalConnector(CLocalView* srcView, CLocalView* dstView) : srcView_(srcView), dstView_(dstView),  
     26      CLocalConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView) : srcView_(srcView), dstView_(dstView),  
    2727                                                                  srcSize_(srcView->getSize()), dstSize_(dstView->getSize()) {} 
    2828      void computeConnector(void); 
    … …  
    5959      } 
    6060 
    61       template<typename T> void transfer(CLocalConnector** connectors, int nConnectors, const T* input, T* output) 
     61      template<typename T> void transfer(shared_ptr<CLocalConnector>* connectors, int nConnectors, const T* input, T* output) 
    6262      { 
    6363 
    … …  
    9191      } 
    9292 
    93       template<typename T> void transfer(CLocalConnector** connectors, int nConnectors, const T* input, T* output, T missingValue) 
     93      template<typename T> void transfer(shared_ptr<CLocalConnector>* connectors, int nConnectors, const T* input, T* output, T missingValue) 
    9494      { 
    9595        int size=mask_.size() ; 
    … …  
    123123      } 
    124124 
    125       int getSrcSliceSize(CLocalConnector** connectors, int nConnectors)  
     125      int getSrcSliceSize(shared_ptr<CLocalConnector>* connectors, int nConnectors)  
    126126      { if (nConnectors==0) return srcSize_ ; else return srcSize_ * (*(connectors-1))->getSrcSliceSize(connectors-1,nConnectors-1) ; } 
    127127 
    128       int getDstSliceSize(CLocalConnector** connectors, int nConnectors)  
     128      int getDstSliceSize(shared_ptr<CLocalConnector>* connectors, int nConnectors)  
    129129      { if (nConnectors==0) return dstSize_ ; else return dstSize_ * (*(connectors-1))->getDstSliceSize(connectors-1,nConnectors-1) ; } 
    130130 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/local_view.cpp

    r1930 r2267  
    66namespace xios 
    77{ 
    8   CLocalView::CLocalView(CLocalElement* parent, CElementView::type type, const CArray<int,1>& indexView)  
     8  CLocalView::CLocalView(shared_ptr<CLocalElement> parent, CElementView::type type, const CArray<int,1>& indexView)  
    99                        : CDistributedView( parent, type, {{  parent->localRank_,  indexView }} ), 
    1010                          localRank_(parent->localRank_), 
    … …  
    1515  } 
    1616 
    17   CLocalView::CLocalView(CLocalElement* parent, CElementView::type type, const CArray<bool,1>& maskView)  
     17  CLocalView::CLocalView(shared_ptr<CLocalElement> parent, CElementView::type type, const CArray<bool,1>& maskView)  
    1818                        : CDistributedView( parent, type, {{  parent->localRank_,  maskView }} ), 
    1919                          localRank_(parent->localRank_), 
    … …  
    2424  } 
    2525 
    26   void CLocalView::sendRemoteElement(CRemoteConnector& connector, CContextClient* client, CEventClient& event, const CMessage& messageHeader) 
     26  void CLocalView::sendRemoteElement(shared_ptr<CRemoteConnector> connector, CContextClient* client, CEventClient& event, const CMessage& messageHeader) 
    2727  { 
    2828    int n = index_.numElements() ; 
    … …  
    3636    CMessage message(messageHeader) ; 
    3737    message<<globalSize_ ; 
    38     connector.transferToServer(ind, client, event, message) ; 
     38    connector->transferToServer(ind, client, event, message) ; 
    3939  } 
    4040 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/local_view.hpp

    r1954 r2267  
    1616  { 
    1717    public: 
    18     CLocalView(CLocalElement* parent, CElementView::type type, const CArray<int,1>& indexView) ; 
    19     CLocalView(CLocalElement* parent, CElementView::type type, const CArray<bool,1>& maskView) ; 
     18    CLocalView(shared_ptr<CLocalElement> parent, CElementView::type type, const CArray<int,1>& indexView) ; 
     19    CLocalView(shared_ptr<CLocalElement> parent, CElementView::type type, const CArray<bool,1>& maskView) ; 
    2020 
    2121    const CArray<int,1>& getIndex(void) { return index_ ;} 
    … …  
    3838    }     
    3939 
    40     void getGlobalIndex(vector<size_t>& globalIndex, size_t sliceIndex, size_t* sliceSize, CLocalView** localView, int pos) 
     40    void getGlobalIndex(vector<size_t>& globalIndex, size_t sliceIndex, size_t* sliceSize, shared_ptr<CLocalView>* localView, int pos) 
    4141    { 
    4242      if (pos==0) 
    … …  
    5656    int getLocalSize(void) {return localSize_ ;} 
    5757    int getSize(void) {return size_;}  
    58     void sendRemoteElement(CRemoteConnector& connector, CContextClient* client, CEventClient& event, const CMessage& messageHeader) ; 
     58    void sendRemoteElement(shared_ptr<CRemoteConnector> connector, CContextClient* client, CEventClient& event, const CMessage& messageHeader) ; 
    5959    
    6060    CArray<size_t,1>& globalIndex_ ; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/reduce_transform_connector.cpp

    r2000 r2267  
    55{ 
    66 
    7   CReduceTransformConnector::CReduceTransformConnector(CLocalView* srcView, CLocalView* dstView, EReduction op,  
     7  CReduceTransformConnector::CReduceTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, EReduction op,  
    88                                                       unordered_map<int, std::vector<int>>& indexMap, bool detectMissingValue) 
    99   : srcView_(srcView), dstView_(dstView), detectMissingValue_(detectMissingValue) 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/reduce_transform_connector.hpp

    r2188 r2267  
    1717     
    1818    private: 
    19       CLocalView* srcView_; 
    20       CLocalView* dstView_; 
     19      shared_ptr<CLocalView> srcView_; 
     20      shared_ptr<CLocalView> dstView_; 
    2121 
    2222      vector<int> connector_;  //  sizeof sum(nWeights_)   
    … …  
    3434    public: 
    3535 
    36     CReduceTransformConnector(CLocalView* srcView, CLocalView* dstView, EReduction op, unordered_map<int, std::vector<int>>& indexMap,  
     36    CReduceTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, EReduction op, unordered_map<int, std::vector<int>>& indexMap,  
    3737                              bool detectMissingValue=true) ; 
    3838  

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/remote_connector.hpp

    r1918 r2267  
    1717  { 
    1818    private: 
    19       CLocalView* srcView_; 
    20       CDistributedView* dstView_; 
     19      shared_ptr<CLocalView> srcView_; 
     20      shared_ptr<CDistributedView> dstView_; 
    2121      map<int, vector<int>> connector_ ; // connector[rank][srcIndex] 
    2222 
    … …  
    2626     
    2727    public: 
    28       CRemoteConnector(CLocalView* srcView, CDistributedView* dstView, MPI_Comm localComm) : srcView_(srcView), dstView_(dstView), localComm_(localComm){} ; 
     28      CRemoteConnector(shared_ptr<CLocalView> srcView, shared_ptr<CDistributedView> dstView, MPI_Comm localComm) : srcView_(srcView), dstView_(dstView), localComm_(localComm){} ; 
    2929      void computeConnector(void) ; 
    3030      map<int, CArray<size_t,1>>& getDistributedGlobalIndex() { return element_ ;}  

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/scatterer_connector.hpp

    r2118 r2267  
    2323      int remoteCommSize_ ; 
    2424 
    25       CLocalView* srcView_ ; 
    26       CDistributedView* dstView_ ; 
     25      shared_ptr<CLocalView> srcView_ ; 
     26      shared_ptr<CDistributedView> dstView_ ; 
    2727      map<int,int> nbSenders_ ; // number of participant when sending remote buffer 
    2828      int srcSize_ ; 
    … …  
    3131    public: 
    3232 
    33     CScattererConnector(CLocalView* srcView, CDistributedView* dstView, MPI_Comm localComm, int remoteCommSize)  
     33    CScattererConnector(shared_ptr<CLocalView> srcView, shared_ptr<CDistributedView> dstView, MPI_Comm localComm, int remoteCommSize)  
    3434                       : srcView_(srcView), dstView_(dstView), localComm_(localComm), remoteCommSize_(remoteCommSize) {} 
    3535    void computeConnector(void) ; 
    … …  
    147147 
    148148    template<typename T>  
    149     void transfer(int rank, CScattererConnector** connectors, int nConnectors, const T* input, T* output) 
     149    void transfer(int rank, shared_ptr<CScattererConnector>* connectors, int nConnectors, const T* input, T* output) 
    150150    { 
    151151      auto& connector = connector_[rank] ; // probably costly, find a better way to avoid the map 
    … …  
    197197    } 
    198198 
    199     int getSrcSliceSize(CScattererConnector** connectors, int nConnectors)  
     199    int getSrcSliceSize(shared_ptr<CScattererConnector>* connectors, int nConnectors)  
    200200    { if (nConnectors==0) return srcSize_ ; else return srcSize_ * (*(connectors-1))->getSrcSliceSize(connectors-1,nConnectors-1) ; } 
    201201 
    202     int getDstSliceSize(int rank, CScattererConnector** connectors, int nConnectors)  
     202    int getDstSliceSize(int rank, shared_ptr<CScattererConnector>* connectors, int nConnectors)  
    203203    { if (nConnectors==0) return dstSize_[rank] ; else return dstSize_[rank] * (*(connectors-1))->getDstSliceSize(rank, connectors-1,nConnectors-1) ; } 
    204204 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/transfer_transform_connector.cpp

    r1996 r2267  
    44{ 
    55 
    6   CTransferTransformConnector::CTransferTransformConnector(CLocalView* srcView, CLocalView* dstView, unordered_map<int, int>& indexMap)  
     6  CTransferTransformConnector::CTransferTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, unordered_map<int, int>& indexMap)  
    77    : srcView_(srcView), dstView_(dstView) 
    88  { 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/transfer_transform_connector.hpp

    r1999 r2267  
    1515     
    1616    private: 
    17       CLocalView* srcView_; 
    18       CLocalView* dstView_; 
     17      shared_ptr<CLocalView> srcView_; 
     18      shared_ptr<CLocalView> dstView_; 
    1919 
    2020      vector<int> connector_;     
    … …  
    2727    public: 
    2828 
    29     CTransferTransformConnector(CLocalView* srcView, CLocalView* dstView, unordered_map<int, int>& indexMap) ; 
     29    CTransferTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, unordered_map<int, int>& indexMap) ; 
    3030  
    3131    void transfer(int repeat, int sizeT, const CArray<double,1>& dataIn, CArray<double,1>& dataOut) 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/transform_connector.cpp

    r1984 r2267  
    5656 
    5757    // distributed element : where to send data 
    58     CDistributedElement dstElement(srcView_->getGlobalSize(), dstArrayIndex) ; 
    59     dstElement.addFullView() ; 
     58    auto dstElement = make_shared<CDistributedElement>(srcView_->getGlobalSize(), dstArrayIndex) ; 
     59    dstElement->addFullView() ; 
    6060     
    6161    // create scatterer connector 
    6262    int commSize ; 
    6363    MPI_Comm_size(localComm_, &commSize) ; 
    64     scattererConnector_ = new CScattererConnector(srcView_, dstElement.getView(CElementView::FULL), localComm_, commSize ) ; 
     64    scattererConnector_ = make_shared<CScattererConnector>(srcView_, dstElement->getView(CElementView::FULL), localComm_, commSize ) ; 
    6565    scattererConnector_->computeConnector() ; 
    6666 
    … …  
    9898    MPI_Waitall(sendReq.size(),sendReq.data(),sendStatus.data()) ; 
    9999 
    100     CDistributedElement remoteElement(dstView_->getGlobalSize(), remoteArrayIndex) ; 
    101     remoteElement.addFullView() ; 
    102     gathererConnector_=new CGathererConnector(remoteElement.getView(CElementView::FULL),dstView_) ; 
     100    auto remoteElement = make_shared<CDistributedElement>(dstView_->getGlobalSize(), remoteArrayIndex) ; 
     101    remoteElement->addFullView() ; 
     102    gathererConnector_= make_shared<CGathererConnector>(remoteElement->getView(CElementView::FULL),dstView_) ; 
    103103    gathererConnector_->computeConnector() ; 
    104104 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/transform_connector.hpp

    r1984 r2267  
    1818      
    1919    public: 
    20       CTransformConnector(CLocalView* srcView, CLocalView* dstView, MPI_Comm localComm)  
     20      CTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, MPI_Comm localComm)  
    2121                          : srcView_(srcView), dstView_(dstView), localComm_(localComm) {} 
    2222     
    … …  
    2525 
    2626      MPI_Comm localComm_ ; 
    27       CLocalView* srcView_ ; 
    28       CLocalView* dstView_ ; 
     27      shared_ptr<CLocalView> srcView_ ; 
     28      shared_ptr<CLocalView> dstView_ ; 
    2929      map<int,int> recvRankSize_ ; 
    30       CScattererConnector* scattererConnector_=nullptr ; 
    31       CGathererConnector*  gathererConnector_=nullptr ; 
     30      shared_ptr<CScattererConnector> scattererConnector_ ; 
     31      shared_ptr<CGathererConnector>  gathererConnector_ ; 
    3232    
    3333    public: 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/weight_transform_connector.cpp

    r1984 r2267  
    44{ 
    55 
    6   CWeightTransformConnector::CWeightTransformConnector(CLocalView* srcView, CLocalView* dstView, unordered_map<int, std::vector<int>>& indexMap,  
     6  CWeightTransformConnector::CWeightTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, unordered_map<int, std::vector<int>>& indexMap,  
    77                                                   unordered_map<int, std::vector<double>>& weightMap) : srcView_(srcView), dstView_(dstView) 
    88  { 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/distribution/weight_transform_connector.hpp

    r1984 r2267  
    1515     
    1616    private: 
    17       CLocalView* srcView_; 
    18       CLocalView* dstView_; 
     17      shared_ptr<CLocalView> srcView_; 
     18      shared_ptr<CLocalView> dstView_; 
    1919 
    2020      vector<double> weights_; //  sizeof sum(nWeights_)   
    … …  
    2828    public: 
    2929 
    30     CWeightTransformConnector(CLocalView* srcView, CLocalView* dstView, unordered_map<int, std::vector<int>>& indexMap,  
     30    CWeightTransformConnector(shared_ptr<CLocalView> srcView, shared_ptr<CLocalView> dstView, unordered_map<int, std::vector<int>>& indexMap,  
    3131                              unordered_map<int, std::vector<double>>& weightMap) ; 
    3232  
Note: See TracChangeset for help on using the changeset viewer.