Changeset 2397

Timestamp:

08/31/22 17:23:56 (21 months ago)

Author:

ymipsl

Message:

• Optimize remote connector computation in case of read (reverse way).
• don't compute anymore clientFromServerConnector (and all intermediate computation) for non reading case.

YM

Location:

XIOS3/trunk/src

Files:

• distribution/grid_client_server_remote_connector.cpp (modified) (1 diff)
• distribution/grid_client_server_remote_connector.hpp (modified) (1 diff)
• distribution/grid_remote_connector.cpp (modified) (9 diffs)
• distribution/grid_remote_connector.hpp (modified) (2 diffs)
• node/axis.cpp (modified) (4 diffs)
• node/axis.hpp (modified) (1 diff)
• node/context.cpp (modified) (2 diffs)
• node/domain.cpp (modified) (3 diffs)
• node/domain.hpp (modified) (1 diff)
• node/field.cpp (modified) (2 diffs)
• node/grid.cpp (modified) (10 diffs)
• node/grid.hpp (modified) (2 diffs)
• node/scalar.cpp (modified) (3 diffs)
• node/scalar.hpp (modified) (1 diff)

XIOS3/trunk/src/distribution/grid_client_server_remote_connector.cpp

@@ -38 +38 @@
     }
   }
+ 
+  void CGridClientServerRemoteConnector::computeConnectorOut()
+  {
+    set<int> workflowRankToRemove ;
+    vector<bool> workflowIsSrcViewDistributed ;
+    {
+      auto workflowRemoteConnector=make_shared<CGridRemoteConnector>(srcWorkflowView_,dstView_,localComm_,remoteSize_) ;
+      workflowRemoteConnector->computeViewDistribution() ;
+      workflowRemoteConnector->computeConnectorMethods(false) ;
+      workflowRemoteConnector->computeRedondantRanks(false) ;
+      workflowRankToRemove = workflowRemoteConnector->getRankToRemove() ;
+      workflowIsSrcViewDistributed = workflowRemoteConnector->getIsSrcViewDistributed() ;
+    }
+    
+    computeViewDistribution() ;
+    
+    for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowIsSrcViewDistributed[i]  ;
+    computeConnectorMethods(false) ;
+    computeRedondantRanks(false) ;
 
+    for(auto& rank : rankToRemove_)
+      if (workflowRankToRemove.count(rank)!=0)
+        for(auto& element : elements_) element.erase(rank) ;
+  }
+
+  void CGridClientServerRemoteConnector::computeConnectorIn()
+  {
+    set<int> workflowRankToRemove ;
+    vector<bool> workflowIsSrcViewDistributed ;
+    {
+      auto workflowRemoteConnector=make_shared<CGridRemoteConnector>(srcWorkflowView_,dstView_,localComm_,remoteSize_) ;
+      workflowRemoteConnector->computeViewDistribution() ;
+      workflowRemoteConnector->computeConnectorMethods(true) ;
+      workflowRemoteConnector->computeRedondantRanks(true) ;
+      workflowRankToRemove = workflowRemoteConnector->getRankToRemove() ;
+      workflowIsSrcViewDistributed = workflowRemoteConnector->getIsSrcViewDistributed() ;
+    }
+
+    computeViewDistribution() ;
+    
+    for(int i=0;i<srcView_.size();i++) isSrcViewDistributed_[i] =  isSrcViewDistributed_[i] || workflowIsSrcViewDistributed[i]  ;
+    computeConnectorMethods(true) ;
+    computeRedondantRanks(true) ;
+
+    for(auto& rank : rankToRemove_)
+      if (workflowRankToRemove.count(rank)!=0)
+        for(auto& element : elements_) element.erase(rank) ;
+  }
 }

XIOS3/trunk/src/distribution/grid_client_server_remote_connector.hpp

@@ -14 +14 @@
       CGridClientServerRemoteConnector(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CLocalView>>& worflowSrcView, vector<shared_ptr<CDistributedView>>& dstView, MPI_Comm localComm, int remoteSize) ;
       void computeConnector(bool eliminateRedondant=true) ;
+      void computeConnectorOut(void) ;
+      void computeConnectorIn(void) ;
       vector<shared_ptr<CLocalView>> srcWorkflowView_ ;   
   } ;

XIOS3/trunk/src/distribution/grid_remote_connector.cpp

@@ -3 +3 @@
 #include "leader_process.hpp"
 #include "mpi.hpp"
+#include "element.hpp"
 
 
@@ -188 +189 @@
   *         redondantly the the remote servers
   */
-  void CGridRemoteConnector::computeConnectorMethods(void)
+  void CGridRemoteConnector::computeConnectorMethods(bool reverse)
   {
     vector<shared_ptr<CLocalView>> srcView ;
@@ -201 +202 @@
     for(int i=0;i<dstView_.size();i++) dstViewsNonDistributed = dstViewsNonDistributed && !isDstViewDistributed_[i] ;
     
-    if (srcViewsNonDistributed) 
+  //*****************************************************
+    if (srcViewsNonDistributed && dstViewsNonDistributed)
+    {
+      int commRank, commSize ;
+      MPI_Comm_rank(localComm_,&commRank) ;
+      MPI_Comm_size(localComm_,&commSize) ;
+ 
+      map<int,bool> ranks ;
+      if (reverse)
+      {
+        int leaderRank=getLeaderRank(remoteSize_, commSize, commRank) ;
+        ranks[leaderRank] = true ; 
+      }
+      else
+      {
+        list<int> remoteRanks;
+        list<int> notUsed ;
+        computeLeaderProcess(commRank, commSize, remoteSize_, remoteRanks, notUsed) ;
+        for(int rank : remoteRanks) ranks[rank]=true ;
+      }
+      for(int i=0; i<srcView_.size(); i++) computeSrcDstNonDistributed(i,ranks) ;  
+    }
+  
+  //*****************************************************
+    else if (srcViewsNonDistributed) 
     {
       int commRank, commSize ;
@@ -208 +233 @@
       list<int> remoteRanks;
       list<int> notUsed ;
-      map<int,bool> ranks ;  
-      computeLeaderProcess(commRank, commSize, remoteSize_, remoteRanks, notUsed) ;
-      for(int rank : remoteRanks) ranks[rank]=true ;
+      map<int,bool> ranks ;
       
-      for(int i=0; i<srcView_.size(); i++)  
-      {
-        if (isDstViewDistributed_[i]) computeSrcNonDistributed(i) ;
-        else computeSrcDstNonDistributed(i, ranks) ;
-      }
+      if (reverse)
+      {
+        shared_ptr<CLocalElement> voidElement = make_shared<CLocalElement>(commRank, 0, CArray<size_t,1>()) ;
+        shared_ptr<CLocalView> voidView = make_shared<CLocalView>(voidElement, CElementView::FULL, CArray<int,1>()) ;
+
+        for(int i=0;i<srcView_.size();i++) 
+          if (isDstViewDistributed_[i])
+          {
+            if (commRank==0) srcView.push_back(srcView_[i]) ;
+            else srcView.push_back(make_shared<CLocalView>(make_shared<CLocalElement>(commRank, srcView_[i]->getGlobalSize(), CArray<size_t,1>()),
+                                                           CElementView::FULL, CArray<int,1>())) ; // void view
+            dstView.push_back(dstView_[i]) ;
+            indElements.push_back(i) ;
+          }
+        
+        computeGenericMethod(srcView, dstView, indElements) ;
+
+        for(int i=0;i<srcView_.size();i++) 
+          if (isDstViewDistributed_[i])
+          {
+            size_t sizeElement ;
+            int nRank ;
+            if (commRank==0) nRank = elements_[i].size() ;
+            MPI_Bcast(&nRank, 1, MPI_INT, 0, localComm_) ;
+              
+            auto it=elements_[i].begin() ;
+            for(int j=0;j<nRank;j++)
+            {
+              int rank ;
+              size_t sizeElement ;
+              if (commRank==0) { rank = it->first ; sizeElement=it->second.numElements(); }
+              MPI_Bcast(&rank, 1, MPI_INT, 0, localComm_) ;
+              MPI_Bcast(&sizeElement, 1, MPI_SIZE_T, 0, localComm_) ;
+              if (commRank!=0) elements_[i][rank].resize(sizeElement) ;
+              MPI_Bcast(elements_[i][rank].dataFirst(), sizeElement, MPI_SIZE_T, 0, localComm_) ;
+              if (commRank==0) ++it ;
+            }
+          }
+
+        for(auto& it : elements_[indElements[0]]) 
+        {
+          if (it.second.numElements()==0) ranks[it.first] = false ;
+          else  ranks[it.first] = true ;
+        }
+    
+        for(int i=0;i<srcView_.size();i++) 
+          if (!isDstViewDistributed_[i]) computeSrcDstNonDistributed(i, ranks) ;
+
+      }
+      else 
+      {
+        computeLeaderProcess(commRank, commSize, remoteSize_, remoteRanks, notUsed) ;
+        for(int rank : remoteRanks) ranks[rank]=true ;
+
+        for(int i=0; i<srcView_.size(); i++)  
+        {
+          if (isDstViewDistributed_[i]) computeSrcNonDistributed(i) ;
+          else computeSrcDstNonDistributed(i, ranks) ;
+        }
+      }
+
     } 
+  //*****************************************************
     else if (dstViewsNonDistributed)
     {
+      int commRank, commSize ;
+      MPI_Comm_rank(localComm_,&commRank) ;
+      MPI_Comm_size(localComm_,&commSize) ;
+ 
       map<int,bool> ranks ;
-      for(int i=0;i<remoteSize_;i++) ranks[i]=true ;
+      if (reverse)
+      {
+        int leaderRank=getLeaderRank(remoteSize_, commSize, commRank) ;
+        ranks[leaderRank] = true ; 
+      }
+      else for(int i=0;i<remoteSize_;i++) ranks[i]=true ;
+     
       for(int i=0; i<srcView_.size(); i++)  
       {
@@ -228 +318 @@
       }
     } 
+  //*****************************************************
     else
     {
@@ -338 +429 @@
     }
   }
+
+/**
+  * \brief Compute the connector for the element \b i when the source view is not distributed. 
+  *        After the call element_[i] is defined.
+  *  \param i Indice of the element composing the source grid. 
+  */
+
+  void CGridRemoteConnector::computeSrcNonDistributedReverse(int i)
+  {
+    auto& element = elements_[i] ;
+    map<int,CArray<size_t,1>> globalIndexView ;
+    dstView_[i]->getGlobalIndexView(globalIndexView) ;
+    
+    CClientClientDHTTemplate<int>::Index2InfoTypeMap dataInfo;
+    
+    for(auto& it : globalIndexView)
+    {
+      auto& globalIndex=it.second ;
+      for(size_t ind : globalIndex) dataInfo[ind]=it.first ;
+    }
+    
+    // First we feed the distributed hash map  with key (remote global index) 
+    // associated with the value of the remote rank
+    CClientClientDHTTemplate<int> DHT(dataInfo, localComm_) ;
+    // after we feed the DHT with the local global indices of the source view
+
+    int commRank, commSize ;
+    MPI_Comm_rank(localComm_,&commRank) ;
+    MPI_Comm_size(localComm_,&commSize) ;
+    CArray<size_t,1> srcIndex ;
+    // like the source view is not distributed, then only the rank 0 need to feed the DHT
+    if (commRank==0) srcView_[i]->getGlobalIndexView(srcIndex) ;
+    
+    // compute the mapping
+    DHT.computeIndexInfoMapping(srcIndex) ;
+    auto& returnInfo = DHT.getInfoIndexMap() ;
+    
+    // returnInfo contains now the map for each global indices to send to a list of remote rank
+    // only for the rank=0 because it is the one to feed the DHT
+    // so it need to send the list to each server leader i.e. the local process that handle specifically one or more 
+    // servers
+    
+    // rankIndGlo : rankIndGlo[rank][indGlo] : list of indice to send the the remote server of rank "rank"
+    vector<vector<size_t>> rankIndGlo(remoteSize_) ;
+    if (commRank==0) 
+      for(auto& it1 : returnInfo)
+        for(auto& it2 : it1.second) rankIndGlo[it2].push_back(it1.first) ;
+    
+   // bcast the same for each client
+   for(int remoteRank=0 ; remoteRank<remoteSize_ ; remoteRank++)
+   {
+      int remoteDataSize ;
+      if (commRank==0) remoteDataSize = rankIndGlo[remoteRank].size() ;
+      MPI_Bcast(&remoteDataSize, 1, MPI_INT, 0, localComm_) ;
+
+      auto& element = elements_[i][remoteRank] ;
+      element.resize(remoteDataSize) ;
+      if (commRank==0) for(int j=0 ; j<remoteDataSize; j++) element(j)=rankIndGlo[remoteRank][j] ;
+      MPI_Bcast(element.dataFirst(), remoteDataSize, MPI_SIZE_T, 0, localComm_) ;
+   }
+  }
+
+
 
   /**
@@ -442 +596 @@
         for(auto& it2 : it1.second) indGlo.push_back(it1.first) ;
 
-    // now local rank 0 know which indices to seed to remote rank 0, but all the server
+    // now local rank 0 know which indices to send to remote rank 0, but all the server
     // must receive the same information. So only the leader rank will sent this.
     // So local rank 0 must broadcast the information to all leader.
@@ -642 +796 @@
   *        After we compare hash between local rank and remove redondant data corresponding to the same hash.
   */
-  void CGridRemoteConnector::computeRedondantRanks(void)
+  void CGridRemoteConnector::computeRedondantRanks(bool reverse)
   {
     int commRank ;
@@ -672 +826 @@
         }
       }
-    // a hash is now computed for data block I will sent to the server.
-
-    CClientClientDHTTemplate<int>::Index2InfoTypeMap info ;
-
-    map<size_t,int> hashRank ;
-    HashXIOS<int> hashGlobalIndexRank;
-    for(auto& it : hashRanks) 
-    {
-      it.second = hashGlobalIndexRank.hashCombine(it.first,it.second) ; 
-      info[it.second]=commRank ;
-      hashRank[it.second]=it.first ;
-    }
-
-    // we feed a DHT map with key : hash, value : myrank
-    CClientClientDHTTemplate<int> dataHash(info, localComm_) ;
-    CArray<size_t,1> hashList(hashRank.size()) ;
-    
-    int i=0 ;
-    for(auto& it : hashRank) { hashList(i)=it.first ; i++; }
-
-    // now who are the ranks that have the same hash : feed the DHT with my list of hash
-    dataHash.computeIndexInfoMapping(hashList) ;
-    auto& hashRankList = dataHash.getInfoIndexMap() ;
-    
-
-    for(auto& it : hashRankList)
-    {
-      size_t hash = it.first ;
-      auto& ranks = it.second ;
+    
+    if (reverse)
+    {
+      set<size_t> hashs ;
+      //easy because local
+      for(auto& hashRank : hashRanks)
+      {
+        if (hashs.count(hashRank.second)==0) hashs.insert(hashRank.second) ;
+        else rankToRemove_.insert(hashRank.first) ;
+      }
+    
+    }
+    else
+    {
+      // a hash is now computed for data block I will sent to the server.
+
+      CClientClientDHTTemplate<int>::Index2InfoTypeMap info ;
+  
+      map<size_t,int> hashRank ;
+      HashXIOS<int> hashGlobalIndexRank;
+      for(auto& it : hashRanks) 
+      {
+        it.second = hashGlobalIndexRank.hashCombine(it.first,it.second) ; 
+        info[it.second]=commRank ;
+        hashRank[it.second]=it.first ;
+      }
+
+      // we feed a DHT map with key : hash, value : myrank
+      CClientClientDHTTemplate<int> dataHash(info, localComm_) ;
+      CArray<size_t,1> hashList(hashRank.size()) ;
+    
+      int i=0 ;
+      for(auto& it : hashRank) { hashList(i)=it.first ; i++; }
+
+      // now who are the ranks that have the same hash : feed the DHT with my list of hash
+      dataHash.computeIndexInfoMapping(hashList) ;
+      auto& hashRankList = dataHash.getInfoIndexMap() ;
+    
+
+      for(auto& it : hashRankList)
+      {
+        size_t hash = it.first ;
+        auto& ranks = it.second ;
       
-      bool first=true ;
-      // only the process with the lowest rank get in charge of sendinf data to remote server
-      for(int rank : ranks) if (commRank>rank) first=false ;
-      if (!first) rankToRemove_.insert(hashRank[hash]) ;
+        bool first=true ;
+        // only the process with the lowest rank get in charge of sendinf data to remote server
+        for(int rank : ranks) if (commRank>rank) first=false ;
+        if (!first) rankToRemove_.insert(hashRank[hash]) ;
+      }
     }
   }

XIOS3/trunk/src/distribution/grid_remote_connector.hpp

@@ -22 +22 @@
       void computeViewDistribution(void) ;
       void computeConnector(bool eliminateRedundant=true) ;
-      void computeConnectorMethods(void) ;
+      void computeConnectorMethods(bool reverse=false) ;
       void computeConnectorRedundant(void) ;
       void computeGenericMethod(vector<shared_ptr<CLocalView>>& srcView, vector<shared_ptr<CDistributedView>>& dstView, vector<int>& indElements) ;
@@ -28 +28 @@
       void computeDstNonDistributed(int i, map<int,bool>& ranks) ;
       void computeSrcNonDistributed(int i) ;
-      void computeRedondantRanks(void) ;
+      void computeSrcNonDistributedReverse(int i) ;
+      void computeRedondantRanks(bool reverse=false) ;
       std::map<int, CArray<size_t,1>>& getDistributedGlobalIndex(int pos) { return elements_[pos] ;} 
       const vector<bool>& getIsSrcViewDistributed(void) { return isSrcViewDistributed_ ;}

XIOS3/trunk/src/node/axis.cpp

@@ -982 +982 @@
   }
  
-  void CAxis::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
+  void CAxis::distributeToServer(CContextClient* client, bool inOut, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
                                  shared_ptr<CScattererConnector> &scattererConnector, const string& axisId)
   {
@@ -1042 +1042 @@
     // phase 3 : compute connector to receive from server
     ////////////
+    if (inOut)
     {
       auto scatteredElement = make_shared<CDistributedElement>(n_glo, globalIndexIn) ;
@@ -1128 +1129 @@
 //      gathererConnector_ -> computeConnector() ;
     }
-    else if (phasis==3)
+    else if (phasis==3) // only for server -> client
     {
       elementTo_ = make_shared<CDistributedElement>(event) ;
@@ -1145 +1146 @@
     serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
     serverFromClientConnector_->computeConnector() ;
-      
-    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
+    elementFrom_.reset() ;
+
+    if (elementTo_)
+    {
+      serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
                                                                 context->getIntraComm(), client->getRemoteSize()) ;
-    serverToClientConnector_->computeConnector() ;
+      serverToClientConnector_->computeConnector() ;
+      elementTo_.reset() ;
+    }
   }
   CATCH_DUMP_ATTR

XIOS3/trunk/src/node/axis.hpp

@@ -253 +253 @@
        public:
          void computeRemoteElement(CContextClient* client, EDistributionType) ;
-         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
+         void distributeToServer(CContextClient* client, bool inOut, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
                                  shared_ptr<CScattererConnector>& scattererConnector, const string& axisId="") ;
 

XIOS3/trunk/src/node/context.cpp

@@ -1012 +1012 @@
       for(auto file : this->enabledReadModeFiles) file->setContextClient(client) ;
    
+
+    // workflow startpoint => data from server on client side
+    // important : sendFieldToInputFileServer must be done prior sendFieldToFileServer because for the first case the grid remoteConnectorIn
+    //             and grid remoteConnectorOut will be computed, and in the second case only the remoteConnectorOut.
+    if (serviceType_==CServicesManager::CLIENT)
+    {
+      for(auto field : fileInField) 
+      {
+        field->sendFieldToInputFileServer() ;
+        field->connectToServerInput(garbageCollector) ; // connect the field to server filter
+        fileInFields_.push_back(field) ;
+      }
+    }
+
     // workflow endpoint => sent to IO/SERVER
     if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER)
@@ -1076 +1090 @@
     {
       field->connectToCouplerOut(garbageCollector) ; // for now the same kind of filter that for file server
-    }
-
-     // workflow startpoint => data from server on client side
-    if (serviceType_==CServicesManager::CLIENT)
-    {
-      for(auto field : fileInField) 
-      {
-        field->sendFieldToInputFileServer() ;
-        field->connectToServerInput(garbageCollector) ; // connect the field to server filter
-        fileInFields_.push_back(field) ;
-      }
     }
 

XIOS3/trunk/src/node/domain.cpp

@@ -2113 +2113 @@
  
 
-  void CDomain::distributeToServer(CContextClient* client, map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,
+  void CDomain::distributeToServer(CContextClient* client, bool inOut, map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,
                                    shared_ptr<CScattererConnector> &scattererConnector, const string& domainId)
   TRY
@@ -2175 +2175 @@
     // phase 3 : compute connector to receive from server
     ////////////
+    if (inOut)
     {
       auto scatteredElement = make_shared<CDistributedElement>(ni_glo*nj_glo, globalIndexIn) ;
@@ -2278 +2279 @@
     serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
     serverFromClientConnector_->computeConnector() ;
+    elementFrom_.reset() ;
       
-    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
+    if (elementTo_)
+    {
+      serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
                                                                 context->getIntraComm(), client->getRemoteSize()) ;
-    serverToClientConnector_->computeConnector() ;
+      serverToClientConnector_->computeConnector() ;
+      elementTo_.reset() ;
+    }
+
   }
   CATCH_DUMP_ATTR

XIOS3/trunk/src/node/domain.hpp

@@ -309 +309 @@
        public:
          void computeRemoteElement(CContextClient* client, EDistributionType) ;
-         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
+         void distributeToServer(CContextClient* client, bool inOut, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn, 
                                  shared_ptr<CScattererConnector> &scattererConnector, const string& domainId="") ;
 

XIOS3/trunk/src/node/field.cpp

@@ -1466 +1466 @@
     getRelFile()->sendFileToFileServer(client);
     sentGrid_ = grid_-> duplicateSentGrid() ;
-    sentGrid_->sendGridToFileServer(client);
+    sentGrid_->sendGridToFileServer(client, false);
     name = getFieldOutputName() ;
     this->sendAllAttributesToServer(client);
@@ -1477 +1477 @@
     getRelFile()->sendFileToFileServer(client);
     sentGrid_ = grid_-> duplicateSentGrid() ;
-    sentGrid_->sendGridToFileServer(client);
+    sentGrid_->sendGridToFileServer(client, true);
     read_access=true ; // not the best solution, but on server side, the field must be a starting point of the workflow
                        // must be replace by a better solution when implementing filters for reading and send to client

XIOS3/trunk/src/node/grid.cpp

@@ -1448 +1448 @@
  
 
-  void CGrid::sendGridToFileServer(CContextClient* client)
+  void CGrid::sendGridToFileServer(CContextClient* client, bool inOut)
   {
     if (sendGridToFileServer_done_.count(client)!=0) return ;
@@ -1457 +1457 @@
     gridPtr->sendCreateChild(this->getId(),client);
     this->sendAllAttributesToServer(client);
-    distributeGridToServer(client) ;
+    distributeGridToServer(client, inOut) ;
   }
 
@@ -1466 +1466 @@
     else sendGridToCouplerOut_done_.insert(client) ;
     this->sendAllAttributesToServer(client, getCouplingAlias(fieldId));
-    distributeGridToServer(client, fieldId) ;
-  }
-
-
-  void CGrid::distributeGridToServer(CContextClient* client, const string& fieldId)
+    distributeGridToServer(client, false, fieldId) ;
+  }
+
+
+  void CGrid::distributeGridToServer(CContextClient* client, bool inOut, const string& fieldId)
   {
     CContext* context = CContext::getCurrent();
@@ -1520 +1520 @@
     // CGridClientServerRemoteConnector : workflowView is added to avoid spurious optimisation with only the fullview
     auto gridRemoteConnector = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ;
-    gridRemoteConnector->computeConnector(true) ;
+    gridRemoteConnector->computeConnectorOut() ;
     
-    auto gridRemoteConnectorIn = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ;
-    gridRemoteConnectorIn->computeConnector(false) ;
-
-    
+    shared_ptr<CGridClientServerRemoteConnector> gridRemoteConnectorIn ;
+    if (inOut)
+    {
+      gridRemoteConnectorIn = make_shared<CGridClientServerRemoteConnector>(localViews, workflowView, remoteViews, context->getIntraComm(), client->getRemoteSize()) ;
+      gridRemoteConnectorIn->computeConnectorIn() ;
+    }
+    else gridRemoteConnectorIn = gridRemoteConnector ;
+
+
     vector<shared_ptr<CScattererConnector>> scattererConnectors ;
     shared_ptr<CScattererConnector> scattererConnector;
@@ -1533 +1538 @@
       { 
         CDomain* domain = (CDomain*) elements[i].ptr ;
-        if (isCoupling) domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
+        if (isCoupling) domain->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
                                                    scattererConnector,  domain->getCouplingAlias(fieldId,i)) ;
         else 
         {
           sendAddDomain(domain->getId(),client) ;
-          domain->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
+          domain->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
         }
         scattererConnectors.push_back(scattererConnector) ;
@@ -1545 +1550 @@
       {
         CAxis* axis = (CAxis*) elements[i].ptr ;
-        if (isCoupling) axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
+        if (isCoupling) axis->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
                                                  scattererConnector,  axis->getCouplingAlias(fieldId,i)) ;
         else 
         {
           sendAddAxis(axis->getId(),client) ;
-          axis->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
+          axis->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
         }
         scattererConnectors.push_back(scattererConnector) ;
@@ -1557 +1562 @@
       {
         CScalar* scalar = (CScalar*) elements[i].ptr ;
-        if (isCoupling) scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
+        if (isCoupling) scalar->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i),
                                                    scattererConnector,  scalar->getCouplingAlias(fieldId,i)) ;
         else 
         {
           sendAddScalar(scalar->getId(),client) ;
-          scalar->distributeToServer(client, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
+          scalar->distributeToServer(client, inOut, gridRemoteConnector->getDistributedGlobalIndex(i), gridRemoteConnectorIn->getDistributedGlobalIndex(i), scattererConnector) ;
         }
         scattererConnectors.push_back(scattererConnector) ;
@@ -1588 +1593 @@
       { 
          clientToServerConnectors.push_back(element.domain->getClientToServerConnector(client)) ;
-         clientFromServerConnectors.push_back(element.domain->getClientFromServerConnector(client)) ;
+         if (inOut) clientFromServerConnectors.push_back(element.domain->getClientFromServerConnector(client)) ;
       }
       else if (element.type==TYPE_AXIS)
       {
         clientToServerConnectors.push_back(element.axis->getClientToServerConnector(client)) ;
-        clientFromServerConnectors.push_back(element.axis->getClientFromServerConnector(client)) ;
+        if (inOut) clientFromServerConnectors.push_back(element.axis->getClientFromServerConnector(client)) ;
 
       }
@@ -1599 +1604 @@
       {
         clientToServerConnectors.push_back(element.scalar->getClientToServerConnector(client)) ;
-        clientFromServerConnectors.push_back(element.scalar->getClientFromServerConnector(client)) ;
+        if (inOut) clientFromServerConnectors.push_back(element.scalar->getClientFromServerConnector(client)) ;
       }
     }
@@ -1605 +1610 @@
     // compute the grid clientToServerConnector to send flux from client to servers
     clientToServerConnector_[client] = make_shared<CGridScattererConnector>(clientToServerConnectors) ;
-    clientFromServerConnector_[client] = make_shared<CGridGathererConnector>(clientFromServerConnectors) ;
+    if (inOut) clientFromServerConnector_[client] = make_shared<CGridGathererConnector>(clientFromServerConnectors) ;
 
   }

XIOS3/trunk/src/node/grid.hpp

@@ -172 +172 @@
 
       public:
-         void sendGridToFileServer(CContextClient* client) ;
+         void sendGridToFileServer(CContextClient* client, bool inOut) ;
       private:
          std::set<CContextClient*> sendGridToFileServer_done_ ;
@@ -351 +351 @@
 
       public: //? 
-        void distributeGridToServer(CContextClient* client, const string& fieldId="");
+        void distributeGridToServer(CContextClient* client, bool inOut, const string& fieldId="");
       
             

XIOS3/trunk/src/node/scalar.cpp

@@ -420 +420 @@
   }
  
-  void CScalar::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut,  std::map<int, CArray<size_t,1>>& globalIndexIn, 
+  void CScalar::distributeToServer(CContextClient* client, bool inOut, std::map<int, CArray<size_t,1>>& globalIndexOut,  std::map<int, CArray<size_t,1>>& globalIndexIn, 
                                    shared_ptr<CScattererConnector> &scattererConnector, const string& scalarId)
   {
@@ -480 +480 @@
     // phase 3 : compute connector to receive from server
     ////////////
+    if (inOut)
     {
       auto scatteredElement = make_shared<CDistributedElement>(1, globalIndexIn) ;
@@ -567 +568 @@
     serverFromClientConnector_ = make_shared<CGathererConnector>(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
     serverFromClientConnector_->computeConnector() ;
+    elementFrom_.reset() ;
       
-    serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
+    if (elementTo_)
+    {
+      serverToClientConnector_ = make_shared<CScattererConnector>(localElement_->getView(CElementView::WORKFLOW), elementTo_->getView(CElementView::FULL),
                                                                 context->getIntraComm(), client->getRemoteSize()) ;
-    serverToClientConnector_->computeConnector() ;
+      serverToClientConnector_->computeConnector() ;
+      elementTo_.reset() ;
+    }
   }
   CATCH_DUMP_ATTR

XIOS3/trunk/src/node/scalar.hpp

@@ -202 +202 @@
     public:
       void computeRemoteElement(CContextClient* client, EDistributionType) ;
-      void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,
+      void distributeToServer(CContextClient* client, bool inOut, std::map<int, CArray<size_t,1>>& globalIndexOut, std::map<int, CArray<size_t,1>>& globalIndexIn,
                               shared_ptr<CScattererConnector> &scattererConnector, const string& scalarId="") ;