Index: XIOS3/trunk/src/client.cpp
===================================================================
--- XIOS3/trunk/src/client.cpp	(revision 2588)
+++ XIOS3/trunk/src/client.cpp	(revision 2589)
@@ -105,5 +105,5 @@
           delete[] hashAll ;
 
-          MPI_Comm_split(globalComm, color, commRank, &clientComm) ;
+          xios::MPI_Comm_split(globalComm, color, commRank, &clientComm) ;
           CXios::getMpiGarbageCollector().registerCommunicator(clientComm) ;
         }
@@ -115,7 +115,7 @@
       else // localComm is given
       {
-        MPI_Comm_dup(localComm,&clientComm) ;
+        xios::MPI_Comm_dup(localComm,&clientComm) ;
         CXios::getMpiGarbageCollector().registerCommunicator(clientComm) ;
-        MPI_Comm_dup(localComm,&intraComm_) ;
+        xios::MPI_Comm_dup(localComm,&intraComm_) ;
         CXios::getMpiGarbageCollector().registerCommunicator(intraComm_) ;
 
@@ -145,5 +145,5 @@
          MPI_Comm splitComm,interComm ;
          MPI_Comm_rank(globalComm,&commGlobalRank) ;
-         MPI_Comm_split(globalComm, 0, commGlobalRank, &splitComm) ;
+         xios::MPI_Comm_split(globalComm, 0, commGlobalRank, &splitComm) ;
          int splitCommSize, globalCommSize ;
         
@@ -152,5 +152,5 @@
          if (splitCommSize==globalCommSize) // no server
          {
-           MPI_Comm_dup(globalComm,&xiosGlobalComm) ;
+           xios::MPI_Comm_dup(globalComm,&xiosGlobalComm) ;
            CXios::setXiosComm(xiosGlobalComm) ;
          }
@@ -163,6 +163,6 @@
            MPI_Allreduce(&clientLeader,&clientRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ;
            MPI_Allreduce(&serverLeader,&serverRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ;
-           MPI_Intercomm_create(splitComm, 0, globalComm, serverRemoteLeader,1341,&interComm) ;
-           MPI_Intercomm_merge(interComm,true,&xiosGlobalComm) ;
+           xios::MPI_Intercomm_create(splitComm, 0, globalComm, serverRemoteLeader,1341,&interComm) ;
+           xios::MPI_Intercomm_merge(interComm,true,&xiosGlobalComm) ;
            CXios::setXiosComm(xiosGlobalComm) ;
          }
@@ -177,5 +177,5 @@
       int commRank ;
       MPI_Comm_rank(CXios::getXiosComm(), &commRank) ;
-      MPI_Comm_split(CXios::getXiosComm(),false,commRank, &clientsComm_) ;
+      xios::MPI_Comm_split(CXios::getXiosComm(),false,commRank, &clientsComm_) ;
       CXios::getMpiGarbageCollector().registerCommunicator(clientsComm_) ;
       
@@ -271,5 +271,5 @@
       {
         MPI_Comm intraComm ;
-        MPI_Comm_dup(clientComm,&intraComm) ;
+        xios::MPI_Comm_dup(clientComm,&intraComm) ;
         MPI_Comm interComm ;
         
@@ -280,8 +280,8 @@
         for(int i=pos ; i<clientsCodeId.size(); i++)
         {  
-          MPI_Intercomm_create(intraComm, 0, globalComm, serverRank, 3141, &interComm);
+          xios::MPI_Intercomm_create(intraComm, 0, globalComm, serverRank, 3141, &interComm);
           CXios::getMpiGarbageCollector().registerCommunicator(interComm) ;
-          MPI_Comm_free(&intraComm) ;
-          MPI_Intercomm_merge(interComm,high, &intraComm ) ;
+          xios::MPI_Comm_free(&intraComm) ;
+          xios::MPI_Intercomm_merge(interComm,high, &intraComm ) ;
           high=false ;
           if (i==pos) {
@@ -313,5 +313,5 @@
         int client ;
         MPI_Comm intraComm ;
-        MPI_Comm_dup(clientComm,&intraComm) ;
+        xios::MPI_Comm_dup(clientComm,&intraComm) ;
         MPI_Comm interComm ;
         
@@ -324,11 +324,11 @@
           if (codeId==clientsCodeId[0])   // first model play the server rule
           {          
-            MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm);
-            MPI_Intercomm_merge(interComm,false, &intraComm ) ;
+            xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm);
+            xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ;
           }
           else
           {          
-            MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[0], 3141, &interComm);
-            MPI_Intercomm_merge(interComm,high, &intraComm ) ;
+            xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[0], 3141, &interComm);
+            xios::MPI_Intercomm_merge(interComm,high, &intraComm ) ;
             high=false ;
           }
@@ -381,5 +381,5 @@
           {  
             MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm);
-            MPI_Intercomm_merge(interComm, true, &intraComm ) ;
+            xios::MPI_Intercomm_merge(interComm, true, &intraComm ) ;
           }
           xiosGlobalComm=intraComm ;
@@ -401,5 +401,5 @@
             {  
               MPI_Comm_accept(portName, MPI_INFO_NULL, 0, intraComm, &interComm);
-              MPI_Intercomm_merge(interComm,false, &intraComm ) ;
+              xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ;
             }
           }
@@ -423,5 +423,5 @@
               {  
                 MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm);
-                MPI_Intercomm_merge(interComm, true, &intraComm ) ;
+                xios::MPI_Intercomm_merge(interComm, true, &intraComm ) ;
               }
               xiosGlobalComm=intraComm ;
@@ -523,5 +523,5 @@
       CXios::getMpiGarbageCollector().release() ; // release unfree MPI ressources
       MPI_Comm xiosComm=CXios::getXiosComm() ;
-      MPI_Comm_free(&xiosComm) ;
+      xios::MPI_Comm_free(&xiosComm) ;
       CCommTrack::dumpComm() ;
       if (!is_MPI_Initialized)
Index: XIOS3/trunk/src/distribution/grid_remote_connector.cpp
===================================================================
--- XIOS3/trunk/src/distribution/grid_remote_connector.cpp	(revision 2588)
+++ XIOS3/trunk/src/distribution/grid_remote_connector.cpp	(revision 2589)
@@ -609,5 +609,5 @@
     if (commRank==0) color=1 ;
     MPI_Comm newComm ;
-    MPI_Comm_split(localComm_, color, commRank, &newComm) ;
+    xios::MPI_Comm_split(localComm_, color, commRank, &newComm) ;
     if (color==1)
     {
@@ -620,5 +620,5 @@
       MPI_Bcast(indGlo.data(),dataSize,MPI_SIZE_T,0,newComm) ;
     }
-    MPI_Comm_free(&newComm) ;
+    xios::MPI_Comm_free(&newComm) ;
 
     // construct element_[i] from indGlo
Index: XIOS3/trunk/src/event_scheduler.cpp
===================================================================
--- XIOS3/trunk/src/event_scheduler.cpp	(revision 2588)
+++ XIOS3/trunk/src/event_scheduler.cpp	(revision 2589)
@@ -27,5 +27,5 @@
   void CEventScheduler::initialize(const MPI_Comm& comm) 
   {
-    MPI_Comm_dup(comm, &communicator_) ;
+    xios::MPI_Comm_dup(comm, &communicator_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(communicator_) ;
     MPI_Comm_size(communicator_,&mpiSize_) ;
@@ -123,5 +123,5 @@
     if (child->isRoot()) color=1 ;
     else color=0 ;
-    MPI_Comm_split(communicator_, color, mpiRank_, &newComm) ;
+    xios::MPI_Comm_split(communicator_, color, mpiRank_, &newComm) ;
     CXios::getMpiGarbageCollector().registerCommunicator(newComm) ;
 
Index: XIOS3/trunk/src/manager/daemons_manager.cpp
===================================================================
--- XIOS3/trunk/src/manager/daemons_manager.cpp	(revision 2588)
+++ XIOS3/trunk/src/manager/daemons_manager.cpp	(revision 2589)
@@ -17,5 +17,5 @@
     MPI_Comm_rank(xiosComm,&commRank) ;
     MPI_Comm splitComm ;
-    MPI_Comm_split(xiosComm,isXiosServer,commRank,&splitComm) ;
+    xios::MPI_Comm_split(xiosComm,isXiosServer,commRank,&splitComm) ;
     
     CXios::launchRegistryManager(isXiosServer) ;
@@ -28,5 +28,5 @@
     if (isXiosServer) CServer::launchServersRessource(splitComm) ;
     MPI_Barrier(xiosComm) ;
-    MPI_Comm_free(&splitComm) ;
+    xios::MPI_Comm_free(&splitComm) ;
   }
 
Index: XIOS3/trunk/src/manager/pool_ressource.cpp
===================================================================
--- XIOS3/trunk/src/manager/pool_ressource.cpp	(revision 2588)
+++ XIOS3/trunk/src/manager/pool_ressource.cpp	(revision 2589)
@@ -15,5 +15,5 @@
   {
     int commRank, commSize ;
-    MPI_Comm_dup(poolComm, &poolComm_) ;
+    xios::MPI_Comm_dup(poolComm, &poolComm_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(poolComm_) ;
     winNotify_ = new CWindowManager(poolComm_, maxBufferSize_,"CPoolRessource::winNotify_") ;
@@ -336,10 +336,10 @@
     else color=1 ; 
     MPI_Comm_rank(poolComm_,&commRank) ;
-    MPI_Comm_split(poolComm_, color, commRank, &freeComm) ;  // workaround
+    xios::MPI_Comm_split(poolComm_, color, commRank, &freeComm) ;  // workaround
     
     if (services_.empty()) 
     {
       MPI_Comm_rank(freeComm,&commRank) ;
-      MPI_Comm_split(freeComm, in, commRank, &serviceComm) ;
+      xios::MPI_Comm_split(freeComm, in, commRank, &serviceComm) ;
 
       // temporary for event scheduler, we must using hierarchical split of free ressources communicator.
@@ -364,5 +364,5 @@
         else  partitionId = serviceCommRank / (serviceCommSize/nbPartitions + 1) ;
 
-        MPI_Comm_split(serviceComm, partitionId, commRank, &newServiceComm) ;
+        xios::MPI_Comm_split(serviceComm, partitionId, commRank, &newServiceComm) ;
 
         MPI_Comm_size(newServiceComm,&serviceCommSize) ;
@@ -378,5 +378,5 @@
         services_[std::make_tuple(serviceId,partitionId)] = new CService(newServiceComm, childScheduler, Id_, serviceId, partitionId, type, nbPartitions) ;
        
-        MPI_Comm_free(&newServiceComm) ;
+        xios::MPI_Comm_free(&newServiceComm) ;
       }
       else
@@ -388,7 +388,7 @@
         isFirstSplit_=false ;
       }
-      MPI_Comm_free(&serviceComm) ;
-    }
-    MPI_Comm_free(&freeComm) ;
+      xios::MPI_Comm_free(&serviceComm) ;
+    }
+    xios::MPI_Comm_free(&freeComm) ;
   }
   
@@ -404,5 +404,5 @@
         const MPI_Comm& serviceComm = service.second->getCommunicator() ;
         MPI_Comm newServiceComm ;
-        MPI_Comm_dup(serviceComm, &newServiceComm) ;
+        xios::MPI_Comm_dup(serviceComm, &newServiceComm) ;
         CXios::getMpiGarbageCollector().registerCommunicator(newServiceComm) ;
         int nbPartitions = service.second->getNbPartitions() ;
Index: XIOS3/trunk/src/manager/server_context.cpp
===================================================================
--- XIOS3/trunk/src/manager/server_context.cpp	(revision 2588)
+++ XIOS3/trunk/src/manager/server_context.cpp	(revision 2589)
@@ -23,5 +23,5 @@
    int localRank, globalRank, commSize ;
 
-    MPI_Comm_dup(contextComm, &contextComm_) ;
+    xios::MPI_Comm_dup(contextComm, &contextComm_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(contextComm_) ;
     xiosComm_=CXios::getXiosComm() ;
@@ -104,6 +104,6 @@
     {
       MPI_Comm newInterCommClient, newInterCommServer ;
-      MPI_Comm_dup(contextComm_,&newInterCommClient) ;
-      MPI_Comm_dup(contextComm_,&newInterCommServer) ;
+      xios::MPI_Comm_dup(contextComm_,&newInterCommClient) ;
+      xios::MPI_Comm_dup(contextComm_,&newInterCommServer) ;
       overlapedComm_[name_]=tuple<bool, MPI_Comm, MPI_Comm>(false, newInterCommClient, newInterCommServer) ;
       MPI_Barrier(contextComm_) ;
@@ -129,10 +129,10 @@
       if (nOverlap==0)
       { 
-        MPI_Intercomm_create(intraComm, 0, xiosComm_, contextLeader, 3141, &interCommClient) ;
+        xios::MPI_Intercomm_create(intraComm, 0, xiosComm_, contextLeader, 3141, &interCommClient) ;
         CXios::getMpiGarbageCollector().registerCommunicator(interCommClient) ;
-        MPI_Comm_dup(interCommClient, &interCommServer) ;
+        xios::MPI_Comm_dup(interCommClient, &interCommServer) ;
         CXios::getMpiGarbageCollector().registerCommunicator(interCommServer) ;
-        MPI_Comm_free(&newInterCommClient) ;
-        MPI_Comm_free(&newInterCommServer) ;
+        xios::MPI_Comm_free(&newInterCommClient) ;
+        xios::MPI_Comm_free(&newInterCommServer) ;
       }
       else
@@ -320,7 +320,7 @@
     { 
       info(10)<<"CServerContext::createIntercomm : No overlap ==> context in server mode"<<endl ;
-      MPI_Intercomm_create(contextComm_, 0, xiosComm_, remoteLeader, 3141, &interCommServer) ;
+      xios::MPI_Intercomm_create(contextComm_, 0, xiosComm_, remoteLeader, 3141, &interCommServer) ;
       CXios::getMpiGarbageCollector().registerCommunicator(interCommServer) ;
-      MPI_Comm_dup(interCommServer,&interCommClient) ;
+      xios::MPI_Comm_dup(interCommServer,&interCommClient) ;
       CXios::getMpiGarbageCollector().registerCommunicator(interCommClient) ;
       context_ -> createClientInterComm(interCommClient,interCommServer) ;
@@ -339,5 +339,5 @@
     //delete winNotify_ ;
     //winNotify_=nullptr ;
-    //MPI_Comm_free(&contextComm_) ;
+    //xios::MPI_Comm_free(&contextComm_) ;
     // don't forget intercomm -> later
   }
Index: XIOS3/trunk/src/manager/servers_ressource.cpp
===================================================================
--- XIOS3/trunk/src/manager/servers_ressource.cpp	(revision 2588)
+++ XIOS3/trunk/src/manager/servers_ressource.cpp	(revision 2589)
@@ -22,5 +22,5 @@
   {
 
-    MPI_Comm_dup(serverComm, &serverComm_) ;
+    xios::MPI_Comm_dup(serverComm, &serverComm_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(serverComm_) ; 
     MPI_Comm xiosComm=CXios::getXiosComm() ;
@@ -42,5 +42,5 @@
     }
 
-    MPI_Comm_dup(serverComm_, &freeRessourcesComm_) ; 
+    xios::MPI_Comm_dup(serverComm_, &freeRessourcesComm_) ; 
     CXios::getMpiGarbageCollector().registerCommunicator(freeRessourcesComm_) ;
     eventScheduler_ = make_shared<CEventScheduler>(freeRessourcesComm_) ;
@@ -225,5 +225,5 @@
     MPI_Comm poolComm ;
     MPI_Comm_rank(freeRessourcesComm_,&commRank) ;
-    MPI_Comm_split(freeRessourcesComm_, isPartOf, commRank, &poolComm) ;
+    xios::MPI_Comm_split(freeRessourcesComm_, isPartOf, commRank, &poolComm) ;
     
     shared_ptr<CEventScheduler> parentScheduler, childScheduler ;
@@ -236,10 +236,10 @@
     {  
       poolRessource_ = new CPoolRessource(poolComm, childScheduler, poolId, true) ;
-      MPI_Comm_free(&poolComm) ;
+      xios::MPI_Comm_free(&poolComm) ;
     }
     else 
     {
       freeRessourceEventScheduler_ = childScheduler ;
-      MPI_Comm_free(&freeRessourcesComm_) ;
+      xios::MPI_Comm_free(&freeRessourcesComm_) ;
       freeRessourcesComm_=poolComm ;
     }
Index: XIOS3/trunk/src/manager/services.cpp
===================================================================
--- XIOS3/trunk/src/manager/services.cpp	(revision 2588)
+++ XIOS3/trunk/src/manager/services.cpp	(revision 2589)
@@ -21,5 +21,5 @@
     int localRank, globalRank, commSize ;
 
-    MPI_Comm_dup(serviceComm, &serviceComm_) ;
+    xios::MPI_Comm_dup(serviceComm, &serviceComm_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(serviceComm_) ;
     MPI_Comm globalComm_=CXios::getXiosComm() ;
Index: XIOS3/trunk/src/mpi_garbage_collector.hpp
===================================================================
--- XIOS3/trunk/src/mpi_garbage_collector.hpp	(revision 2588)
+++ XIOS3/trunk/src/mpi_garbage_collector.hpp	(revision 2589)
@@ -28,5 +28,5 @@
       {
         for( auto& it : stack_) 
-          if (it.type==SType::COMM) MPI_Comm_free(&it.comm);
+          if (it.type==SType::COMM) xios::MPI_Comm_free(&it.comm);
           else if (it.type==SType::WIN) MPI_Win_free(&it.win);
         stack_.clear();
Index: XIOS3/trunk/src/node/context.cpp
===================================================================
--- XIOS3/trunk/src/node/context.cpp	(revision 2588)
+++ XIOS3/trunk/src/node/context.cpp	(revision 2589)
@@ -541,5 +541,5 @@
   {
     MPI_Comm intraCommClient ;
-    MPI_Comm_dup(intraComm_, &intraCommClient);
+    xios::MPI_Comm_dup(intraComm_, &intraCommClient);
     comms.push_back(intraCommClient);
 
@@ -598,5 +598,5 @@
 
       intraCommClient=intraComm_ ;
-      MPI_Comm_dup(intraComm_, &intraCommServer) ;
+      xios::MPI_Comm_dup(intraComm_, &intraCommServer) ;
       CXios::getMpiGarbageCollector().registerCommunicator(intraCommServer) ;
 
@@ -806,15 +806,15 @@
          MPI_Comm intraCommClient, intraCommServer ;
 
-         MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
-
-        MPI_Comm_dup(intraComm_, &intraCommClient) ;
-        MPI_Comm_dup(intraComm_, &intraCommServer) ;
-        MPI_Comm_dup(interComm, &interCommClient) ;
-        MPI_Comm_dup(interComm, &interCommServer) ;
+         xios::MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
+
+        xios::MPI_Comm_dup(intraComm_, &intraCommClient) ;
+        xios::MPI_Comm_dup(intraComm_, &intraCommServer) ;
+        xios::MPI_Comm_dup(interComm, &interCommClient) ;
+        xios::MPI_Comm_dup(interComm, &interCommServer) ;
         CContextClient* client = CContextClient::getNew(this, intraCommClient, interCommClient);
         CContextServer* server = CContextServer::getNew(this, intraCommServer, interCommServer);
         client->setAssociatedServer(server) ;
         server->setAssociatedClient(client) ;
-        MPI_Comm_free(&interComm) ;
+        xios::MPI_Comm_free(&interComm) ;
         couplerOutClient_[fullContextId] = client ;
         couplerOutServer_[fullContextId] = server ;
@@ -829,15 +829,15 @@
        MPI_Comm intraCommClient, intraCommServer ;
 
-       MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
-
-       MPI_Comm_dup(intraComm_, &intraCommClient) ;
-       MPI_Comm_dup(intraComm_, &intraCommServer) ;
-       MPI_Comm_dup(interComm, &interCommServer) ;
-       MPI_Comm_dup(interComm, &interCommClient) ;
+       xios::MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
+
+       xios::MPI_Comm_dup(intraComm_, &intraCommClient) ;
+       xios::MPI_Comm_dup(intraComm_, &intraCommServer) ;
+       xios::MPI_Comm_dup(interComm, &interCommServer) ;
+       xios::MPI_Comm_dup(interComm, &interCommClient) ;
        CContextServer* server = CContextServer::getNew(this, intraCommServer, interCommServer);
        CContextClient* client = CContextClient::getNew(this, intraCommClient, interCommClient);
        client->setAssociatedServer(server) ;
        server->setAssociatedClient(client) ;
-       MPI_Comm_free(&interComm) ;
+       xios::MPI_Comm_free(&interComm) ;
 
        couplerInClient_[fullContextId] = client ;
@@ -1001,5 +1001,5 @@
    {
      for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
-       MPI_Comm_free(&(*it));
+       xios::MPI_Comm_free(&(*it));
      comms.clear();
    }
Index: XIOS3/trunk/src/node/file.cpp
===================================================================
--- XIOS3/trunk/src/node/file.cpp	(revision 2588)
+++ XIOS3/trunk/src/node/file.cpp	(revision 2589)
@@ -272,5 +272,5 @@
       {
         // NetCDF runs now write of null data
-        MPI_Comm_dup(context->intraComm_, &fileComm) ;
+        xios::MPI_Comm_dup(context->intraComm_, &fileComm) ;
       }
 
@@ -287,5 +287,5 @@
       //createSubComFile();
       allZoneEmpty = false; 
-      MPI_Comm_dup(context->intraComm_, &fileComm) ;
+      xios::MPI_Comm_dup(context->intraComm_, &fileComm) ;
       checkRead = true;
     }
@@ -312,6 +312,6 @@
 
       int color = allZoneEmpty ? 0 : 1;
-      MPI_Comm_split(context->intraComm_, color, context->intraCommRank_, &fileComm);
-      if (allZoneEmpty) MPI_Comm_free(&fileComm);
+      xios::MPI_Comm_split(context->intraComm_, color, context->intraCommRank_, &fileComm);
+      if (allZoneEmpty) xios::MPI_Comm_free(&fileComm);
     }
     CATCH_DUMP_ATTR
@@ -725,5 +725,5 @@
         isOpen = false;
        }
-      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm);
+      if (fileComm != MPI_COMM_NULL) xios::MPI_Comm_free(&fileComm);
    }
    CATCH_DUMP_ATTR
Index: XIOS3/trunk/src/policy.cpp
===================================================================
--- XIOS3/trunk/src/policy.cpp	(revision 2588)
+++ XIOS3/trunk/src/policy.cpp	(revision 2589)
@@ -44,5 +44,5 @@
 //   int color = clientRank % 2;
 //   commLevel_.push_back(MPI_Comm());
-//   MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back()));
+//   xios::MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back()));
 //   divideMPICommLevel(commLevel_.back(), level);
 //  }
@@ -160,5 +160,5 @@
 //   int color = clientRank % 2;
 //   commLevel_.push_back(MPI_Comm());
-//   MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back()));
+//   xios::MPI_Comm_split(mpiCommLevel, color, 0, &(commLevel_.back()));
 //   divideMPICommLevel(commLevel_.back(), level);
 //  }
Index: XIOS3/trunk/src/registry.cpp
===================================================================
--- XIOS3/trunk/src/registry.cpp	(revision 2588)
+++ XIOS3/trunk/src/registry.cpp	(revision 2589)
@@ -265,7 +265,7 @@
     if (rank==0) color=1 ;
     MPI_Comm newComm ;
-    MPI_Comm_split(communicator,color,rank,&newComm) ;
+    xios::MPI_Comm_split(communicator,color,rank,&newComm) ;
     if (color==1) hierarchicalGatherRegistry(newComm) ;
-    MPI_Comm_free(&newComm) ;    
+    xios::MPI_Comm_free(&newComm) ;    
   }
 
@@ -282,7 +282,7 @@
       else color=1 ;
       MPI_Comm commUp ;
-      MPI_Comm_split(comm,color,mpiRank,&commUp) ,
+      xios::MPI_Comm_split(comm,color,mpiRank,&commUp) ,
       hierarchicalGatherRegistry(commUp) ;
-      MPI_Comm_free(&commUp) ;
+      xios::MPI_Comm_free(&commUp) ;
     }
 
@@ -294,7 +294,7 @@
       if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ;
       else color=1 ;
-      MPI_Comm_split(comm,color,mpiRank,&commDown) ;
+      xios::MPI_Comm_split(comm,color,mpiRank,&commDown) ;
       if (color==0) gatherRegistry(commDown) ;
-      MPI_Comm_free(&commDown) ;    
+      xios::MPI_Comm_free(&commDown) ;    
     }
   }
Index: XIOS3/trunk/src/server.cpp
===================================================================
--- XIOS3/trunk/src/server.cpp	(revision 2588)
+++ XIOS3/trunk/src/server.cpp	(revision 2589)
@@ -101,5 +101,5 @@
         delete[] hashAll ;
 
-        MPI_Comm_split(globalComm, color, commRank, &serverComm) ;
+        xios::MPI_Comm_split(globalComm, color, commRank, &serverComm) ;
         CXios::getMpiGarbageCollector().registerCommunicator(serverComm) ;
 
@@ -119,5 +119,5 @@
         driver_->getComponentCommunicator( serverComm );
       }
-      MPI_Comm_dup(serverComm, &intraComm_);
+      xios::MPI_Comm_dup(serverComm, &intraComm_);
       CXios::getMpiGarbageCollector().registerCommunicator(intraComm_) ;
       
@@ -142,5 +142,5 @@
         MPI_Comm splitComm,interComm ;
         MPI_Comm_rank(globalComm,&commGlobalRank) ;
-        MPI_Comm_split(globalComm, 1, commGlobalRank, &splitComm) ;
+        xios::MPI_Comm_split(globalComm, 1, commGlobalRank, &splitComm) ;
         MPI_Comm_rank(splitComm,&commRank) ;
         if (commRank==0) serverLeader=commGlobalRank ;
@@ -149,6 +149,6 @@
         MPI_Allreduce(&clientLeader,&clientRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ;
         MPI_Allreduce(&serverLeader,&serverRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ;
-        MPI_Intercomm_create(splitComm, 0, globalComm, clientRemoteLeader,1341,&interComm) ;
-        MPI_Intercomm_merge(interComm,false,&xiosGlobalComm) ;
+        xios::MPI_Intercomm_create(splitComm, 0, globalComm, clientRemoteLeader,1341,&interComm) ;
+        xios::MPI_Intercomm_merge(interComm,false,&xiosGlobalComm) ;
         CXios::setXiosComm(xiosGlobalComm) ;
       }
@@ -167,5 +167,5 @@
       int commRank ;
       MPI_Comm_rank(CXios::getXiosComm(), &commRank) ;
-      MPI_Comm_split(CXios::getXiosComm(),true,commRank,&serversComm_) ;
+      xios::MPI_Comm_split(CXios::getXiosComm(),true,commRank,&serversComm_) ;
       CXios::getMpiGarbageCollector().registerCommunicator(serversComm_) ;
       
@@ -442,13 +442,13 @@
 
       MPI_Comm intraComm ;
-      MPI_Comm_dup(serverComm,&intraComm) ;
+      xios::MPI_Comm_dup(serverComm,&intraComm) ;
       MPI_Comm interComm ;
       for(int i=0 ; i<clientsRank.size(); i++)
       {  
-        MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm);
+        xios::MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm);
         CXios::getMpiGarbageCollector().registerCommunicator(interComm) ;
         interCommLeft.push_back(interComm) ;
-        MPI_Comm_free(&intraComm) ;
-        MPI_Intercomm_merge(interComm,false, &intraComm ) ;
+        xios::MPI_Comm_free(&intraComm) ;
+        xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ;
       }
       xiosGlobalComm=intraComm ;  
@@ -485,5 +485,5 @@
         {  
           MPI_Comm_accept(portName, MPI_INFO_NULL, 0, intraComm, &interComm);
-          MPI_Intercomm_merge(interComm,false, &intraComm ) ;
+          xios::MPI_Intercomm_merge(interComm,false, &intraComm ) ;
         }
 */      
@@ -590,13 +590,13 @@
 
       for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++)
-        MPI_Comm_free(&(*it));
+        xios::MPI_Comm_free(&(*it));
 
       for (std::list<MPI_Comm>::iterator it = contextIntraComms.begin(); it != contextIntraComms.end(); it++)
-        MPI_Comm_free(&(*it));
+        xios::MPI_Comm_free(&(*it));
 
         for (std::list<MPI_Comm>::iterator it = interCommRight.begin(); it != interCommRight.end(); it++)
-          MPI_Comm_free(&(*it));
-
-//      MPI_Comm_free(&intraComm);
+          xios::MPI_Comm_free(&(*it));
+
+//      xios::MPI_Comm_free(&intraComm);
       CXios::finalizeDaemonsManager();
       finalizeServersRessource();
@@ -606,5 +606,5 @@
       CXios::getMpiGarbageCollector().release() ; // release unfree MPI ressources
       MPI_Comm xiosComm=CXios::getXiosComm() ;
-      MPI_Comm_free(&xiosComm) ;
+      xios::MPI_Comm_free(&xiosComm) ;
       CMemChecker::logMem( "CServer::finalize", true );
       
Index: XIOS3/trunk/src/transformation/domain_algorithm/domain_algorithm_interpolate.cpp
===================================================================
--- XIOS3/trunk/src/transformation/domain_algorithm/domain_algorithm_interpolate.cpp	(revision 2588)
+++ XIOS3/trunk/src/transformation/domain_algorithm/domain_algorithm_interpolate.cpp	(revision 2589)
@@ -447,5 +447,5 @@
   
   MPI_Comm poleComme(MPI_COMM_NULL);
-  MPI_Comm_split(context->intraComm_, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme);
+  xios::MPI_Comm_split(context->intraComm_, interMapValuePole.empty() ? MPI_UNDEFINED : 1, 0, &poleComme);
   if (MPI_COMM_NULL != poleComme)
   {
Index: XIOS3/trunk/src/transport/legacy_context_client.cpp
===================================================================
--- XIOS3/trunk/src/transport/legacy_context_client.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/legacy_context_client.cpp	(revision 2589)
@@ -31,6 +31,6 @@
     {
       pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test)
-      MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
-      MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
+      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
+      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
       eventScheduler_ = parent->getEventScheduler() ;  
       timeLine = 1;
@@ -219,7 +219,7 @@
           MPI_Comm interComm ;
           int tag = 0 ;
-          MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ;
-          MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ;
-          MPI_Comm_free(&interComm) ;
+          xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ;
+          xios::MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ;
+          xios::MPI_Comm_free(&interComm) ;
                 
           buffer->attachWindows(winComm_[rank]) ;
@@ -242,7 +242,7 @@
             MPI_Comm interComm ;
             int tag = 0 ;
-            MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ;
-            MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ;
-            MPI_Comm_free(&interComm) ;
+            xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, clientSize+rank, tag, &interComm) ;
+            xios::MPI_Intercomm_merge(interComm, false, &winComm_[rank]) ;
+            xios::MPI_Comm_free(&interComm) ;
               
             buffer->attachWindows(winComm_[rank]) ;
Index: XIOS3/trunk/src/transport/legacy_context_server.cpp
===================================================================
--- XIOS3/trunk/src/transport/legacy_context_server.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/legacy_context_server.cpp	(revision 2589)
@@ -36,5 +36,5 @@
   {
  
-    MPI_Comm_dup(intraComm, &processEventBarrier_) ;
+    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ;
  
 
@@ -43,6 +43,6 @@
     finished=false;
 
-    MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
-    MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
+    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
+    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
     
     itLastTimeLine=lastTimeLine.begin() ;
@@ -122,7 +122,7 @@
       MPI_Comm interComm ;
       int tag = 0 ;
-      MPI_Intercomm_create(commSelf_, 0, interCommMerged_, rank, tag , &interComm) ;
-      MPI_Intercomm_merge(interComm, true, &winComm_[rank]) ;
-      MPI_Comm_free(&interComm) ;
+      xios::MPI_Intercomm_create(commSelf_, 0, interCommMerged_, rank, tag , &interComm) ;
+      xios::MPI_Intercomm_merge(interComm, true, &winComm_[rank]) ;
+      xios::MPI_Comm_free(&interComm) ;
       windows_[rank].resize(2) ;
       //MPI_Win_create_dynamic(MPI_INFO_NULL, winComm_[rank], &windows_[rank][0]);
Index: XIOS3/trunk/src/transport/one_sided_client_buffer.cpp
===================================================================
--- XIOS3/trunk/src/transport/one_sided_client_buffer.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/one_sided_client_buffer.cpp	(revision 2589)
@@ -22,11 +22,11 @@
     CTimer::get("create Windows").resume() ;
     MPI_Comm interComm ;
-    MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
-    MPI_Intercomm_merge(interComm, false, &winComm_) ;
+    xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
+    xios::MPI_Intercomm_merge(interComm, false, &winComm_) ;
     int rank ;
     MPI_Comm_rank(winComm_,&rank) ;
     info(logProtocol)<<"Windows rank="<<rank<<endl ;
     CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ;
-    MPI_Comm_free(&interComm) ;
+    xios::MPI_Comm_free(&interComm) ;
     
     maxWindows_=MAX_WINDOWS ;    
Index: XIOS3/trunk/src/transport/one_sided_context_client.cpp
===================================================================
--- XIOS3/trunk/src/transport/one_sided_context_client.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/one_sided_context_client.cpp	(revision 2589)
@@ -31,7 +31,7 @@
       pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test)
 
-      MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
-      
-      MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
+      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
+      
+      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
       eventScheduler_ = parent->getEventScheduler() ;  
       timeLine = 1;
Index: XIOS3/trunk/src/transport/one_sided_context_server.cpp
===================================================================
--- XIOS3/trunk/src/transport/one_sided_context_server.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/one_sided_context_server.cpp	(revision 2589)
@@ -36,5 +36,5 @@
   {
    
-    MPI_Comm_dup(intraComm, &processEventBarrier_) ;
+    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ;
  
     currentTimeLine=1;
@@ -42,6 +42,6 @@
     finished=false;
 
-    MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
-    MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
+    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
+    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
     
     itLastTimeLine=lastTimeLine.begin() ;
@@ -237,5 +237,5 @@
     //    MPI_Win_free(&windows_[rank][0]);
     //    MPI_Win_free(&windows_[rank][1]);
-    //    MPI_Comm_free(&winComm_[rank]) ;
+    //    xios::MPI_Comm_free(&winComm_[rank]) ;
     //  }
   }
Index: XIOS3/trunk/src/transport/one_sided_server_buffer.cpp
===================================================================
--- XIOS3/trunk/src/transport/one_sided_server_buffer.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/one_sided_server_buffer.cpp	(revision 2589)
@@ -25,8 +25,8 @@
     CTimer::get("create Windows").resume() ;
     MPI_Comm interComm ;
-    MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
-    MPI_Intercomm_merge(interComm, true, &winComm_) ;
+    xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
+    xios::MPI_Intercomm_merge(interComm, true, &winComm_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ;
-    MPI_Comm_free(&interComm) ;
+    xios::MPI_Comm_free(&interComm) ;
     
     maxWindows_=MAX_WINDOWS ;
Index: XIOS3/trunk/src/transport/p2p_client_buffer.cpp
===================================================================
--- XIOS3/trunk/src/transport/p2p_client_buffer.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/p2p_client_buffer.cpp	(revision 2589)
@@ -24,11 +24,11 @@
     CTimer::get("create Windows").resume() ;
     //MPI_Comm interComm ;
-    //MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
-    //MPI_Intercomm_merge(interComm, false, &winComm_) ;
+    //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
+    //xios::MPI_Intercomm_merge(interComm, false, &winComm_) ;
     //int rank ;
     //MPI_Comm_rank(winComm_,&rank) ;
     //info(logProtocol)<<"Windows rank="<<rank<<endl ;
     //CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ;
-    //MPI_Comm_free(&interComm) ;
+    //xios::MPI_Comm_free(&interComm) ;
     
     maxWindows_=MAX_WINDOWS ;    
Index: XIOS3/trunk/src/transport/p2p_context_client.cpp
===================================================================
--- XIOS3/trunk/src/transport/p2p_context_client.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/p2p_context_client.cpp	(revision 2589)
@@ -31,8 +31,8 @@
       pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test)
 
-      MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
+      xios::MPI_Intercomm_merge(interComm_,false, &interCommMerged_) ;
       CXios::getMpiGarbageCollector().registerCommunicator(interCommMerged_) ;
       
-      MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
+      xios::MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf_) ; // for windows
       CXios::getMpiGarbageCollector().registerCommunicator(commSelf_) ;
       eventScheduler_ = parent->getEventScheduler() ;  
Index: XIOS3/trunk/src/transport/p2p_context_server.cpp
===================================================================
--- XIOS3/trunk/src/transport/p2p_context_server.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/p2p_context_server.cpp	(revision 2589)
@@ -36,5 +36,5 @@
   {
    
-    MPI_Comm_dup(intraComm, &processEventBarrier_) ;
+    xios::MPI_Comm_dup(intraComm, &processEventBarrier_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(processEventBarrier_) ;
     
@@ -43,7 +43,7 @@
     finished=false;
 
-    MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
+    xios::MPI_Intercomm_merge(interComm_,true,&interCommMerged_) ;
     CXios::getMpiGarbageCollector().registerCommunicator(interCommMerged_) ;
-    MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
+    xios::MPI_Comm_split(intraComm_, intraCommRank, intraCommRank, &commSelf_) ; // for windows
     CXios::getMpiGarbageCollector().registerCommunicator(commSelf_) ;
     
@@ -244,5 +244,5 @@
     //    MPI_Win_free(&windows_[rank][0]);
     //    MPI_Win_free(&windows_[rank][1]);
-    //    MPI_Comm_free(&winComm_[rank]) ;
+    //    xios::MPI_Comm_free(&winComm_[rank]) ;
     //  }
   }
Index: XIOS3/trunk/src/transport/p2p_server_buffer.cpp
===================================================================
--- XIOS3/trunk/src/transport/p2p_server_buffer.cpp	(revision 2588)
+++ XIOS3/trunk/src/transport/p2p_server_buffer.cpp	(revision 2589)
@@ -25,8 +25,8 @@
     CTimer::get("create Windows").resume() ;
     //MPI_Comm interComm ;
-    //MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
-    //MPI_Intercomm_merge(interComm, true, &winComm_) ;
+    //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
+    //xios::MPI_Intercomm_merge(interComm, true, &winComm_) ;
     //CXios::getMpiGarbageCollector().registerCommunicator(winComm_) ;
-    //MPI_Comm_free(&interComm) ;
+    //xios::MPI_Comm_free(&interComm) ;
     
     //maxWindows_=MAX_WINDOWS ;
