Changeset 1943


Ignore:
Timestamp:
09/25/20 16:09:35 (4 years ago)
Author:
ymipsl
Message:

Solve issues for grid mask on server side.

YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

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

    r1918 r1943  
    4141      }  
    4242 
     43      template<typename T>  
     44      void transfer(const map<int, CArray<T,1>>& input, CArray<T,1>& output, T missingValue) 
     45      { 
     46        int n = elementsConnector_.size()-1 ; 
     47        CGathererConnector** connector = elementsConnector_.data() + n ; 
     48        output.resize(dstSize_) ; 
     49        output = missingValue ; 
     50        for(auto& rankDataIn : input)  
     51        { 
     52          elementsConnector_[n]->transfer(rankDataIn.first, connector, n, rankDataIn.second.dataFirst(), output.dataFirst()) ; 
     53        } 
     54      }  
     55 
    4356      template<typename T> 
    4457      void transfer(CEventServer& event, CArray<T,1>& dataOut) 
    … …  
    5265        transfer(dataIn, dataOut) ; 
    5366      } 
    54    
     67  
     68      template<typename T> 
     69      void transfer(CEventServer& event, CArray<T,1>& dataOut, T missingValue) 
     70      { 
     71        map<int, CArray<T,1>> dataIn ; 
     72        for (auto& subEvent : event.subEvents)  
     73        { 
     74          auto& data = dataIn[subEvent.rank];  
     75          (*subEvent.buffer) >> data ; 
     76        } 
     77        transfer(dataIn, dataOut, missingValue) ; 
     78      } 
     79 
    5580  }; 
    5681} 

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

    r1918 r1943  
    5151 
    5252   // compute the number of senders for a remote destination view 
    53     int commSize ; 
    54     MPI_Comm_size(localComm_, &commSize) ; 
    55     vector<int> ranks(commSize,0) ; 
     53    vector<int> ranks(remoteCommSize_,0) ; 
    5654    for(auto& rank : connector_) ranks[rank.first] = 1 ; 
    57     MPI_Allreduce(MPI_IN_PLACE,ranks.data(),commSize,MPI_INT,MPI_SUM,localComm_) ; 
     55    MPI_Allreduce(MPI_IN_PLACE,ranks.data(),remoteCommSize_,MPI_INT,MPI_SUM,localComm_) ; 
    5856    for(auto& rank : connector_) nbSenders_[rank.first] = ranks[rank.first] ; 
    5957 

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

    r1930 r1943  
    2121      map<int, vector<bool>> mask_ ;  // mask is on dst view 
    2222      MPI_Comm localComm_ ; 
     23      int remoteCommSize_ ; 
    2324 
    2425      CLocalView* srcView_ ; 
    … …  
    3031    public: 
    3132 
    32     CScattererConnector(CLocalView* srcView, CDistributedView* dstView, MPI_Comm localComm)  
    33                        : srcView_(srcView), dstView_(dstView), localComm_(localComm) {} 
     33    CScattererConnector(CLocalView* srcView, CDistributedView* dstView, MPI_Comm localComm, int remoteCommSize)  
     34                       : srcView_(srcView), dstView_(dstView), localComm_(localComm), remoteCommSize_(remoteCommSize) {} 
    3435    void computeConnector(void) ; 
    3536     

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

    r1939 r1943  
    16561656    CDistributedElement scatteredElement(n_glo,globalIndex) ; 
    16571657    scatteredElement.addFullView() ; 
    1658     CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     1658    CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
     1659                                           context->getIntraComm(), client->getRemoteSize()) ; 
    16591660    scattererConnector.computeConnector() ; 
    16601661     
    … …  
    16961697    message2<<serverAxisId<<2 ;  
    16971698    clientToServerElement.sendToServer(client, event2, message2) ;  
    1698     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), 
    1699                                                               clientToServerElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     1699    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL),  
     1700                                                              context->getIntraComm(), client->getRemoteSize()) ; 
    17001701    clientToServerConnector_[client]->computeConnector() ; 
    1701  
    1702  
    1703     CEventClient event3(getType(), EVENT_ID_AXIS_DISTRIBUTION); 
    1704     CMessage message3 ; 
    1705     message3<<serverAxisId<<3 ;  
    1706     clientToServerConnector_[client]->transfer(maskIn,client,event3,message3) ;  
    17071702 
    17081703    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    … …  
    17631758      gathererConnector_ -> computeConnector() ; 
    17641759    } 
    1765     else if (phasis==3) 
    1766     { 
    1767       CArray<bool,1> localMask ; 
    1768       gathererConnector_->transfer(event,localMask,false) ; 
    1769       localElement_->addView(CElementView::WORKFLOW, localMask) ; 
    1770       mask.reference(localMask.copy()) ; 
     1760   
     1761  } 
     1762  CATCH 
     1763 
     1764  void CAxis::setServerMask(CArray<bool,1>& serverMask, CContextClient* client) 
     1765  TRY 
     1766  { 
     1767    CContext* context = CContext::getCurrent(); 
     1768    localElement_->addView(CElementView::WORKFLOW, serverMask) ; 
     1769    mask.reference(serverMask.copy()) ; 
    17711770  
    1772       serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    1773       serverFromClientConnector_->computeConnector() ; 
    1774  
    1775       serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    1776                                                          context->getIntraComm()) ; 
    1777       serverToClientConnector_->computeConnector() ; 
    1778  
    1779     } 
    1780   } 
    1781   CATCH 
     1771    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     1772    serverFromClientConnector_->computeConnector() ; 
     1773       
     1774    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     1775                                                         context->getIntraComm(), client->getRemoteSize()) ; 
     1776    serverToClientConnector_->computeConnector() ; 
     1777  } 
     1778  CATCH_DUMP_ATTR 
    17821779 
    17831780  void CAxis::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId) 

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

    r1934 r1943  
    258258         static void recvAxisDistribution(CEventServer& event) ; 
    259259         void receivedAxisDistribution(CEventServer& event, int phasis) ; 
    260  
     260         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client ) ; 
    261261         void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId) ; 
    262262         static void recvDistributedAttributes(CEventServer& event) ; 
    … …  
    272272       private: 
    273273         CGathererConnector*  gathererConnector_ ; 
     274       public: 
     275         CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
     276       private: 
    274277         CGathererConnector* serverFromClientConnector_ ; 
    275278         CDistributedElement* elementFrom_ ; 

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

    r1938 r1943  
    23052305    CDistributedElement scatteredElement(ni_glo*nj_glo, globalIndex) ; 
    23062306    scatteredElement.addFullView() ; 
    2307     CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     2307    CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
     2308                                           context->getIntraComm(), client->getRemoteSize()) ; 
    23082309    scattererConnector.computeConnector() ; 
    23092310 
    … …  
    23472348    message2<<serverDomainId<<2 ;  
    23482349    clientToServerElement.sendToServer(client, event2, message2) ;  
    2349     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), 
    2350                                                               clientToServerElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     2350    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL), 
     2351                                                               context->getIntraComm(), client->getRemoteSize()) ; 
    23512352    clientToServerConnector_[client]->computeConnector() ; 
    23522353 
    2353  
    2354     CEventClient event3(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
    2355     CMessage message3 ; 
    2356     message3<<serverDomainId<<3 ;  
    2357     clientToServerConnector_[client]->transfer(maskIn,client,event3,message3) ;  
    2358      
    23592354    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    23602355    clientFromServerConnector_[client]->computeConnector() ; 
    … …  
    24182413      gathererConnector_ -> computeConnector() ; 
    24192414    } 
    2420     else if (phasis==3) 
    2421     { 
    2422       CArray<bool,1> localMask ; 
    2423       gathererConnector_->transfer(event,localMask,false) ; 
    2424       localElement_->addView(CElementView::WORKFLOW, localMask) ; 
    2425       mask_1d.reference(localMask.copy()) ; 
     2415  } 
     2416  CATCH 
     2417 
     2418  void CDomain::setServerMask(CArray<bool,1>& serverMask, CContextClient* client) 
     2419  TRY 
     2420  { 
     2421    // nota : the client is needed to get the remote size for the scatterer connector. Maybe it is not the good place for this 
     2422    // Later, server to client connector can be computed on demand, with "client" as argument 
     2423    CContext* context = CContext::getCurrent(); 
     2424    localElement_->addView(CElementView::WORKFLOW, serverMask) ; 
     2425    mask_1d.reference(serverMask.copy()) ; 
    24262426  
    2427       serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    2428       serverFromClientConnector_->computeConnector() ; 
     2427    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     2428    serverFromClientConnector_->computeConnector() ; 
    24292429       
    2430       serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    2431                                                          context->getIntraComm()) ; 
    2432       serverToClientConnector_->computeConnector() ; 
    2433   
    2434     } 
    2435   } 
    2436   CATCH 
     2430    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     2431                                                       context->getIntraComm(), client->getRemoteSize()) ; 
     2432    serverToClientConnector_->computeConnector() ; 
     2433  } 
     2434  CATCH_DUMP_ATTR 
    24372435 
    24382436 
    … …  
    25792577    CDistributedElement scatteredElement(remoteElement.getGlobalSize(), remoteConnector.getDistributedGlobalIndex()) ; 
    25802578    scatteredElement.addFullView() ; 
    2581     CScattererConnector scatterConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     2579    CScattererConnector scatterConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
     2580                                         context->getIntraComm(), client->getRemoteSize()) ; 
    25822581    scatterConnector.computeConnector() ; 
    25832582    CGridScattererConnector gridScatter({&scatterConnector}) ; 

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

    r1934 r1943  
    212212       private: 
    213213         std::set<CContextClient*> sendDomainToFileServer_done_ ; 
    214        private: 
    215          public: 
     214       public: 
    216215         void sendDomainToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) ; 
    217216       private: 
    … …  
    341340         static void recvDistributedAttributes(CEventServer& event) ; 
    342341         void recvDistributedAttributes(CEventServer& event, const string& type) ; 
     342         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client) ; 
     343 
    343344       private: 
    344345         map<CContextClient*, CDistributedElement*> remoteElement_ ; 
    … …  
    352353       private: 
    353354         CGathererConnector*  gathererConnector_ ; 
     355       public: 
     356         CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
     357        private: 
    354358         CGathererConnector* serverFromClientConnector_ ; 
    355359         CDistributedElement* elementFrom_ ; 

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

    r1940 r1943  
    2323#include "grid_elements.hpp" 
    2424#include "grid_local_view.hpp" 
     25#include "grid_mask_connector.hpp" 
    2526 
    2627 
    … …  
    275276  TRY 
    276277  { 
     278    setDomainList(); 
    277279    std::vector<CDomain*> domList; 
    278280    if (!domList_.empty()) 
    … …  
    291293  TRY 
    292294  { 
     295    setAxisList(); 
    293296    std::vector<CAxis*> aList; 
    294297    if (!axisList_.empty()) 
    … …  
    306309  TRY 
    307310  { 
     311    setScalarList() ; 
    308312    std::vector<CScalar*> sList; 
    309313    if (!scalarList_.empty()) 
    … …  
    25972601           return true; 
    25982602           break; 
     2603 
     2604         case EVENT_ID_SEND_MASK : 
     2605           recvMask(event); 
     2606           return true; 
     2607           break; 
    25992608        default : 
    2600           ERROR("bool CDomain::dispatchEvent(CEventServer& event)", 
     2609          ERROR("bool CGrid::dispatchEvent(CEventServer& event)", 
    26012610                << "Unknown Event"); 
    26022611          return false; 
    … …  
    26712680    gridRemoteConnector.computeConnector() ; 
    26722681     
    2673     vector<CScattererConnector*> clientToServerConnectors ; 
    2674     vector<CGathererConnector*>  clientFromServerConnectors ; 
     2682    vector<CScattererConnector*> scattererConnectors ; 
    26752683    for(int i=0 ; i<elements.size() ; i++) 
    26762684    { 
    … …  
    26802688         sendAddDomain(domain->getId(),client) ; 
    26812689         domain->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ; 
    2682          clientToServerConnectors.push_back(domain->getClientToServerConnector(client)) ; 
    2683          clientFromServerConnectors.push_back(domain->getClientFromServerConnector(client)) ; 
     2690         scattererConnectors.push_back(domain->getClientToServerConnector(client)) ; 
    26842691      } 
    26852692      else if (elements[i].type==TYPE_AXIS) 
    … …  
    26882695        sendAddAxis(axis->getId(),client) ; 
    26892696        axis->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ; 
    2690         clientToServerConnectors.push_back(axis->getClientToServerConnector(client)) ; 
    2691         clientFromServerConnectors.push_back(axis->getClientFromServerConnector(client)) ; 
    2692  
     2697        scattererConnectors.push_back(axis->getClientToServerConnector(client)) ; 
    26932698      } 
    26942699      else if (elements[i].type==TYPE_SCALAR) 
    … …  
    26972702        sendAddScalar(scalar->getId(),client) ; 
    26982703        scalar->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ; 
    2699         clientToServerConnectors.push_back(scalar->getClientToServerConnector(client)) ; 
    2700         clientFromServerConnectors.push_back(scalar->getClientFromServerConnector(client)) ; 
     2704        scattererConnectors.push_back(scalar->getClientToServerConnector(client)) ; 
     2705      } 
     2706    } 
     2707 
     2708    CGridScattererConnector gridScattererConnector(scattererConnectors) ; 
     2709    CGridLocalConnector* workflowToFull = getGridLocalElements()->getConnector(CElementView::WORKFLOW, CElementView::FULL) ; 
     2710    CArray<bool,1> maskIn(workflowToFull->getSrcSize()) ; 
     2711    CArray<bool,1> maskOut(workflowToFull->getDstSize()) ; 
     2712    maskIn = true ; 
     2713    workflowToFull->transfer(maskIn,maskOut,false) ; 
     2714 
     2715    CEventClient event(getType(), EVENT_ID_SEND_MASK); 
     2716    CMessage message ; 
     2717    message<<getId() ;  
     2718    gridScattererConnector.transfer(maskOut, client, event, message) ; 
     2719 
     2720 
     2721    vector<CScattererConnector*> clientToServerConnectors ; 
     2722    vector<CGathererConnector*>  clientFromServerConnectors ; 
     2723    for(auto& element : elements) 
     2724    { 
     2725      if (element.type==TYPE_DOMAIN)  
     2726      {  
     2727         clientToServerConnectors.push_back(element.domain->getClientToServerConnector(client)) ; 
     2728         clientFromServerConnectors.push_back(element.domain->getClientFromServerConnector(client)) ; 
     2729      } 
     2730      else if (element.type==TYPE_AXIS) 
     2731      { 
     2732        clientToServerConnectors.push_back(element.axis->getClientToServerConnector(client)) ; 
     2733        clientFromServerConnectors.push_back(element.axis->getClientFromServerConnector(client)) ; 
     2734 
     2735      } 
     2736      else if (element.type==TYPE_SCALAR) 
     2737      { 
     2738        clientToServerConnectors.push_back(element.scalar->getClientToServerConnector(client)) ; 
     2739        clientFromServerConnectors.push_back(element.scalar->getClientFromServerConnector(client)) ; 
    27012740      } 
    27022741    } 
    … …  
    27072746 
    27082747 
     2748  } 
     2749 
     2750  void CGrid::recvMask(CEventServer& event) 
     2751  { 
     2752    string gridId; 
     2753    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> gridId  ; 
     2754    get(gridId)->receiveMask(event); 
     2755  } 
     2756   
     2757  void CGrid::receiveMask(CEventServer& event) 
     2758  { 
     2759    vector<CGathererConnector*> gathererConnectors ; 
     2760    vector<CLocalView*> fullViews ; 
     2761 
     2762    for(auto& element : getElements()) 
     2763    { 
     2764      if (element.type==TYPE_DOMAIN)  
     2765      { 
     2766        gathererConnectors.push_back(element.domain->getGathererConnector()); 
     2767        fullViews.push_back(element.domain->getLocalElement()->getView(CElementView::FULL)); 
     2768         
     2769      } 
     2770      else if (element.type==TYPE_AXIS) 
     2771      { 
     2772       gathererConnectors.push_back(element.axis->getGathererConnector()); 
     2773       fullViews.push_back(element.axis->getLocalElement()->getView(CElementView::FULL)); 
     2774      } 
     2775      else if (element.type==TYPE_SCALAR)  
     2776      { 
     2777        gathererConnectors.push_back(element.scalar->getGathererConnector()); 
     2778        fullViews.push_back(element.scalar->getLocalElement()->getView(CElementView::FULL)); 
     2779      } 
     2780    } 
     2781    CGridGathererConnector gridGathererConnector(gathererConnectors) ; 
     2782    CGridMaskConnector gridMaskConnector(fullViews) ; 
     2783 
     2784    CArray<bool,1> maskOut ; 
     2785    gridGathererConnector.transfer(event,maskOut,false) ; 
     2786    gridMaskConnector.computeConnector(maskOut) ; 
     2787 
     2788    CContextClient* client = event.getContextServer()->getAssociatedClient() ; 
     2789    int i=0 ; 
     2790    for(auto& element : getElements()) 
     2791    { 
     2792      if (element.type==TYPE_DOMAIN) element.domain->setServerMask(gridMaskConnector.getElementMask(i),client); 
     2793      else if (element.type==TYPE_AXIS) element.axis->setServerMask(gridMaskConnector.getElementMask(i),client); 
     2794      else if (element.type==TYPE_SCALAR) element.scalar->setServerMask(gridMaskConnector.getElementMask(i),client); 
     2795      i++ ; 
     2796    } 
    27092797  } 
    27102798 

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

    r1934 r1943  
    7575         enum EEventId 
    7676         { 
    77            EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR 
     77           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR, 
     78           EVENT_ID_SEND_MASK, 
     79 
    7880         }; 
    7981 
    … …  
    518520  */ 
    519521//        std::map<CContextClient*, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_; 
    520         std::map<int, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_; 
    521  
    522        
     522      std::map<int, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_; 
     523      
    523524 
    524525     ////////////////////////////////////////////////////////////////////////////////////// 
    525526     //  this part is related to distribution, element definition, views and connectors  // 
    526527     ////////////////////////////////////////////////////////////////////////////////////// 
    527  
     528      private: 
     529       static void recvMask(CEventServer& event) ; 
     530       void receiveMask(CEventServer& event) ; 
    528531 
    529532      private:   

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

    r1940 r1943  
    313313    CDistributedElement scatteredElement(1,globalIndex) ; 
    314314    scatteredElement.addFullView() ; 
    315     CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     315    CScattererConnector scattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),  
     316                                           context->getIntraComm(), client->getRemoteSize()) ; 
    316317    scattererConnector.computeConnector() ; 
    317318     
    … …  
    353354    message2<<serverScalarId<<2 ;  
    354355    clientToServerElement.sendToServer(client, event2, message2) ;  
    355     clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), 
    356                                                               clientToServerElement.getView(CElementView::FULL), context->getIntraComm()) ; 
     356    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL), 
     357                                                               context->getIntraComm(), client->getRemoteSize()) ; 
    357358    clientToServerConnector_[client]->computeConnector() ; 
    358  
    359  
    360     CEventClient event3(getType(), EVENT_ID_SCALAR_DISTRIBUTION); 
    361     CMessage message3 ; 
    362     message3<<serverScalarId<<3 ;  
    363     clientToServerConnector_[client]->transfer(maskIn,client,event3,message3) ;  
    364359 
    365360    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    … …  
    407402      gathererConnector_ -> computeConnector() ; 
    408403    } 
    409     else if (phasis==3) 
    410     { 
    411       CArray<bool,1> localMask ; 
    412       gathererConnector_->transfer(event,localMask,false) ; 
    413       localElement_->addView(CElementView::WORKFLOW, localMask) ; 
    414       mask = localMask(0) ; 
    415         
    416       serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
    417       serverFromClientConnector_->computeConnector() ; 
    418  
    419       serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
    420                                                          context->getIntraComm()) ; 
    421       serverToClientConnector_->computeConnector() ; 
    422  
    423     } 
    424404  } 
    425405  CATCH 
     406 
     407  void CScalar::setServerMask(CArray<bool,1>& serverMask, CContextClient* client) 
     408  TRY 
     409  { 
     410    CContext* context = CContext::getCurrent(); 
     411    localElement_->addView(CElementView::WORKFLOW, serverMask) ; 
     412    mask = serverMask(0) ; 
     413  
     414    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ; 
     415    serverFromClientConnector_->computeConnector() ; 
     416       
     417    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     418                                                         context->getIntraComm(), client->getRemoteSize()) ; 
     419    serverToClientConnector_->computeConnector() ; 
     420  } 
     421  CATCH_DUMP_ATTR 
    426422 
    427423  void CScalar::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId) 

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

    r1940 r1943  
    178178         static void recvScalarDistribution(CEventServer& event) ; 
    179179         void receivedScalarDistribution(CEventServer& event, int phasis) ; 
     180         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client) ; 
    180181         void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId) ; 
    181182         static void recvDistributedAttributes(CEventServer& event) ; 
    … …  
    193194       private: 
    194195         CGathererConnector*  gathererConnector_ ; 
     196       public: 
     197         CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;} 
     198       private: 
    195199         CGathererConnector* serverFromClientConnector_ ; 
    196200         CDistributedElement* elementFrom_ ; 
Note: See TracChangeset for help on using the changeset viewer.