Changeset 286 for XMLIO_V2/dev/common/src/xmlio/manager

Timestamp:

10/21/11 19:01:35 (13 years ago)

Author:

ymipsl

Message:

reprise en main de la version de H. Ozdoba. Correction de différentes erreurs de conception et bug.
Version NEMO operationnel en client/server, interoperabilita avec OASIS, reconstition de fichiers via netcdf4/HDF5

YM

Location:

XMLIO_V2/dev/common/src/xmlio/manager

Files:

• mpi_manager.cpp (modified) (9 diffs)
• mpi_manager.hpp (modified) (7 diffs)
• tree_manager.cpp (modified) (9 diffs)
• xios_manager.cpp (modified) (14 diffs)
• xios_manager.hpp (modified) (4 diffs)

XMLIO_V2/dev/common/src/xmlio/manager/mpi_manager.cpp

@@ -12 +12 @@
  
 // XMLIOServer headers
+#include "xmlioserver.hpp"
 #include "mpi_manager.hpp"
+#include "oasis_cinterface.hpp"
 
 
@@ -21 +23 @@
 
    // ---------------------- Initialisation & Finalisation ---------------------
+
+   bool CMPIManager::Initialized=false ;
+   MPI_Comm CMPIManager::CommClient ;
+   MPI_Comm CMPIManager::CommServer ;
+   MPI_Comm CMPIManager::CommClientServer ;
+   int CMPIManager::NbClient ;
+   int CMPIManager::NbServer ;   
+   bool CMPIManager::_IsClient ;
+   bool CMPIManager::_IsServer ;   
+   bool CMPIManager::using_server ;
+   bool CMPIManager::using_oasis ;
+
 
    void CMPIManager::Initialise(int * _argc, char *** _argv)
@@ -31 +45 @@
          if (MPI_Init(_argc, _argv) != MPI_SUCCESS)
             ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
-      }
-
-   }
-   
+         Initialized=true ;
+      }
+
+   }
+   void CMPIManager::InitialiseClient(int * _argc, char *** _argv)
+   {
+      int flag = 0;
+      using_oasis=CObjectFactory::GetObject<CVariable>("xios","using_oasis")->getData<bool>() ; 
+      using_server=CObjectFactory::GetObject<CVariable>("xios","using_server")->getData<bool>(); 
+
+      Initialized=false ;
+
+      if (MPI_Initialized(&flag) != MPI_SUCCESS)
+         ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
+
+      if (!flag)
+      {
+         if (using_oasis) 
+         {
+           StdString oasisClientId=CObjectFactory::GetObject<CVariable>("xios","client_id")->getData<StdString>();
+           oasis_init(oasisClientId) ;
+         }
+         else
+         {        
+           if (MPI_Init(_argc, _argv) != MPI_SUCCESS)
+            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
+         }
+         Initialized=true ;
+       }
+
+   }
+   
+   void CMPIManager::InitialiseServer(int * _argc, char *** _argv)
+   {
+      int flag = 0;
+      
+      using_oasis=CObjectFactory::GetObject<CVariable>("xios","using_oasis")->getData<bool>(); 
+      using_server=CObjectFactory::GetObject<CVariable>("xios","using_server")->getData<bool>(); 
+   
+      if (using_oasis)
+      {
+         StdString oasisServerId=CObjectFactory::GetObject<CVariable>("xios","server_id")->getData<StdString>(); 
+         oasis_init(oasisServerId) ;
+      }
+      else
+      {
+         if (MPI_Init(_argc, _argv) != MPI_SUCCESS)
+            ERROR("CMPIManager::Initialise(arc, argv)", << " MPI Error !");
+      }
+      Initialized=true ;
+   }
+    
    void CMPIManager::Finalize(void)
    {
-      if (MPI_Finalize() != MPI_SUCCESS)
-         ERROR("CMPIManager::Finalize(void)", << " MPI Error !");
+      if (Initialized)
+      {
+        if (using_oasis) oasis_finalize() ;
+        else if (MPI_Finalize() != MPI_SUCCESS)
+                ERROR("CMPIManager::Finalize(void)", << " MPI Error !");
+      }
    }
    
@@ -86 +152 @@
                                     MPI_Comm   _comm_parent)
    {
+      if (_is_server) { _IsServer=true ; _IsClient=false ; }
+      else { _IsServer=false ; _IsClient=true; }
+
+      if (_is_server)
+      {
+        if (using_oasis)
+        {
+          StdString oasisClientId=CObjectFactory::GetObject<CVariable>("xios","client_id")->getData<StdString>() ;
+          oasis_get_intracomm(_comm_parent,oasisClientId) ;
+        }
+        else _comm_parent=MPI_COMM_WORLD ;
+      }
+      else
+      {
+        if (!using_server)
+        {
+          NbClient=GetCommSize(_comm_parent) ;
+          NbServer=0 ;
+          _comm_server = _comm_client = _comm_parent ;
+          CommClient=_comm_client ;
+          CommServer=_comm_server ;
+          CommClientServer=_comm_client_server ;
+           return false ;
+        }
+        if (using_oasis)  
+        {
+          StdString oasisServerId=CObjectFactory::GetObject<CVariable>("xios","server_id")->getData<StdString>() ;
+          oasis_get_intracomm(_comm_parent,oasisServerId) ;
+        }
+      }    
+      
+      
       int value = (_is_server) ? 1 : 2;
-      std::size_t nbClient = 0, nbServer = 0, nbClientByServer = 0;
+      std::size_t nbClient = 0, nbServer = 0 ;
+      std::vector<int> nbClientByServer ;
+      
       std::vector<int> info, rank_client, rank_server;
       CMPIManager::AllGather(value, info, _comm_parent);
@@ -99 +199 @@
       nbServer = rank_server.size();
       
+      NbClient=nbClient ;
+      NbServer=nbServer ;
+      
       if (nbClient == 0)
          ERROR("CMPIManager::DispatchClient()", << " Aucun client disponible !");
@@ -104 +207 @@
 
       _comm_client = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                     CMPIManager::GetGroupWorld(), rank_client), _comm_parent);
+                     CMPIManager::GetGroup(_comm_parent), rank_client), _comm_parent);
 
       if (nbServer != 0)
       {
          std::size_t currentServer = 0;
-         nbClientByServer = nbClient/nbServer;
+         
+//         nbClientByServer = nbClient/nbServer;
          _comm_server = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                        CMPIManager::GetGroupWorld(), rank_server), _comm_parent);
-
-         //std::cout << nbClient << "," << nbServer  << "," << nbClientByServer << std::endl;
-
-         for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer)
+                        CMPIManager::GetGroup(_comm_parent), rank_server), _comm_parent);
+
+         for(std::size_t mm=0;mm<nbServer;mm++) 
+         {
+           int x=nbClient/nbServer ;
+           if (mm<nbClient%nbServer) x++ ;
+           nbClientByServer.push_back(x) ;
+         }
+
+         for (std::size_t mm = 0; mm < nbClient; mm += nbClientByServer[currentServer],currentServer++ )
          {
             std::vector<int> group_rank;
-            group_rank.push_back(rank_server[currentServer++]);
-            for (std::size_t nn = 0; nn < nbClientByServer; nn++)
+            group_rank.push_back(rank_server[currentServer]);
+            for (std::size_t nn = 0; nn < nbClientByServer[currentServer]; nn++)
                group_rank.push_back(rank_client[nn+mm]);
             MPI_Comm comm_client_server_ = CMPIManager::CreateComm(CMPIManager::CreateSubGroup(
-                                           CMPIManager::GetGroupWorld(), group_rank), _comm_parent);
+                                           CMPIManager::GetGroup(_comm_parent), group_rank), _comm_parent);
 
             if (std::find(group_rank.begin(), group_rank.end(),
@@ -132 +241 @@
             group_rank.clear();
          }
+         CommClient=_comm_client ;
+         CommServer=_comm_server ;
+         CommClientServer=_comm_client_server ;
          return (true);
       }
@@ -137 +249 @@
       {
          _comm_server = _comm_client;
+         CommClient=_comm_client ;
+         CommServer=_comm_server ;
+         CommClientServer=_comm_client_server ;
          return (false);
       }
@@ -149 +264 @@
       if (MPI_Comm_group(MPI_COMM_WORLD, &group) != MPI_SUCCESS)
          ERROR("CMPIManager::GetGroupWorld()", << " MPI Error !");
+      return (group);
+   }
+
+   MPI_Group CMPIManager::GetGroup(MPI_Comm comm)
+   {
+      MPI_Group group = 0;
+      if (MPI_Comm_group(comm, &group) != MPI_SUCCESS)
+         ERROR("CMPIManager::GetGroup()", << " MPI Error !");
       return (group);
    }

XMLIO_V2/dev/common/src/xmlio/manager/mpi_manager.hpp

@@ -52 +52 @@
          
             static void Initialise(int * argc, char *** argv);
+            static void InitialiseClient(int * argc, char *** argv);
+            static void InitialiseServer(int * argc, char *** argv);
             static void Finalize(void);
 
@@ -57 +59 @@
          
          
-            static inline int GetCommRank(MPIComm _comm)            
-            { return (CMPIManager::GetCommRank(MPI_Comm_f2c(_comm))); }   
-                    
-            static inline int GetCommSize(MPIComm _comm)            
-            { return (CMPIManager::GetCommSize(MPI_Comm_f2c(_comm))); }
-            
-            static inline MPIComm GetCommWorld(void)            
-            { return (MPI_Comm_c2f(MPI_COMM_WORLD)); }
-            
-            static inline MPIComm CreateComm(MPI_Group _group, MPIComm _pcomm = CMPIManager::GetCommWorld())
-            { return (MPI_Comm_c2f(CMPIManager::CreateComm( _group, MPI_Comm_f2c(_pcomm)))); }     
+           
+            static inline MPI_Comm GetCommWorld(void)            
+            { return (MPI_COMM_WORLD); }
             
             static int GetCommRank(MPI_Comm _comm = MPI_COMM_WORLD);
             static int GetCommSize(MPI_Comm _comm = MPI_COMM_WORLD);       
             
-            static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm);
+            static MPI_Comm CreateComm(MPI_Group _group, MPI_Comm _pcomm=MPI_COMM_WORLD);
+
+            static inline MPI_Comm GetCommClient(void) 
+            { return CommClient; }   
+            static inline MPI_Comm GetCommServer(void) 
+            { return CommServer; }   
+            static inline MPI_Comm GetCommClientServer(void)             
+            { return CommClientServer; }   
+            static inline int GetNbClient(void)             
+            { return NbClient; }   
+            static inline int GetNbServer(void)             
+            { return NbServer; }   
+
+            static inline bool IsConnected(void)             
+            { return (NbServer==0)?true:false; }   
+
+            static inline bool IsClient(void)             
+            { return _IsClient; }   
+
+            static inline bool IsServer(void)             
+            { return _IsServer; }   
 
          public : // Autre
@@ -78 +92 @@
             static void Barrier(MPI_Comm _comm = MPI_COMM_WORLD);
             
-            static inline bool DispatchClient(bool       _is_server,
-                                              MPIComm & _comm_client,
-                                              MPIComm & _comm_client_server,
-                                              MPIComm & _comm_server,
-                                              MPIComm   _comm_parent =  CMPIManager::GetCommWorld())
-            {
-               MPI_Comm comm_client        = MPI_Comm_f2c(_comm_client);
-               MPI_Comm comm_client_server = MPI_Comm_f2c(_comm_client_server);
-               MPI_Comm comm_server        = MPI_Comm_f2c(_comm_server);
-               MPI_Comm comm_parent        = MPI_Comm_f2c(_comm_parent);
-               bool ret = CMPIManager::DispatchClient(_is_server, comm_client, comm_client_server, comm_server, comm_parent);
-               _comm_client        = MPI_Comm_c2f(comm_client);
-               _comm_client_server = MPI_Comm_c2f(comm_client_server);
-               _comm_server        = MPI_Comm_c2f(comm_server); 
-               return (ret);                          
-            }
-                                      
-            
             static bool DispatchClient(bool       _is_server,
                                        MPI_Comm & _comm_client,
                                        MPI_Comm & _comm_client_server,
                                        MPI_Comm & _comm_server,
-                                       MPI_Comm   _comm_parent = MPI_COMM_WORLD);
+                                       MPI_Comm _comm_parent);
 
          public : // Groupes
          
             static MPI_Group GetGroupWorld(void);
+            static MPI_Group GetGroup(MPI_Comm Comm);
             static MPI_Group CreateSubGroup(MPI_Group _pgroup, const std::vector<int> & _ranks);
             static MPI_Group CreateSubGroup(MPI_Group _pgroup, int _min_rank, int _max_rank, int _intval = 1);
@@ -110 +107 @@
          public : // Tests 
          
-            static inline bool IsMaster(MPIComm _comm)
-            { return (CMPIManager::IsMaster(MPI_Comm_f2c(_comm))); }
-            
-            static inline bool IsRank(int _rank, MPIComm _comm)
-            { return (CMPIManager::IsRank(_rank, MPI_Comm_f2c(_comm))); }
+       
          
             static bool IsMaster(MPI_Comm _comm = MPI_COMM_WORLD);
@@ -126 +119 @@
             static bool Test (MPI_Request & _request);
 
-
-            static inline bool HasReceivedData(MPIComm _comm, int _src_rank)
-            { return (CMPIManager::HasReceivedData(MPI_Comm_f2c(_comm), _src_rank));  }
-            
-            static inline std::size_t GetReceivedDataSize(MPIComm _comm, int _src_rank)
-            { return (CMPIManager::GetReceivedDataSize(MPI_Comm_f2c(_comm), _src_rank)); }
-            
-            
             
             static bool HasReceivedData(MPI_Comm _comm, int _src_rank);
             
             static std::size_t GetReceivedDataSize(MPI_Comm _comm, int _src_rank);
+
             static void Receive(MPI_Comm _comm, int _src_rank, char * _data);
             
@@ -150 +136 @@
          public : // Communication 'complexe'
          
-            static inline void SendLinearBuffer(MPIComm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request)
-            { CMPIManager::SendLinearBuffer(MPI_Comm_f2c(_comm), _dest_rank, _lbuffer, _request); }
-            
-            static inline void ReceiveLinearBuffer(MPIComm _comm, int _src_rank, CLinearBuffer & _lbuffer)
-            { CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank, _lbuffer); }
-            
-            static inline boost::shared_ptr<CLinearBuffer> ReceiveLinearBuffer(MPIComm _comm, int _src_rank)
-            { return (CMPIManager::ReceiveLinearBuffer(MPI_Comm_f2c(_comm), _src_rank)); }
-            
-            static inline void ReceiveCircularBuffer(MPIComm _comm, int _src_rank, CCircularBuffer & _cbuffer)
-            { CMPIManager::ReceiveCircularBuffer(MPI_Comm_f2c(_comm), _src_rank, _cbuffer); }
-            
-         
+
             static void SendLinearBuffer(MPI_Comm _comm, int _dest_rank, CLinearBuffer & _lbuffer, MPI_Request & _request);
             static void ReceiveLinearBuffer(MPI_Comm _comm, int _src_rank, CLinearBuffer & _lbuffer);
@@ -175 +149 @@
             static void FreeMemory (void * _data);
          
+          private :
+          
+            static bool Initialized ;
+            static MPI_Comm CommClient ;
+            static MPI_Comm CommServer ;
+            static MPI_Comm CommClientServer ;
+            static int NbClient ;
+            static int NbServer ;
+
+            static bool _IsClient ;
+            static bool _IsServer ;
+            static bool using_server ;
+            static bool using_oasis ;
+            
       }; // class CMPIManager
       

XMLIO_V2/dev/common/src/xmlio/manager/tree_manager.cpp

@@ -129 +129 @@
                   
                   
-//         std::cout << "Nombre de contexte :" << ctxtnb << std::endl;
 
          for (StdSize i = 0; i < ctxtnb; i++)
@@ -148 +147 @@
                is.read (const_cast<char *>(id.data()), size * sizeof(char));
                
-//               std::cout << "context ::::" << id << std::endl;
                
                CTreeManager::SetCurrentContextId(id);               
@@ -187 +185 @@
          os.write (reinterpret_cast<const char*>(&genum) , sizeof(ENodeType)); 
          os.write (reinterpret_cast<const char*>(&size) , sizeof(StdSize));
-         
+
          for (StdSize i = 0; i < size; i++)
          {
@@ -232 +230 @@
                      
                   os.write (reinterpret_cast<const char*>(&idsize), sizeof(StdSize));
-                  os.write (id.data(), idsize * sizeof(char));         
+                  os.write (id.data(), idsize * sizeof(char));  
                }         
                domain->toBinary(os);               
@@ -273 +271 @@
          const StdSize size = def_vector.size();  
                   
-         is.read (reinterpret_cast<char*>(&renum), sizeof(StdSize));   
-         is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(ENodeType));
+         is.read (reinterpret_cast<char*>(&renum), sizeof(ENodeType));   
+         is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(StdSize));
 
          if (renum != CContextGroup::GetType())
@@ -282 +280 @@
          if (size != ctxtnb)
             ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
-                  << "[ size = " << size << "] Bad context group size !");
+                  << "[ size = " << size << "] != "<<ctxtnb<<" : Bad context group size !");
                   
          for (StdSize i = 0; i < ctxtnb; i++)
@@ -330 +328 @@
                      
             // Lecture successive des informations binaires de domaine.
+              
             for (StdSize j = 0; j < alldomain_size; j++)
             {
@@ -352 +351 @@
                   if (domain->getId().compare(id) != 0)
                      ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
-                           << "[ id = " << id << "] Bad id !"); 
+                           << "[ id = " <<  id <<" != "<<domain->getId()<< "] Bad id !"); 
                }
                domain->fromBinary(is);
@@ -380 +379 @@
                   if (grid->getId().compare(id) != 0)
                      ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
-                           << "[ id = " << id << "] Bad id !"); 
+                           << "[ id = " << id <<" != "<<grid->getId()<< "] Bad id !"); 
                }
                grid->fromBinary(is);

XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.cpp

@@ -17 +17 @@
          {
             // Initialisation de la biliothÚque MPI si nécessaire
-            comm::CMPIManager::Initialise(argc, argv);
+            comm::CMPIManager::InitialiseServer(argc, argv);
             ExeName = StdString((*argv)[0]);
             for (int i = 1; i < *argc; i++)
@@ -43 +43 @@
 
       StdString     CXIOSManager::ClientName("unknown name");
-      comm::MPIComm CXIOSManager::Comm_Client_Server = -1;
-      comm::MPIComm CXIOSManager::Comm_Server = -1;
+      MPI_Comm CXIOSManager::Comm_Client_Server = MPI_COMM_NULL;
+      MPI_Comm CXIOSManager::Comm_Server = MPI_COMM_NULL;
 
       xios_map<StdString, CXIOSManager::XIOSClient> CXIOSManager::Clients;
@@ -51 +51 @@
       
       void CXIOSManager::RunServer
-         (StdString clientName, comm::MPIComm comm_client_server, comm::MPIComm comm_server)
+         (StdString clientName, MPI_Comm comm_client_server, MPI_Comm comm_server)
       {
          using namespace comm;
@@ -69 +69 @@
          // La quasi-totalité de l'arborescence est obtenue depuis les informations
          // fournies par le client 1 du sous-groupe.
-         StdString main_data_tree = clientBuffer[0]->getString(0);        
+/*         StdString main_data_tree = clientBuffer[0]->getString(0);        
          tree::CTreeManager::FromBinary(main_data_tree);
          
@@ -78 +78 @@
             tree::CTreeManager::DomainsFromBinary(main_data_tree);
          }
+*/
+
+         // Obtention des sous-domaines clients.
+         for (StdSize j = 0; j < clientBuffer.size(); j++)
+         {
+             StdString main_data_tree = clientBuffer[j]->getString(0);
+            tree::CTreeManager::FromBinary(main_data_tree);
+         }
+
          
          StdOStringStream osss;
@@ -111 +120 @@
       //--------------------------------------------------------------
       
-      void CXIOSManager::ShowInformation_CS(comm::MPIComm comm_client_server)
+      void CXIOSManager::ShowInformation_CS(MPI_Comm comm_client_server)
       {
          using namespace comm;
@@ -149 +158 @@
          }
 
-         comm::CMPIManager::Barrier();
+         comm::CMPIManager::Barrier(comm_client_server);
          
       }
@@ -155 +164 @@
       //--------------------------------------------------------------
       
-      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server)
+      void CXIOSManager::RunClientServer(MPI_Comm comm_client_server)
       {
          using namespace comm;
@@ -171 +180 @@
          
          bool isClient = true, isIncl = false, isIncl_ = false;
-         MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0;
+         MPI_Comm comm_client = 0, comm_client_grp = 0; comm_client_server = 0;
 
          for (;iit != eend; iit++)
@@ -187 +196 @@
             {
                end = start + nbClientPServer;
-               MPIComm comm_  =  CMPIManager::CreateComm
+               MPI_Comm comm_  =  CMPIManager::CreateComm
                   (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start, end));
-               MPIComm comm__ =  CMPIManager::CreateComm
+               MPI_Comm comm__ =  CMPIManager::CreateComm
                   (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), start+1, end));
                   
@@ -212 +221 @@
                if (clieindex.size() == nbClient)
                {
-                  MPIComm comm___ = CMPIManager::CreateComm
+                  MPI_Comm comm___ = CMPIManager::CreateComm
                   (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), clieindex));
                   if (isIncl) comm_client = comm___;
@@ -221 +230 @@
                start = start + nbClientPServer + 1;
             }
-            MPIComm comm____ = CMPIManager::CreateComm
+            MPI_Comm comm____ = CMPIManager::CreateComm
                (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), servindex));
             if (isIncl_) CXIOSManager::Comm_Server = comm____;               
@@ -245 +254 @@
       //---------------------------------------------------------------
       
-      void CXIOSManager::RunClient(bool launch, comm::MPIComm comm_client)
+      void CXIOSManager::RunClient(bool launch, MPI_Comm comm_client)
       {
          if (launch)
@@ -263 +272 @@
 
       void CXIOSManager::AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer,
-                                   void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm))
+                                   void (*entry_point)(MPI_Comm, MPI_Comm, MPI_Comm))
       {
          StdSize nbprocess  = comm::CMPIManager::GetCommSize(comm::CMPIManager::GetCommWorld());

XMLIO_V2/dev/common/src/xmlio/manager/xios_manager.hpp

@@ -25 +25 @@
             StdSize nbClient;
             StdSize nbClientPServer;
-            void (*entry)(comm::MPIComm, comm::MPIComm, comm::MPIComm) ;
+            void (*entry)(MPI_Comm, MPI_Comm, MPI_Comm) ;
          } XIOSClient;
          
@@ -38 +38 @@
          /// Ajout de client en mode CLIENT_SERVER et CLIENT///
          static void AddClient(StdString clientName, StdSize nbClient, StdSize nbClientPServer,
-                               void (*entry_point)(comm::MPIComm, comm::MPIComm, comm::MPIComm));
+                               void (*entry_point)(MPI_Comm, MPI_Comm, MPI_Comm));
 
          /// Lancement des serveurs et/ou des clients ///
-         static void RunServer(StdString clientName,
-                               comm::MPIComm comm_client_server, comm::MPIComm comm_server);
-         static void RunClient(bool launch = false, comm::MPIComm comm_client =
-                                                    comm::CMPIManager::GetCommWorld());
-         static void RunClientServer(comm::MPIComm comm_client_server =
-                                     comm::CMPIManager::GetCommWorld());
+         static void RunServer(StdString clientName,MPI_Comm comm_client_server,MPI_Comm comm_server);
+         static void RunClient(bool launch = false, MPI_Comm comm_client = comm::CMPIManager::GetCommWorld());
+         static void RunClientServer(MPI_Comm comm_client_server = comm::CMPIManager::GetCommWorld());
 
       public :
@@ -66 +63 @@
       
          /// Information ///
-         static void ShowInformation_CS(comm::MPIComm comm_client_server);
+         static void ShowInformation_CS(MPI_Comm comm_client_server);
 
          /// Variables statiques privées ///
@@ -75 +72 @@
          static XIOSStatus Status;
          static StdString  ClientName;
-         static comm::MPIComm Comm_Client_Server, Comm_Server;
+         static MPI_Comm Comm_Client_Server, Comm_Server;
          static xios_map<StdString, XIOSClient> Clients;