Changeset 2453 for XIOS3/dev/XIOS_FILE_SERVICES/src/node

Timestamp:

01/03/23 19:06:42 (19 months ago)

Author:

ymipsl

Message:

Implementation of files service on dev branch

YM

Location:

XIOS3/dev/XIOS_FILE_SERVICES/src/node

Files:

• context.cpp (modified) (16 diffs)
• context.hpp (modified) (7 diffs)
• file.cpp (modified) (4 diffs)
• file.hpp (modified) (2 diffs)
• node_enum.hpp (modified) (1 diff)
• node_type.hpp (modified) (1 diff)
• pool_node.cpp (modified) (3 diffs)
• pool_node.hpp (modified) (2 diffs)
• service_node.cpp (added)
• service_node.hpp (added)

XIOS3/dev/XIOS_FILE_SERVICES/src/node/context.cpp

@@ -577 +577 @@
     if (commRank==0)
     {
-      CXios::getServicesManager()->getServiceNbPartitions(poolId, serverId, 0, nbPartitions) ;
+      CXios::getServicesManager()->getServiceNbPartitions(poolId, serverId, 0, nbPartitions, true) ;
       for(int i=0 ; i<nbPartitions; i++) CXios::getContextsManager()->createServerContext(poolId, serverId, i, getContextId()) ;
     }
@@ -588 +588 @@
       parentServerContext_->createIntercomm(poolId, serverId, i, getContextId(), intraComm_, interCommClient, interCommServer) ;
       int type ; 
-      if (commRank==0) CXios::getServicesManager()->getServiceType(poolId, serverId, 0, type) ;
+      if (commRank==0) CXios::getServicesManager()->getServiceType(poolId, serverId, 0, type, true) ;
       MPI_Bcast(&type,1,MPI_INT,0,intraComm_) ;
       string fullServerId=CXios::getContextsManager()->getServerContextName(poolId, serverId, i, type, getContextId()) ;
@@ -610 +610 @@
   CATCH_DUMP_ATTR
   
+  
+  // obsolete
   void CContext::createServerInterComm(void) 
   TRY
@@ -645 +647 @@
   }
   CATCH_DUMP_ATTR
+
+  
+  void CContext::getServerInterComm(const string& poolId, const string& serviceId,  vector<pair<CContextClient*,CContextServer*>>& clientServers)
+  {
+    vector<pair<string, pair<CContextClient*,CContextServer*>>> retClientServers ;
+
+    auto it=serversMap_.find(make_pair(poolId,serviceId)) ;
+    if (it!=serversMap_.end()) clientServers=it->second ;
+    else
+    {
+      if (attached_mode) createServerInterComm(CClient::getPoolRessource()->getId(), getContextId()+"_"+serviceId, retClientServers) ;
+      else createServerInterComm(poolId, serviceId, retClientServers) ;
+      for(auto& retClientServer : retClientServers)  clientServers.push_back(retClientServer.second) ;
+      
+      int serviceType ;
+      if (intraCommRank_==0) CXios::getServicesManager()->getServiceType(poolId, serviceId, 0, serviceType) ;
+      MPI_Bcast(&serviceType,1,MPI_INT,0,intraComm_) ;
+      
+      for(auto& clientServer : clientServers)     
+      {
+        if (serviceType==CServicesManager::WRITER) { writerClientOut_.push_back(clientServer.first)      ; writerServerOut_.push_back(clientServer.second) ; }
+        else if (serviceType==CServicesManager::READER) { readerClientOut_.push_back(clientServer.first) ; readerServerOut_.push_back(clientServer.second) ; }
+        else if (serviceType==CServicesManager::GATHERER) { writerClientOut_.push_back(clientServer.first) ; writerServerOut_.push_back(clientServer.second) ; }
+      }
+      serversMap_.insert(make_pair(make_pair(poolId,serviceId),clientServers)) ;
+    }
+
+  }
+
+  vector<CContextClient*> CContext::getContextClient(const string& poolId, const string& serviceId)
+  {
+    vector<pair<CContextClient*,CContextServer*>> clientServers ;
+    getServerInterComm(poolId, serviceId, clientServers ) ;
+    vector<CContextClient*> ret ;
+    for(auto& clientServer : clientServers) ret.push_back(clientServer.first) ;
+    return ret ;
+  }
+
 
   void CContext::globalEventLoop(void)
@@ -783 +823 @@
         CContextServer* server ;
 
+        /*
         if (writerClientOut_.size()!=0)
         {
@@ -803 +844 @@
           info(100)<<"DEBUG: context "<<getId()<<" release client writer ok"<<endl ;
         }
+        */
+
+        for(int n=0; n<writerClientOut_.size() ; n++)
+        {
+          client=writerClientOut_[n] ;
+          server=writerServerOut_[n] ;
+
+          info(100)<<"DEBUG: context "<<getId()<<" Send client finalize to writer"<<endl ;
+          client->finalize();
+          info(100)<<"DEBUG: context "<<getId()<<" Client finalize sent to writer"<<endl ;
+          bool bufferReleased;
+          do
+          {
+            client->eventLoop();
+            bufferReleased = !client->havePendingRequests();
+          } while (!bufferReleased);
+          info(100)<<"DEBUG: context "<<getId()<<" no pending request on writer ok"<<endl ;
+
+          bool notifiedFinalized=false ;
+          do
+          {
+            notifiedFinalized=client->isNotifiedFinalized() ;
+          } while (!notifiedFinalized) ;
+          server->releaseBuffers();
+          client->releaseBuffers();
+          info(100)<<"DEBUG: context "<<getId()<<" release client writer ok"<<endl ;
+        }
+        
 
         if (readerClientOut_.size()!=0)
@@ -879 +948 @@
 
    
+   void CContext::setDefaultServices(void)
+   {
+     defaultPoolWriterId_ = CXios::defaultPoolId ;
+     defaultPoolReaderId_ = CXios::defaultPoolId ;
+     defaultPoolGathererId_ = CXios::defaultPoolId ;
+     defaultWriterId_ = CXios::defaultWriterId ;
+     defaultReaderId_ = CXios::defaultReaderId ;
+     defaultGathererId_ = CXios::defaultGathererId ;
+     defaultUsingServer2_ = CXios::usingServer2 ;
+     
+     if (!default_pool.isEmpty())  defaultPoolWriterId_ = defaultPoolReaderId_= defaultPoolGathererId_= default_pool ;
+     if (!default_pool_writer.isEmpty()) defaultPoolWriterId_ = default_pool_writer ;
+     if (!default_pool_reader.isEmpty()) defaultPoolReaderId_ = default_pool_reader ;
+     if (!default_pool_gatherer.isEmpty()) defaultPoolGathererId_ = default_pool_gatherer ;
+     if (!default_writer.isEmpty()) defaultWriterId_ = default_writer ;
+     if (!default_reader.isEmpty()) defaultWriterId_ = default_reader ;
+     if (!default_gatherer.isEmpty()) defaultGathererId_ = default_gatherer ;
+     if (!default_using_server2.isEmpty()) defaultUsingServer2_ = default_using_server2 ;
+   }
+
    /*!
    \brief Close all the context defintion and do processing data
@@ -894 +983 @@
 
      CTimer::get("Context : close definition").resume() ;
-     
+          
      // create intercommunicator with servers. 
      // not sure it is the good place to be called here 
-     createServerInterComm() ;
+     //createServerInterComm() ;
 
 
@@ -916 +1005 @@
     // pour chacun des contextes.
     solveDescInheritance(true);
- 
+    setDefaultServices() ;
     // Check if some axis, domains or grids are eligible to for compressed indexed output.
     // Warning: This must be done after solving the inheritance and before the rest of post-processing
@@ -1023 +1112 @@
 
     // Distribute files between secondary servers according to the data size => assign a context to a file and then to fields
-    if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER ) distributeFiles(this->enabledWriteModeFiles);
-    //else if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledWriteModeFiles) file->setContextClient(client) ;
+    
+    if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER) distributeFiles(this->enabledWriteModeFiles) ;
+    /*
+    if (serviceType_==CServicesManager::CLIENT )
+    {   
+      if (CXios::usingServer2) distributeFiles(this->enabledWriteModeFiles, defaultPoolGathererId_, defaultGathererId_);
+      else distributeFiles(this->enabledWriteModeFiles, defaultPoolWriterId_, defaultWriterId_);
+    }
+    if (serviceType_==CServicesManager::GATHERER ) distributeFiles(this->enabledWriteModeFiles, defaultPoolWriterId_, defaultWriterId_);
+    */
 
     // client side, assign context for file reading
-    if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledReadModeFiles) file->setContextClient(readerClientOut_[0]) ;
-    
+//    if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledReadModeFiles) file->setContextClient(readerClientOut_[0]) ;
+    if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledReadModeFiles) 
+    {
+      string poolReaderId ;
+      string readerId ;
+      file->getReaderServicesId(defaultPoolReaderId_, defaultReaderId_, poolReaderId, readerId) ;
+      file->setContextClient(poolReaderId, readerId, 0) ;
+    }
+
     // server side, assign context where to send file data read
     if (serviceType_==CServicesManager::READER) for(auto file : this->enabledReadModeFiles) file->setContextClient(readerClientIn_[0]) ;
@@ -1163 +1267 @@
     // fix size for each context client
     for(auto& it : fieldBufferEvaluation) it.first->setBufferSize(it.second) ;
+
 
      CTimer::get("Context : close definition").suspend() ;
@@ -1436 +1541 @@
    TRY
    {
+     map< pair<string,string>, vector<CFile*>> fileMaps ;
+     for(auto& file : files)
+     {
+       string poolWriterId ;
+       string poolGathererId ;
+       string writerId  ;
+       string gathererId  ;
+       bool usingServer2 ;
+
+       file->getWriterServicesId(defaultUsingServer2_, defaultPoolWriterId_, defaultWriterId_, defaultPoolGathererId_, defaultGathererId_,
+                                 usingServer2, poolWriterId, writerId, poolGathererId, gathererId) ;
+       if (serviceType_==CServicesManager::CLIENT && usingServer2) fileMaps[make_pair(poolGathererId,gathererId)].push_back(file) ;
+       else fileMaps[make_pair(poolWriterId,writerId)].push_back(file) ;
+     }
+     for(auto& it : fileMaps) distributeFilesOnSameService(it.second, it.first.first, it.first.second) ;
+   }
+   CATCH_DUMP_ATTR
+
+
+   void CContext::distributeFilesOnSameService(const vector<CFile*>& files, const string& poolId, const string& serviceId)
+   TRY
+   {
      bool distFileMemory=false ;
      distFileMemory=CXios::getin<bool>("server2_dist_file_memory", distFileMemory);
 
-     int nbPools = writerClientOut_.size();
-     if (nbPools==1) distributeFileOverOne(files) ;
-     else if (distFileMemory) distributeFileOverMemoryBandwith(files) ;
-     else distributeFileOverBandwith(files) ;
-   }
-   CATCH_DUMP_ATTR
-
-   void CContext::distributeFileOverOne(const vector<CFile*>& files)
-   TRY
-   {
-    for(auto& file : files) file->setContextClient(writerClientOut_[0]) ;
-   }
-   CATCH_DUMP_ATTR
-
-   void CContext::distributeFileOverBandwith(const vector<CFile*>& files)
+     auto writers = getContextClient(poolId, serviceId) ;
+     int  nbPools = writers.size() ;
+     
+     if (nbPools==1) distributeFileOverOne(files, poolId, serviceId) ;
+     else if (distFileMemory) distributeFileOverMemoryBandwith(files, poolId, serviceId) ;
+     else distributeFileOverBandwith(files, poolId, serviceId) ;
+   }
+   CATCH_DUMP_ATTR
+
+   void CContext::distributeFileOverOne(const vector<CFile*>& files, const string& poolId, const string& serviceId)
+   TRY
+   {
+     for(auto& file : files) file->setContextClient(poolId, serviceId,0) ;
+   }
+   CATCH_DUMP_ATTR
+
+   void CContext::distributeFileOverBandwith(const vector<CFile*>& files, const string& poolId, const string& serviceId)
    TRY
    {
@@ -1459 +1588 @@
      
      std::ofstream ofs(("distribute_file_"+getId()+".dat").c_str(), std::ofstream::out);
-     int nbPools = writerClientOut_.size();
+     auto writers = getContextClient(poolId, serviceId) ;
+     int nbPools = writers.size();
+     //int nbPools = writerClientOut_.size();
 
      // (1) Find all enabled files in write mode
@@ -1512 +1643 @@
        dataSize=(*poolDataSize.begin()).first ;
        j=(*poolDataSize.begin()).second ;
-       dataSizeMap[i].second->setContextClient(writerClientOut_[j]);
+       dataSizeMap[i].second->setContextClient(poolId, serviceId, j);
        dataSize+=dataSizeMap[i].first;
        poolDataSize.erase(poolDataSize.begin()) ;
@@ -1522 +1653 @@
    CATCH_DUMP_ATTR
 
-   void CContext::distributeFileOverMemoryBandwith(const vector<CFile*>& filesList)
-   TRY
-   {
-     int nbPools = writerClientOut_.size();
+   void CContext::distributeFileOverMemoryBandwith(const vector<CFile*>& filesList, const string& poolId, const string& serviceId)
+   TRY
+   {
+     auto writers = getContextClient(poolId, serviceId) ;
+     int nbPools = writers.size();
+    
      double ratio=0.5 ;
      ratio=CXios::getin<double>("server2_dist_file_memory_ratio", ratio);
@@ -1591 +1724 @@
          }
        }
-       filesList[i]->setContextClient(writerClientOut_[files[i].assignedServer_]) ;
+       filesList[i]->setContextClient(poolId, serviceId, files[i].assignedServer_) ;
        delete [] files[i].assignedGrid_ ;
      }

XIOS3/dev/XIOS_FILE_SERVICES/src/node/context.hpp

@@ -103 +103 @@
          
          void initServer(MPI_Comm intraComm, int serviceType );
-         void createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer)  ;
- 
-         void createServerInterComm(void)  ;
-         void createServerInterComm_old(void)  ;
-         void createServerInterComm(const string& poolId, const string& serverId, vector<pair<string, pair<CContextClient*,CContextServer*>>>& clientServers ) ;
- 
-
+         
          bool isInitialized(void);
 
@@ -123 +117 @@
 
          bool isFinalized(void);
-
          void closeDefinition(void);
 
@@ -159 +152 @@
 
          // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
-         void distributeFiles(const std::vector<CFile*>& files);
-         void distributeFileOverOne(const vector<CFile*>& files) ; //!< Distribute files over one single server (no distribution)
-         void distributeFileOverBandwith(const std::vector<CFile*>& files) ; //!< Distribute files overs servers to balance the I/O bandwith
-         void distributeFileOverMemoryBandwith(const std::vector<CFile*>& files) ; //!< Distribute files overs servers to minimize the memory consumption
+         void distributeFiles(const vector<CFile*>& files) ;
+         void distributeFilesOnSameService(const vector<CFile*>& files, const string& poolId, const string& serviceId) ;
+         void distributeFileOverOne(const vector<CFile*>& files, const string& poolId, const string& serviceId) ; //!< Distribute files over one single server (no distribution)
+         void distributeFileOverBandwith(const std::vector<CFile*>& files, const string& poolId, const string& serviceId) ; //!< Distribute files overs servers to balance the I/O bandwith
+         void distributeFileOverMemoryBandwith(const std::vector<CFile*>& files, const string& poolId, const string& serviceId) ; //!< Distribute files overs servers to minimize the memory consumption
          
        public:
@@ -271 +265 @@
          bool setProcessingEvent(void) {isProcessingEvent_=true ;}
          bool unsetProcessingEvent(void) {isProcessingEvent_=false ;}
-         MPI_Comm getIntraComm(void) {return intraComm_ ;}
-         int getIntraCommRank(void) {return intraCommRank_;}
-         int getIntraCommSize(void) {return intraCommSize_;}
-
+         
          void addCouplingChanel(const std::string& contextId, bool out) ;
 
@@ -310 +301 @@
 
       private:
-        std::string defaultReaderId ;
-        std::string defaultWriterId ;
-        std::string defaultGathererId ;
+        std::string defaultPoolWriterId_ ;
+        std::string defaultPoolReaderId_ ;
+        std::string defaultPoolGathererId_ ;
+        std::string defaultWriterId_ ;
+        std::string defaultReaderId_ ;
+        std::string defaultGathererId_ ;
+        bool defaultUsingServer2_ ;
+        void setDefaultServices(void) ;
+
+
+        std::map<std::pair<string,string>,std::vector<pair<CContextClient*,CContextServer*>>> serversMap_ ;
 
         std::vector<CContextClient*> writerClientOut_ ;
@@ -342 +341 @@
         std::map<std::string, CContextServer*> couplerInServer_ ;
       public:
+         void createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer)  ;
+         void createServerInterComm(void)  ; // obsolete
+         void createServerInterComm_old(void)  ;
+         void createServerInterComm(const string& poolId, const string& serverId, vector<pair<string, pair<CContextClient*,CContextServer*>>>& clientServers ) ;
+         void getServerInterComm(const string& poolId, const string& serviceId,  vector<pair<CContextClient*,CContextServer*>>& clientServers) ;
+         vector<CContextClient*> getContextClient(const string& poolId, const string& serviceId) ;
          CContextClient* getCouplerInClient(const string& contextId) { return couplerInClient_[contextId] ;}
          CContextServer* getCouplerInServer(const string& contextId) { return couplerInServer_[contextId] ;}
          CContextClient* getCouplerOutClient(const string& contextId) { return couplerOutClient_[contextId] ;}
          CContextServer* getCouplerOutServer(const string& contextId) { return couplerOutServer_[contextId] ;}
-
-         CRegistry* registryIn=nullptr ;    //!< input registry which is read from file
-         CRegistry* registryOut=nullptr ;   //!< output registry which will be written into file at the finalize
+       
+       public: // must be privatize using accessors
+        
+        CRegistry* registryIn=nullptr ;    //!< input registry which is read from file
+        CRegistry* registryOut=nullptr ;   //!< output registry which will be written into file at the finalize
 
 
@@ -354 +361 @@
         int intraCommRank_ ; //! context intra communicator rank
         int intraCommSize_ ; //! context intra communicator size
-        
+       public: 
+        MPI_Comm getIntraComm(void) {return intraComm_ ;}
+        int getIntraCommRank(void) {return intraCommRank_;}
+        int getIntraCommSize(void) {return intraCommSize_;}
       private:
          shared_ptr<CEventScheduler> eventScheduler_ ; //! The local event scheduler for context

XIOS3/dev/XIOS_FILE_SERVICES/src/node/file.cpp

@@ -26 +26 @@
       : CObjectTemplate<CFile>(), CFileAttributes()
       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
-      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
+      , isOpen(false),  checkRead(false), allZoneEmpty(false)
    {
      setVirtualFieldGroup(CFieldGroup::create(getId() + "_virtual_field_group"));
@@ -35 +35 @@
       : CObjectTemplate<CFile>(id), CFileAttributes()
       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
-      , isOpen(false), read_client(0), checkRead(false), allZoneEmpty(false)
+      , isOpen(false), checkRead(false), allZoneEmpty(false)
     {
       setVirtualFieldGroup(CFieldGroup::create(getId() + "_virtual_field_group"));
@@ -1117 +1117 @@
    CATCH_DUMP_ATTR
 
+   void CFile::getWriterServicesId(bool defaultUsingServer2_, const string& defaultPoolWriterId_, const string& defaultWriterId_, const string& defaultPoolGathererId_, const string& defaultGathererId_,
+                                   bool& usingServer2, string& poolWriterId, string& writerId, string& poolGathererId, string& gathererId)
+   {
+     usingServer2 = defaultUsingServer2_ ;
+     poolWriterId = defaultPoolWriterId_ ;
+     writerId = defaultWriterId_ ;
+     poolGathererId = defaultPoolGathererId_ ;
+     gathererId = defaultGathererId_ ;
+
+     if (!using_server2.isEmpty()) usingServer2 = using_server2;
+     if (!pool_writer.isEmpty()) poolWriterId = pool_writer ;
+     if (!writer.isEmpty()) writerId = writer;
+     if (!pool_gatherer.isEmpty()) poolGathererId = pool_gatherer;
+     if (!gatherer.isEmpty()) gathererId = gatherer;
+   }
+
+   void CFile::getReaderServicesId(const string& defaultPoolReaderId_, const string& defaultReaderId_, string& poolReaderId, string& readerId)
+   {
+     poolReaderId = defaultPoolReaderId_ ;
+     readerId = defaultReaderId_ ;
+    
+     if (!pool_reader.isEmpty()) poolReaderId = pool_reader ;
+     if (!reader.isEmpty()) readerId = reader;
+   }
+
+   void CFile::setContextClient(const string& defaultPoolId, const string& defaultServiceId, int partitionId)
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     vector<CContextClient*> clients = context->getContextClient(defaultPoolId, defaultServiceId) ;
+     setContextClient(clients[partitionId]) ;
+   }
+   CATCH_DUMP_ATTR
+
+
    void CFile::setContextClient(CContextClient* newContextClient)
    TRY
@@ -1136 +1171 @@
    CATCH_DUMP_ATTR
 
-   void CFile::setReadContextClient(CContextClient* readContextclient)
-   TRY
-   {
-     read_client = readContextclient;
-   }
-   CATCH_DUMP_ATTR
-
-   CContextClient* CFile::getReadContextClient()
-   TRY
-   {
-     return read_client;
-   }
-   CATCH_DUMP_ATTR
-
+   
    /*!
    \brief Send a message to create a field on server side

XIOS3/dev/XIOS_FILE_SERVICES/src/node/file.hpp

@@ -128 +128 @@
          CVariable* addVariable(const string& id = "");
          CVariableGroup* addVariableGroup(const string& id = "");
+         
+         
+         void getWriterServicesId(bool defaultUsingServer2_, const string& defaultPoolWriterId_, const string& defaultWriterId_, const string& defaultPoolGathererId_, const string& defaultGathererId_,
+                                  bool& usingServer2, string& poolWriterId, string& writerId, string& poolGathererId, string& gathererId) ;
+         void getReaderServicesId(const string& defaultPoolReaderId_, const string& defaultReaderId_, string& poolReaderId, string& readerId) ;
+ 
+
+         void setContextClient(const string& defaultPoolId, const string& defaultServiceId, int partitionId) ;
          void setContextClient(CContextClient* newContextClient);
          CContextClient* getContextClient();
-
-         void setReadContextClient(CContextClient* newContextClient);
-         CContextClient* getReadContextClient();
 
          // Send info to server         
@@ -192 +197 @@
          /// Propriétés privées ///
          CContextClient* client;
-         CContextClient* read_client; // Context client for reading (channel between server 1 and client)
          CFieldGroup* vFieldGroup;
          CVariableGroup* vVariableGroup;

XIOS3/dev/XIOS_FILE_SERVICES/src/node/node_enum.hpp

@@ -44 +44 @@
          eExtractDomain,
          ePoolNode,gPoolNode,
+         eServiceNode,gServiceNode,
 //         eService, gService
        } ENodeType;

XIOS3/dev/XIOS_FILE_SERVICES/src/node/node_type.hpp

@@ -34 +34 @@
 #include "extract_domain.hpp"
 #include "pool_node.hpp"
+#include "service_node.hpp"
 
 

XIOS3/dev/XIOS_FILE_SERVICES/src/node/pool_node.cpp

@@ -1 +1 @@
 #include "pool_node.hpp"
+#include "cxios.hpp"
+#include<cmath>
 
 namespace xios
@@ -5 +7 @@
   
   CPoolNode::CPoolNode(void) : CObjectTemplate<CPoolNode>(), CPoolNodeAttributes()
-  { /* Ne rien faire de plus */ }
+  { 
+    setVirtualServiceNodeGroup(CServiceNodeGroup::create(getId() + "_virtual_service_node_group"));
+  }
 
   CPoolNode::CPoolNode(const StdString & id) : CObjectTemplate<CPoolNode>(id), CPoolNodeAttributes()
-  { /* Ne rien faire de plus */ }
+  { 
+    setVirtualServiceNodeGroup(CServiceNodeGroup::create(getId() + "_virtual_service_node_group"));
+  }
 
   CPoolNode::~CPoolNode(void)
@@ -17 +23 @@
   {
     SuperClass::parse(node);
+    if (node.goToChildElement())
+    {
+      do
+      {
+        if (node.getElementName()=="service" || node.getElementName()=="service_group") this->getVirtualServiceNodeGroup()->parseChild(node);
+      } while (node.goToNextElement());
+      node.goToParentElement();
+    }
   }
 
-
+  void CPoolNode::allocateRessources(void)
+  {
+    int nonEmpty=0 ;
+    if (!nprocs.isEmpty()) nonEmpty++ ;
+    if (!global_fraction.isEmpty()) nonEmpty++ ;
+    if (!remain_fraction.isEmpty()) nonEmpty++ ;
+    if (!remain.isEmpty()) nonEmpty++ ;
+    if (nonEmpty==0) ERROR("void CPoolNode::allocateRessources(void)",<<"A number a ressource for allocate pool must be specified." 
+                           <<"At least attributes, <nprocs> or <global_fraction> or <remain_fraction> or <remain> must be specified")
+    else if (nonEmpty>1) ERROR("void CPoolNode::allocateRessources(void)",<<"Only one of these attributes : <nprocs> or <global_fraction>"
+                               <<" or <remain_fraction> or <remain> must be specified to determine allocated ressouces."
+                               <<" More than one is currently specified")
+    auto ressourcesManager=CXios::getRessourcesManager() ;
+    int nbRessources ;
+    int globalRessources = ressourcesManager->getRessourcesSize() ;
+    int freeRessources =   ressourcesManager->getFreeRessourcesSize() ;
+    if (!nprocs.isEmpty()) nbRessources = nprocs ;
+    if (!global_fraction.isEmpty()) nbRessources = std::round(globalRessources * global_fraction) ;
+    if (!remain_fraction.isEmpty()) nbRessources = std::round(freeRessources * remain_fraction) ;
+    if (!remain.isEmpty()) nbRessources = freeRessources ;
+    if (nbRessources>freeRessources)
+      ERROR("void CPoolNode::allocateRessources(void)",<<"Cannot allocate required ressources for the pool."
+                                                       <<"  Required is : "<<nbRessources<<"  but free ressource is currently : "<<freeRessources)
+    string poolId ;
+    if (!name.isEmpty()) poolId=name ;
+    else if (!hasAutoGeneratedId() ) poolId=getId() ;
+    else ERROR("void CPoolNode::allocateRessources(void)",<<"Pool has no name or id, attributes <id> or <name> must be specified")
+    ressourcesManager->createPool(poolId, nbRessources) ;
+    ressourcesManager->waitPoolRegistration(poolId) ;
+    auto services=this->getAllServiceNodes() ;
+    for(auto& service : services) service->allocateRessources(poolId) ;
+  }
 }
 

XIOS3/dev/XIOS_FILE_SERVICES/src/node/pool_node.hpp

@@ -10 +10 @@
 #include "group_factory.hpp"
 #include "declare_group.hpp"
+#include "service_node.hpp"
 
 
@@ -58 +59 @@
     public:
       virtual void parse(xml::CXMLNode & node);
+      void allocateRessources(void) ;
+
+    private:
+      std::vector<CServiceNode*> getAllServiceNodes(void) const {return this->vServiceNodeGroup->getAllChildren();}
+      CServiceNodeGroup* getVirtualServiceNodeGroup(void) const {return this->vServiceNodeGroup; }
+      void setVirtualServiceNodeGroup(CServiceNodeGroup* newVServiceNodeGroup) { this->vServiceNodeGroup = newVServiceNodeGroup; }
+      CServiceNodeGroup* vServiceNodeGroup;
 
   }; // class CPoolNode