Changeset 2304


Ignore:
Timestamp:
03/07/22 16:41:48 (2 years ago)
Author:
ymipsl
Message:

Fix problem in remote connector for read variable : supress redondance optimisation on remote connector in read case.
YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r2267 r2304  
    1616 
    1717 
    18   void CGridClientServerRemoteConnector::computeConnector(void) 
     18  void CGridClientServerRemoteConnector::computeConnector(bool eliminateRedondant) 
    1919  { 
    20     auto workflowRemoteConnector=make_shared<CGridRemoteConnector>(srcWorkflowView_,dstView_,localComm_,remoteSize_) ; 
    21     workflowRemoteConnector->computeConnector() ; 
    22     computeViewDistribution() ; 
     20    if (eliminateRedondant) 
     21    { 
     22      auto workflowRemoteConnector=make_shared<CGridRemoteConnector>(srcWorkflowView_,dstView_,localComm_,remoteSize_) ; 
     23      workflowRemoteConnector->computeConnector() ; 
     24      computeViewDistribution() ; 
    2325     
    24     for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowRemoteConnector->getIsSrcViewDistributed()[i]  ; 
    25     computeConnectorMethods() ; 
    26     computeRedondantRanks() ; 
     26      for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowRemoteConnector->getIsSrcViewDistributed()[i]  ; 
     27      computeConnectorMethods() ; 
     28      computeRedondantRanks() ; 
    2729 
    28     for(auto& rank : rankToRemove_) 
    29       if (workflowRemoteConnector->getRankToRemove().count(rank)!=0) 
    30         for(auto& element : elements_) element.erase(rank) ; 
     30      for(auto& rank : rankToRemove_) 
     31        if (workflowRemoteConnector->getRankToRemove().count(rank)!=0) 
     32          for(auto& element : elements_) element.erase(rank) ; 
     33    } 
     34    else  
     35    { 
     36      computeViewDistribution() ; 
     37      computeConnectorRedundant() ; 
     38    } 
    3139  } 
    3240 

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

    r2267 r2304  
    1313 
    1414      CGridClientServerRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CLocalView>>& worflowSrcView, vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize) ; 
    15       void computeConnector(void) ; 
     15      void computeConnector(bool eliminateRedondant=true) ; 
    1616      vector<shared_ptr<CLocalView>> srcWorkflowView_ ;    
    1717  } ; 

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

    r2291 r2304  
    927927  } 
    928928  
    929   void CAxis::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,  
     929  void CAxis::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,  
    930930                                 shared_ptr<CScattererConnector> &scattererConnector, const string& axisId) 
    931931  { 
    … …  
    935935    this->sendAllAttributesToServer(client, serverAxisId)  ; 
    936936 
    937     auto scatteredElement = make_shared<CDistributedElement>(n_glo,globalIndex) ; 
     937    auto scatteredElement = make_shared<CDistributedElement>(n_glo,globalIndexOut) ; 
    938938    scatteredElement->addFullView() ; 
    939939    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
    … …  
    958958   
    959959    // phase 2 send the mask : data index + mask2D 
    960     CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    961     CArray<bool,1> maskOut ; 
    962     auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    963     workflowToFull->computeConnector() ; 
    964     maskIn=true ; 
    965     workflowToFull->transfer(maskIn,maskOut,false) ; 
    966  
    967     // phase 3 : prepare grid scatterer connector to send data from client to server 
    968     map<int,CArray<size_t,1>> workflowGlobalIndex ; 
    969     map<int,CArray<bool,1>> maskOut2 ;  
    970     scattererConnector->transfer(maskOut, maskOut2) ; 
    971     scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
    972     scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    973     // create new workflow view for scattered element 
    974     auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
    975     clientToServerElement->addFullView() ; 
    976     CEventClient event2(getType(), EVENT_ID_AXIS_DISTRIBUTION); 
    977     CMessage message2 ; 
    978     message2<<serverAxisId<<2 ;  
    979     clientToServerElement->sendToServer(client, event2, message2) ;  
    980     clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL),  
     960    { 
     961      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     962      CArray<bool,1> maskOut ; 
     963      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     964      workflowToFull->computeConnector() ; 
     965      maskIn=true ; 
     966      workflowToFull->transfer(maskIn,maskOut,false) ; 
     967 
     968      //  prepare grid scatterer connector to send data from client to server 
     969      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     970      map<int,CArray<bool,1>> maskOut2 ;  
     971      scattererConnector->transfer(maskOut, maskOut2) ; 
     972      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     973      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     974      // create new workflow view for scattered element 
     975      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     976      clientToServerElement->addFullView() ; 
     977      CEventClient event2(getType(), EVENT_ID_AXIS_DISTRIBUTION); 
     978      CMessage message2 ; 
     979      message2<<serverAxisId<<2 ;  
     980      clientToServerElement->sendToServer(client, event2, message2) ;  
     981      clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL),  
    981982                                                                        context->getIntraComm(), client->getRemoteSize()) ; 
    982     clientToServerConnector_[client]->computeConnector() ; 
    983  
    984     clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    985     clientFromServerConnector_[client]->computeConnector() ; 
     983      clientToServerConnector_[client]->computeConnector() ; 
     984    } 
     985 
     986    //////////// 
     987    // phase 3 : compute connector to receive from server 
     988    //////////// 
     989    { 
     990      auto scatteredElement = make_shared<CDistributedElement>(n_glo, globalIndexIn) ; 
     991      scatteredElement->addFullView() ; 
     992      auto scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     993                                                                 context->getIntraComm(), client->getRemoteSize()) ; 
     994      scattererConnector->computeConnector() ; 
     995      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     996      CArray<bool,1> maskOut ; 
     997      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     998      workflowToFull->computeConnector() ; 
     999      maskIn=true ; 
     1000      workflowToFull->transfer(maskIn,maskOut,false) ; 
     1001 
     1002      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     1003      map<int,CArray<bool,1>> maskOut2 ;  
     1004      scattererConnector->transfer(maskOut, maskOut2, false) ; 
     1005      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     1006      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     1007      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     1008      clientToServerElement->addFullView() ; 
     1009      CEventClient event3(getType(), EVENT_ID_AXIS_DISTRIBUTION); 
     1010      CMessage message3 ; 
     1011      message3<<serverAxisId<<3 ;  
     1012      clientToServerElement->sendToServer(client, event3, message3) ;  
     1013 
     1014      clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     1015      clientFromServerConnector_[client]->computeConnector() ;       
     1016    } 
     1017 
     1018//    clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     1019//    clientFromServerConnector_[client]->computeConnector() ; 
    9861020 
    9871021 
    … …  
    10391073//      gathererConnector_ -> computeConnector() ; 
    10401074    } 
    1041    
     1075    else if (phasis==3) 
     1076    { 
     1077      elementTo_ = make_shared<CDistributedElement>(event) ; 
     1078      elementTo_->addFullView() ; 
     1079    } 
    10421080  } 
    10431081  CATCH 
    … …  
    10531091    serverFromClientConnector_->computeConnector() ; 
    10541092       
    1055     serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     1093    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL), 
    10561094                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    10571095    serverToClientConnector_->computeConnector() ; 

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

    r2291 r2304  
    248248       public: 
    249249         void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    250          void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector>& scattererConnector, 
    251                                  const string& axisId="") ; 
     250         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,  
     251                                 shared_ptr<CScattererConnector>& scattererConnector, const string& axisId="") ; 
    252252 
    253253         static void recvAxisDistribution(CEventServer& event) ; 
    … …  
    277277       private: 
    278278         shared_ptr<CScattererConnector> serverToClientConnector_ = nullptr ; 
     279         shared_ptr<CDistributedElement> elementTo_ ; 
    279280       public:  
    280281         shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  

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

    r2274 r2304  
    20032003  
    20042004 
    2005   void CDomain::distributeToServer(CContextClient* client, map<int, CArray<size_t,1>>& globalIndex, 
     2005  void CDomain::distributeToServer(CContextClient* client, map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
    20062006                                   shared_ptr<CScattererConnector> &scattererConnector, const string& domainId) 
    20072007  TRY 
    … …  
    20122012    this->sendAllAttributesToServer(client, serverDomainId)  ; 
    20132013 
    2014     auto scatteredElement = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndex) ; 
     2014    auto scatteredElement = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndexOut) ; 
    20152015    scatteredElement->addFullView() ; 
    20162016    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
    … …  
    20362036   
    20372037    // phase 2 send the mask : data index + mask2D 
    2038     CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    2039     CArray<bool,1> maskOut ; 
    2040     auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    2041     workflowToFull->computeConnector() ; 
    2042     maskIn=true ; 
    2043     workflowToFull->transfer(maskIn,maskOut,false) ; 
    2044  
    2045  
    2046     // phase 3 : prepare grid scatterer connector to send data from client to server 
    2047     map<int,CArray<size_t,1>> workflowGlobalIndex ; 
    2048     map<int,CArray<bool,1>> maskOut2 ;  
    2049     scattererConnector->transfer(maskOut, maskOut2, false) ; 
    2050     scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
    2051     scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    2052     // create new workflow view for scattered element 
    2053     auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
    2054     clientToServerElement->addFullView() ; 
    2055     CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
    2056     CMessage message2 ; 
    2057     message2<<serverDomainId<<2 ;  
    2058     clientToServerElement->sendToServer(client, event2, message2) ;  
    2059     clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
     2038    { 
     2039      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     2040      CArray<bool,1> maskOut ; 
     2041      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     2042      workflowToFull->computeConnector() ; 
     2043      maskIn=true ; 
     2044      workflowToFull->transfer(maskIn,maskOut,false) ; 
     2045 
     2046 
     2047      // prepare grid scatterer connector to send data from client to server 
     2048      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     2049      map<int,CArray<bool,1>> maskOut2 ;  
     2050      scattererConnector->transfer(maskOut, maskOut2, false) ; 
     2051      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     2052      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     2053      // create new workflow view for scattered element 
     2054      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     2055      clientToServerElement->addFullView() ; 
     2056      CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2057      CMessage message2 ; 
     2058      message2<<serverDomainId<<2 ;  
     2059      clientToServerElement->sendToServer(client, event2, message2) ;  
     2060      clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
    20602061                                                                        context->getIntraComm(), client->getRemoteSize()) ; 
    20612062    clientToServerConnector_[client]->computeConnector() ; 
    2062  
    2063     clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    2064     clientFromServerConnector_[client]->computeConnector() ; 
    2065  
     2063    } 
     2064    //////////// 
     2065    // phase 3 : compute connector to receive from server 
     2066    //////////// 
     2067    { 
     2068      auto scatteredElement = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndexIn) ; 
     2069      scatteredElement->addFullView() ; 
     2070      auto scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     2071                                                                 context->getIntraComm(), client->getRemoteSize()) ; 
     2072      scattererConnector->computeConnector() ; 
     2073 
     2074      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     2075      CArray<bool,1> maskOut ; 
     2076      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     2077      workflowToFull->computeConnector() ; 
     2078      maskIn=true ; 
     2079      workflowToFull->transfer(maskIn,maskOut,false) ; 
     2080 
     2081      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     2082      map<int,CArray<bool,1>> maskOut2 ;  
     2083      scattererConnector->transfer(maskOut, maskOut2, false) ; 
     2084      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     2085      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     2086      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     2087      clientToServerElement->addFullView() ; 
     2088      CEventClient event3(getType(), EVENT_ID_DOMAIN_DISTRIBUTION); 
     2089      CMessage message3 ; 
     2090      message3<<serverDomainId<<3 ;  
     2091      clientToServerElement->sendToServer(client, event3, message3) ;  
     2092 
     2093      clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     2094      clientFromServerConnector_[client]->computeConnector() ;       
     2095    } 
    20662096  } 
    20672097  CATCH 
    … …  
    21162146    else if (phasis==2) 
    21172147    { 
    2118 //      delete gathererConnector_ ; 
    21192148      elementFrom_ = make_shared<CDistributedElement>(event) ; 
    21202149      elementFrom_->addFullView() ; 
    2121 //      gathererConnector_ =  make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    2122 //      gathererConnector_ -> computeConnector() ; 
     2150    } 
     2151    else if (phasis==3) 
     2152    { 
     2153      elementTo_ = make_shared<CDistributedElement>(event) ; 
     2154      elementTo_->addFullView() ; 
    21232155    } 
    21242156  } 
    … …  
    21372169    serverFromClientConnector_->computeConnector() ; 
    21382170       
    2139     serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     2171    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL), 
    21402172                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    21412173    serverToClientConnector_->computeConnector() ; 

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

    r2282 r2304  
    309309       public: 
    310310         void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    311          void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector> &scattererConnector, 
    312                                  const string& domainId="") ; 
     311         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,  
     312                                 shared_ptr<CScattererConnector> &scattererConnector, const string& domainId="") ; 
    313313 
    314314         static void recvDomainDistribution(CEventServer& event) ; 
    … …  
    340340 
    341341       private: 
    342          shared_ptr<CScattererConnector>  serverToClientConnector_ = nullptr ; 
     342         shared_ptr<CScattererConnector> serverToClientConnector_ = nullptr ; 
     343         shared_ptr<CDistributedElement> elementTo_ ; 
    343344       public:  
    344345         shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  

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

    r2282 r2304  
    14181418    else sendGridToCouplerOut_done_.insert(client) ; 
    14191419    this->sendAllAttributesToServer(client, getCouplingAlias(fieldId)); 
    1420     distributeGridToServer(client,fieldId) ; 
     1420    distributeGridToServer(client, fieldId) ; 
    14211421  } 
    14221422 
    … …  
    14721472    // CGridClientServerRemoteConnector : workflowView is added to avoid spurious optimisation with only the fullview 
    14731473    auto gridRemoteConnector = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ; 
    1474     gridRemoteConnector->computeConnector() ; 
     1474    gridRemoteConnector->computeConnector(true) ; 
     1475     
     1476    auto gridRemoteConnectorIn = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ; 
     1477    gridRemoteConnectorIn->computeConnector(false) ; 
     1478 
    14751479     
    14761480    vector<shared_ptr<CScattererConnector>> scattererConnectors ; 
    … …  
    14811485      {  
    14821486        CDomain* domain = (CDomain*) elements[i].ptr ; 
    1483         if (isCoupling) domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  domain->getCouplingAlias(fieldId,i)) ; 
     1487        if (isCoupling) domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), 
     1488                                                   scattererConnector,  domain->getCouplingAlias(fieldId,i)) ; 
    14841489        else  
    14851490        { 
    14861491          sendAddDomain(domain->getId(),client) ; 
    1487           domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
     1492          domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ; 
    14881493        } 
    14891494        scattererConnectors.push_back(scattererConnector) ; 
    … …  
    14921497      { 
    14931498        CAxis* axis = (CAxis*) elements[i].ptr ; 
    1494         if (isCoupling) axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  axis->getCouplingAlias(fieldId,i)) ; 
     1499        if (isCoupling) axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), 
     1500                                                 scattererConnector,  axis->getCouplingAlias(fieldId,i)) ; 
    14951501        else  
    14961502        { 
    14971503          sendAddAxis(axis->getId(),client) ; 
    1498           axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
     1504          axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ; 
    14991505        } 
    15001506        scattererConnectors.push_back(scattererConnector) ; 
    … …  
    15031509      { 
    15041510        CScalar* scalar = (CScalar*) elements[i].ptr ; 
    1505         if (isCoupling) scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector,  scalar->getCouplingAlias(fieldId,i)) ; 
     1511        if (isCoupling) scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), 
     1512                                                   scattererConnector,  scalar->getCouplingAlias(fieldId,i)) ; 
    15061513        else  
    15071514        { 
    15081515          sendAddScalar(scalar->getId(),client) ; 
    1509           scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), scattererConnector) ; 
     1516          scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ; 
    15101517        } 
    15111518        scattererConnectors.push_back(scattererConnector) ; 

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

    r2274 r2304  
    420420  } 
    421421  
    422   void CScalar::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,  
     422  void CScalar::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut,  std::map<int, CArray<size_t,1>>& globalIndexIn,  
    423423                                   shared_ptr<CScattererConnector> &scattererConnector, const string& scalarId) 
    424424  { 
    … …  
    428428    this->sendAllAttributesToServer(client, serverScalarId)  ; 
    429429 
    430     auto scatteredElement = make_shared<CDistributedElement>(1,globalIndex) ; 
     430    auto scatteredElement = make_shared<CDistributedElement>(1,globalIndexOut) ; 
    431431    scatteredElement->addFullView() ; 
    432432    scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
    … …  
    451451   
    452452    // phase 2 send the mask : data index + mask2D 
    453     CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
    454     CArray<bool,1> maskOut ; 
    455     auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
    456     workflowToFull->computeConnector() ; 
    457     maskIn=true ; 
    458     workflowToFull->transfer(maskIn,maskOut,false) ; 
    459  
    460     // phase 3 : prepare grid scatterer connector to send data from client to server 
    461     map<int,CArray<size_t,1>> workflowGlobalIndex ; 
    462     map<int,CArray<bool,1>> maskOut2 ;  
    463     scattererConnector->transfer(maskOut, maskOut2) ; 
    464     scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
    465     scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
    466     // create new workflow view for scattered element 
    467     auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
    468     clientToServerElement->addFullView() ; 
    469     CEventClient event2(getType(), EVENT_ID_SCALAR_DISTRIBUTION); 
    470     CMessage message2 ; 
    471     message2<<serverScalarId<<2 ;  
    472     clientToServerElement->sendToServer(client, event2, message2) ;  
    473     clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
    474                                                                         context->getIntraComm(), client->getRemoteSize()) ; 
    475     clientToServerConnector_[client]->computeConnector() ; 
    476  
    477     clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
    478     clientFromServerConnector_[client]->computeConnector() ; 
    479  
     453    { 
     454      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     455      CArray<bool,1> maskOut ; 
     456      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     457      workflowToFull->computeConnector() ; 
     458      maskIn=true ; 
     459      workflowToFull->transfer(maskIn,maskOut,false) ; 
     460 
     461      // prepare grid scatterer connector to send data from client to server 
     462      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     463      map<int,CArray<bool,1>> maskOut2 ;  
     464      scattererConnector->transfer(maskOut, maskOut2) ; 
     465      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     466      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     467      // create new workflow view for scattered element 
     468      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     469      clientToServerElement->addFullView() ; 
     470      CEventClient event2(getType(), EVENT_ID_SCALAR_DISTRIBUTION); 
     471      CMessage message2 ; 
     472      message2<<serverScalarId<<2 ;  
     473      clientToServerElement->sendToServer(client, event2, message2) ;  
     474      clientToServerConnector_[client] = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), clientToServerElement->getView(CElementView::FULL), 
     475                                                                          context->getIntraComm(), client->getRemoteSize()) ; 
     476      clientToServerConnector_[client]->computeConnector() ; 
     477    } 
     478 
     479    //////////// 
     480    // phase 3 : compute connector to receive from server 
     481    //////////// 
     482    { 
     483      auto scatteredElement = make_shared<CDistributedElement>(1, globalIndexIn) ; 
     484      scatteredElement->addFullView() ; 
     485      auto scattererConnector = make_shared<CScattererConnector>(localElement_->getView(CElementView::FULL), scatteredElement->getView(CElementView::FULL),  
     486                                                                 context->getIntraComm(), client->getRemoteSize()) ; 
     487      scattererConnector->computeConnector() ; 
     488  
     489      CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize()); 
     490      CArray<bool,1> maskOut ; 
     491      auto workflowToFull = make_shared<CLocalConnector>(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ; 
     492      workflowToFull->computeConnector() ; 
     493      maskIn=true ; 
     494      workflowToFull->transfer(maskIn,maskOut,false) ; 
     495 
     496      map<int,CArray<size_t,1>> workflowGlobalIndex ; 
     497      map<int,CArray<bool,1>> maskOut2 ;  
     498      scattererConnector->transfer(maskOut, maskOut2, false) ; 
     499      scatteredElement->addView(CElementView::WORKFLOW, maskOut2) ; 
     500      scatteredElement->getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ; 
     501      auto clientToServerElement = make_shared<CDistributedElement>(scatteredElement->getGlobalSize(), workflowGlobalIndex) ; 
     502      clientToServerElement->addFullView() ; 
     503      CEventClient event3(getType(), EVENT_ID_SCALAR_DISTRIBUTION); 
     504      CMessage message3 ; 
     505      message3<<serverScalarId<<3 ;  
     506      clientToServerElement->sendToServer(client, event3, message3) ;  
     507 
     508      clientFromServerConnector_[client] = make_shared<CGathererConnector>(clientToServerElement->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)); 
     509      clientFromServerConnector_[client]->computeConnector() ;       
     510    } 
    480511  } 
    481512   
    … …  
    518549//      gathererConnector_ =  make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ; 
    519550//      gathererConnector_ -> computeConnector() ; 
     551    } 
     552    else if (phasis==3) 
     553    { 
     554      elementTo_ = make_shared<CDistributedElement>(event) ; 
     555      elementTo_->addFullView() ; 
    520556    } 
    521557  } 
    … …  
    532568    serverFromClientConnector_->computeConnector() ; 
    533569       
    534     serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL), 
     570    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL), 
    535571                                                                context->getIntraComm(), client->getRemoteSize()) ; 
    536572    serverToClientConnector_->computeConnector() ; 

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

    r2282 r2304  
    200200    public: 
    201201      void computeRemoteElement(CContextClient* client, EDistributionType) ; 
    202       void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, shared_ptr<CScattererConnector> &scattererConnector, 
    203                                 const string& scalarId="") ; 
     202      void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
     203                              shared_ptr<CScattererConnector> &scattererConnector, const string& scalarId="") ; 
    204204 
    205205      static void recvScalarDistribution(CEventServer& event) ; 
    … …  
    231231    private: 
    232232     shared_ptr<CScattererConnector>  serverToClientConnector_ = nullptr ; 
     233     shared_ptr<CDistributedElement> elementTo_ ; 
    233234    public:  
    234235      shared_ptr<CScattererConnector> getServerToClientConnector(void) { return serverToClientConnector_ ;}  
Note: See TracChangeset for help on using the changeset viewer.