Index: XIOS/branchs/xios-1.0/src/buffer_in.cpp
===================================================================
--- XIOS/branchs/xios-1.0/src/buffer_in.cpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/buffer_in.cpp	(revision 799)
@@ -20,5 +20,5 @@
     {
       own=false ;
-      realloc(0,0) ;      
+      size_=0 ;
     }
 
@@ -52,5 +52,5 @@
     }
 
-    size_t CBufferIn::size(void)
+    size_t CBufferIn::bufferSize(void)
     {
       return size_ ;
Index: XIOS/branchs/xios-1.0/src/buffer_in.hpp
===================================================================
--- XIOS/branchs/xios-1.0/src/buffer_in.hpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/buffer_in.hpp	(revision 799)
@@ -42,9 +42,10 @@
 
       void* ptr(void) ;
+      void* start(void) { return begin ; }
 
       
       size_t remain(void) ;
       size_t count(void) ;                          
-      size_t size(void) ;                         
+      size_t bufferSize(void) ;
       ~CBufferIn() ;
 
Index: XIOS/branchs/xios-1.0/src/buffer_out.cpp
===================================================================
--- XIOS/branchs/xios-1.0/src/buffer_out.cpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/buffer_out.cpp	(revision 799)
@@ -14,5 +14,5 @@
     {
       own=false ;
-      realloc(0,0) ;      
+      size_=0 ;
     }
 
@@ -57,5 +57,5 @@
     }
 
-    size_t CBufferOut::size(void)
+    size_t CBufferOut::bufferSize(void)
     {
       return size_ ;
Index: XIOS/branchs/xios-1.0/src/buffer_out.hpp
===================================================================
--- XIOS/branchs/xios-1.0/src/buffer_out.hpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/buffer_out.hpp	(revision 799)
@@ -44,8 +44,9 @@
       
       void* ptr(void) ;
+      void* start(void) { return begin ; }
             
       size_t remain(void) ;
       size_t count(void) ;
-      size_t size(void) ;
+      size_t bufferSize(void) ;
                             
       ~CBufferOut() ;
Index: XIOS/branchs/xios-1.0/src/cxios.cpp
===================================================================
--- XIOS/branchs/xios-1.0/src/cxios.cpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/cxios.cpp	(revision 799)
@@ -10,4 +10,5 @@
 #include <new>
 #include "memtrack.hpp"
+#include "registry.hpp"
 
 namespace xios
@@ -28,4 +29,5 @@
   double CXios::defaultBufferServerFactorSize=2 ;
   bool CXios::printLogs2Files;
+  CRegistry* CXios::globalRegistry = 0;
 
 
@@ -52,4 +54,5 @@
 
     CClient::initialize(codeId,localComm,returnComm) ;
+    if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ;
 
     if (usingServer) isServer=false;
@@ -71,4 +74,10 @@
   {
      CClient::finalize() ;
+     if (CClient::getRank()==0)
+     {
+       info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ;
+       globalRegistry->toFile("xios_registry.bin") ;
+       delete globalRegistry ;
+     }
      CClient::closeInfoStream();
 
@@ -89,4 +98,5 @@
     // Initialize all aspects MPI
     CServer::initialize();
+    if (CServer::getRank()==0) globalRegistry = new CRegistry(CServer::intraComm) ;
 
     if (printLogs2Files)
@@ -106,4 +116,10 @@
     // Finalize
     CServer::finalize();
+    if (CServer::getRank()==0)
+    {
+      info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ;
+      globalRegistry->toFile("xios_registry.bin") ;
+      delete globalRegistry ;
+    }
     CServer::closeInfoStream();
   }
Index: XIOS/branchs/xios-1.0/src/cxios.hpp
===================================================================
--- XIOS/branchs/xios-1.0/src/cxios.hpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/cxios.hpp	(revision 799)
@@ -4,4 +4,5 @@
 #include "xmlioserver_spl.hpp"
 #include "mpi.hpp"
+#include "registry.hpp"
 
 namespace xios
@@ -42,4 +43,5 @@
      static double bufferServerFactorSize ;
      static double defaultBufferServerFactorSize ;
+     static CRegistry* globalRegistry ; //!< global registry which is written by the root process of the servers
 
      public:
Index: XIOS/branchs/xios-1.0/src/node/context.cpp
===================================================================
--- XIOS/branchs/xios-1.0/src/node/context.cpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/node/context.cpp	(revision 799)
@@ -7,4 +7,5 @@
 #include "duration.hpp"
 
+#include "cxios.hpp"
 #include "context_client.hpp"
 #include "context_server.hpp"
@@ -268,4 +269,11 @@
      hasClient=true ;
      client = new CContextClient(this,intraComm, interComm) ;
+     registryIn=new CRegistry(intraComm);
+     registryIn->setPath(getId()) ;
+     if (client->clientRank==0) registryIn->fromFile("xios_registry.bin") ;
+     registryIn->bcastRegistry() ;
+
+     registryOut=new CRegistry(intraComm) ;
+     registryOut->setPath(getId()) ;
    } 
 
@@ -279,4 +287,10 @@
      hasServer=true ;
      server = new CContextServer(this,intraComm,interComm) ;
+     registryIn=new CRegistry(intraComm);
+     registryIn->setPath(getId()) ;
+     if (server->intraCommRank==0) registryIn->fromFile("xios_registry.bin") ;
+     registryIn->bcastRegistry() ;
+     registryOut=new CRegistry(intraComm) ;
+     registryOut->setPath(getId()) ;
    } 
 
@@ -290,4 +304,5 @@
       if (hasClient && !hasServer)
       {
+         if (hasClient) sendRegistry() ;
          client->finalize() ;
       }
@@ -295,4 +310,6 @@
       {
         closeAllFile() ;
+        registryOut->hierarchicalGatherRegistry() ;
+        if (server->intraCommRank==0) CXios::globalRegistry->mergeRegistry(*registryOut) ;
       }
    }
@@ -429,4 +446,8 @@
              return true ;
              break ;
+           case EVENT_ID_SEND_REGISTRY:
+            recvRegistry(event);
+            return true;
+           break;
            default :
              ERROR("bool CContext::dispatchEvent(CEventServer& event)",
@@ -564,3 +585,37 @@
     return (context);
   }
+
+  void CContext::recvRegistry(CEventServer& event)
+  {
+    CBufferIn* buffer=event.subEvents.begin()->buffer;
+    string id;
+    *buffer>>id;
+    get(id)->recvRegistry(*buffer);
+  }
+
+  void CContext::recvRegistry(CBufferIn& buffer)
+  {
+    if (server->intraCommRank==0)
+    {
+      CRegistry registry(server->intraComm) ;
+      registry.fromBuffer(buffer) ;
+      registryOut->mergeRegistry(registry) ;
+    }
+  }
+
+  void CContext::sendRegistry(void)
+  {
+    registryOut->hierarchicalGatherRegistry() ;
+
+    CEventClient event(CContext::GetType(), CContext::EVENT_ID_SEND_REGISTRY);
+    if (client->isServerLeader())
+    {
+       CMessage msg ;
+       msg<<this->getId();
+       if (client->clientRank==0) msg<<*registryOut ;
+       event.push(client->getServerLeader(),1,msg);
+       client->sendEvent(event);
+     }
+     else client->sendEvent(event);
+  }
 } // namespace xios
Index: XIOS/branchs/xios-1.0/src/node/context.hpp
===================================================================
--- XIOS/branchs/xios-1.0/src/node/context.hpp	(revision 798)
+++ XIOS/branchs/xios-1.0/src/node/context.hpp	(revision 799)
@@ -13,4 +13,6 @@
 
 #include "mpi.hpp"
+
+#include "registry.hpp"
 
 
@@ -42,5 +44,6 @@
          {
            EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
-           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE
+           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
+           EVENT_ID_SEND_REGISTRY
          } ;
          
@@ -125,4 +128,5 @@
          void sendUpdateCalendar(int step) ;
          void sendCreateFileHeader(void) ;
+         void sendRegistry(void) ; //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
          static void recvUpdateCalendar(CEventServer& event) ;
          void recvUpdateCalendar(CBufferIn& buffer) ;
@@ -130,4 +134,6 @@
          static void recvCreateFileHeader(CEventServer& event) ;
          void recvCreateFileHeader(CBufferIn& buffer) ;
+         static void recvRegistry(CEventServer& event) ;
+         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the root process of the servers
          static CContext* getCurrent(void) ;
          static CContextGroup* getRoot(void) ;
@@ -151,5 +157,6 @@
          static shared_ptr<CContextGroup> root ;
 
-
+         CRegistry* registryIn ;  //!< input registry which is read from file
+         CRegistry* registryOut ; //!< output registry which will be wrote on file at the finalize
    }; // class CContext
 
Index: XIOS/branchs/xios-1.0/src/registry.cpp
===================================================================
--- XIOS/branchs/xios-1.0/src/registry.cpp	(revision 799)
+++ XIOS/branchs/xios-1.0/src/registry.cpp	(revision 799)
@@ -0,0 +1,293 @@
+#include "registry.hpp"
+#include "type.hpp"
+#include <mpi.hpp>
+#include <fstream>
+#include <sstream>
+
+namespace xios
+{
+  using namespace std;
+
+  CRegistry::CRegistry(const CRegistry& reg) : communicator(reg.communicator)
+  {
+    for(map<string,pair<size_t,char*> >::const_iterator it=reg.registry.begin() ; it!=reg.registry.end() ; ++it)
+    {
+      char* buffer=new char[it->second.first] ;
+      memcpy(buffer,it->second.second,it->second.first) ;
+      registry.insert(pair<string, pair<size_t,char*> >(it->first, pair<size_t,char*>(it->second.first,buffer))) ; 
+    }
+  }
+
+        
+  void CRegistry::reset()
+  {
+    for(map<string,pair<size_t,char*> >::const_iterator it=registry.begin() ; it!=registry.end() ; ++it)
+    {
+      if (it->second.first>0) delete[] it->second.second ;
+    }
+    registry.clear() ;
+  }
+
+  void CRegistry::setKey_(const string& key_, const CBaseType& value)
+  {
+    const string key=path+key_ ;
+    if (!value.isEmpty())
+    {
+      size_t size=value.size();
+      
+      map<string,pair<size_t,char*> >::iterator it=registry.find(key) ;
+
+      if (it!=registry.end())
+      {
+        delete[] it->second.second ;
+        registry.erase(it) ;
+      }
+
+      char* buffer=new char[size] ;
+      CBufferOut tmpBuff(buffer,size) ;
+      value.toBuffer(tmpBuff) ;
+      registry.insert(pair<string, pair<size_t,char*> >(key, pair<size_t,char*>(size,buffer))) ;
+    }
+  }
+
+  void CRegistry::getKey_(const string& key_, CBaseType& value)
+  {
+    const string key=path+key_ ;
+    size_t size=value.size();
+      
+    map<string,pair<size_t,char*> >::iterator it=registry.find(key) ;
+
+    if (it!=registry.end())
+    {
+      CBufferIn tmpBuff(it->second.second,it->second.first) ;
+      value.fromBuffer(tmpBuff) ;
+    }
+    else value.reset() ;
+  }
+
+  bool CRegistry::foundKey(const string& key_) const
+  {
+    const string key=path+key_ ;
+    map<string,pair<size_t,char*> >::const_iterator it=registry.find(key) ;
+    if (it!=registry.end()) return true ;
+    else return false ;
+  }
+  
+  bool CRegistry::toBuffer(CBufferOut& buffer) const
+  {
+    buffer<<registry.size() ;
+    for(map<string,pair<size_t,char*> >::const_iterator it=registry.begin() ; it!=registry.end() ; ++it)
+    {
+      buffer<<it->first<<it->second.first ;
+      if (!buffer.put(it->second.second,it->second.first)) ERROR("bool CRegistry::toBuffer(CBufferOut& buffer) const)",
+                                                           << "Not enough free space in buffer to queue the data."); 
+    }
+    return true ;
+  }
+
+  size_t CRegistry::size() const
+  {
+    size_t s=0;
+    size_t size_t_size=CType<size_t>(0).size() ;
+    s+=size_t_size ;
+    for(map<string,pair<size_t,char*> >::const_iterator it=registry.begin() ; it!=registry.end() ; ++it)
+      s+=(CType<string>(it->first)).size() + size_t_size + it->second.first ;
+    return s ;
+  }
+
+  void CRegistry::fromString(const string& str)
+  {
+     ERROR("void CRegistry::fromString(const string& str)",<< "This method has not been implemented"); 
+  }
+
+  string CRegistry::toString() const
+  {
+    ostringstream oss;
+    
+    for(map<string,pair<size_t,char*> >::const_iterator it=registry.begin() ; it!=registry.end() ; ++it)
+    {
+      oss<<"Key = "<< it->first  <<" , size : "<<it->second.first<<"  ASCII value : "<<string((char*) it->second.second,it->second.first)<<endl ;
+    }
+    return oss.str() ;
+  }
+
+  
+
+  bool CRegistry::fromBuffer(CBufferIn& buffer)
+  {
+    string key ;
+    size_t size ;
+    char* value ;
+    size_t nKeys ;
+    buffer >> nKeys ;
+    for(size_t i=0;i<nKeys;++i)
+    {
+      buffer>>key>>size ;
+      if (size > 0)
+      {
+        value = new char[size] ;
+        buffer.get(value,size) ;
+      }
+      
+      map<string,pair<size_t,char*> >::iterator it=registry.find(key) ;
+      if (it!=registry.end())
+      {
+        delete[] it->second.second ;
+        registry.erase(it) ;
+      }
+      registry.insert(pair<string, pair<size_t,char*> >(key, pair<size_t,char*>(size,value))) ;        
+    }
+    return true ;
+  }  
+
+  void CRegistry::toFile(const string& filename)
+  {
+    if (registry.size()==0) return ;
+    
+    CBufferOut buffer(this->size()) ;
+    this->toBuffer(buffer) ;
+    ofstream file(filename.c_str(), ofstream::out ) ;
+    size_t size=buffer.count() ;
+    file.write((const char*) &size,sizeof(size)) ;
+    file.write((const char*) buffer.start(),size) ;
+    file.close() ;
+  }
+
+  void CRegistry::fromFile(const string& filename)
+  {
+    ifstream file(filename.c_str(), ifstream::in | ifstream::binary) ;
+    if (!file) return ;
+    size_t size;
+    file.read((char*) &size,sizeof(size)) ;
+    
+    CBufferIn buffer(size) ;
+    file.read((char*) buffer.ptr(),size) ;
+    this->fromBuffer(buffer) ;
+
+    file.close() ;
+  }
+    
+  void CRegistry::mergeRegistry(const CRegistry& inRegistry)
+  {
+    size_t size ;
+    char* value;
+    
+    for(map<string,pair<size_t,char*> >::const_iterator it=inRegistry.registry.begin() ; it!=inRegistry.registry.end() ; ++it)
+    {
+      const string& key=it->first ;
+      map<string,pair<size_t,char*> >::iterator it2=registry.find(key) ;
+      if (it2==registry.end())
+      {
+        size=it->second.first ;
+        value=new char[size] ;
+        memcpy(value,it->second.second,size) ;
+        registry.insert(pair<string, pair<size_t,char*> >(key, pair<size_t,char*>(size,value))) ;      
+      }
+    }
+  }
+
+  
+  void CRegistry::bcastRegistry(void)
+  {
+    int rank ;
+    MPI_Comm_rank(communicator,&rank);
+    if (rank==0)
+    {
+      CBufferOut buffer(this->size()) ;
+      this->toBuffer(buffer) ;
+      int size=buffer.count() ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
+    }
+    else
+    {
+      int size ;
+      MPI_Bcast(&size,1,MPI_INT,0,communicator) ;
+      CBufferIn buffer(size) ;
+      MPI_Bcast(buffer.start(),size,MPI_CHAR,0,communicator) ;
+      this->fromBuffer(buffer) ;
+    }
+  }
+  void CRegistry::gatherRegistry(void)
+  {
+    gatherRegistry(communicator) ;
+  }
+
+  void CRegistry::gatherRegistry(const MPI_Comm& comm)
+  {
+    int rank,mpiSize ;
+    MPI_Comm_rank(comm,&rank);
+    MPI_Comm_size(comm,&mpiSize);
+
+    int* sizes=new int[mpiSize] ;
+    CBufferOut localBuffer(this->size()) ;
+    this->toBuffer(localBuffer) ;
+    int localSize=localBuffer.count() ;
+    MPI_Gather(&localSize,1,MPI_INT,sizes,1,MPI_INT,0,comm) ;
+
+    char* globalBuffer ;
+    int*   displs ;
+    
+    if (rank==0)
+    {
+      size_t globalBufferSize=0 ;
+      displs=new int[mpiSize] ;
+      for (int i=0;i<mpiSize;++i)
+      {
+        displs[i]=globalBufferSize ;
+        globalBufferSize+=sizes[i] ;
+      }
+
+      globalBuffer=new char[globalBufferSize] ;
+      MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;
+      for(int i=1;i<mpiSize;++i)
+      {
+        CBufferIn buffer(globalBuffer+displs[i],sizes[i]) ;
+        CRegistry reg ;
+        reg.fromBuffer(buffer) ;
+        mergeRegistry(reg) ;
+      }
+      delete[] displs ;
+      delete[] globalBuffer ;
+    }
+    else  MPI_Gatherv(localBuffer.start(),localSize,MPI_CHAR,globalBuffer,sizes,displs,MPI_CHAR,0,comm) ;   
+    delete[] sizes ;
+    
+  }
+
+  void CRegistry::hierarchicalGatherRegistry(void)
+  {
+    hierarchicalGatherRegistry(communicator) ;
+  }
+
+  void CRegistry::hierarchicalGatherRegistry(const MPI_Comm& comm)
+  {
+    int mpiRank,mpiSize ;
+    MPI_Comm_rank(comm,&mpiRank);
+    MPI_Comm_size(comm,&mpiSize);    
+
+    if (mpiSize>2)
+    {
+      int color ;
+      if (mpiRank<mpiSize/2+mpiSize%2) color=0 ;
+      else color=1 ;
+      MPI_Comm commUp ;
+      MPI_Comm_split(comm,color,mpiRank,&commUp) ,
+      hierarchicalGatherRegistry(commUp) ;
+      MPI_Comm_free(&commUp) ;
+    }
+
+    if (mpiSize>1)
+    {
+      MPI_Comm commDown ;
+      int color ;
+      
+      if (mpiRank==0 || mpiRank==mpiSize/2+mpiSize%2) color=0 ;
+      else color=1 ;
+      MPI_Comm_split(comm,color,mpiRank,&commDown) ;
+      if (color==0) gatherRegistry(commDown) ;
+      MPI_Comm_free(&commDown) ;    
+    }
+  }
+
+}
Index: XIOS/branchs/xios-1.0/src/registry.hpp
===================================================================
--- XIOS/branchs/xios-1.0/src/registry.hpp	(revision 799)
+++ XIOS/branchs/xios-1.0/src/registry.hpp	(revision 799)
@@ -0,0 +1,139 @@
+#ifndef __XIOS_REGISTRY_HPP__
+#define __XIOS_REGISTRY_HPP__
+
+#include "base_type.hpp"
+#include "type.hpp"
+#include "mpi.hpp"
+#include "message.hpp"
+
+// Those two headers can be replaced by the C++11 equivalent in the future
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits.hpp>
+
+namespace xios
+{
+/*!
+  \class CRegistry
+ This class is a registry database which store key with an associated value. Internally the value is stored as a memory bloc
+ and the key is a string. The registry can be gathered and merge between MPI process, broadcast and read or wrote from a file
+*/
+  class CRegistry : virtual public CBaseType
+  {
+    public:
+
+/** Constructor, the communicator is used for bcast or gather operation between MPI processes */
+      CRegistry(const MPI_Comm& comm=MPI_COMM_WORLD) : communicator(comm) {}
+
+/** Copy constructor */
+      CRegistry(const CRegistry& reg) ;
+
+
+/** insert a value associated to a key*/
+      void setKey(const std::string& key, const CBaseType& value) { this->setKey_(key,value); }
+
+/** insert a value associated to a key*/
+      template<typename T> typename boost::enable_if_c<!boost::is_convertible<T&, CBaseType&>::value>::type
+      setKey(const std::string& key, const T& value) { this->setKey_(key,CType<T>(value)); }
+
+
+/** retrieve a value from a key */
+      void getKey(const std::string& key, CBaseType& value) { this->getKey_(key,value); }
+
+/** retrieve a value from a key */
+      template<typename T> typename boost::enable_if_c<!boost::is_convertible<T&, CBaseType&>::value>::type
+      getKey(const std::string& key, T& value) { CType_ref<T> valRef(value); this->getKey_(key,valRef); }
+
+
+/** query for an already inserted key */
+      bool foundKey(const std::string& key) const ;
+
+/** The registry is wrote into a memory buffer */
+      bool toBuffer(CBufferOut& buffer) const ;
+
+/** The registry is read from a memory buffer */
+      bool fromBuffer(CBufferIn& buffer) ;
+
+/** The registry is wrote to the file given by "filename". If the registry is empty no file is wrote */
+      void toFile(const string& filename) ;
+
+/** The registry is read from the file given by "filename". If no file exist, the registry remain empty */
+      void fromFile(const string& filename) ;
+
+/** Merge the registry with an other. Existing keys in the current registry are not overwritten */
+      void mergeRegistry(const CRegistry& inRegistry) ;
+
+/** Broadcast registry from the root process (rank 0) to the other processes of the communicator */
+      void bcastRegistry(void) ;
+
+/** Gather registry to the root process (rank 0) from the other processes of the communicator */
+      void gatherRegistry(void) ;
+
+/** Gather registry with a hierarchical algorithm which avoid root process to get registries from whole processes of the communicator.
+   Registry are merged two by two hierarchically. */
+      void hierarchicalGatherRegistry(void) ;
+
+/** Destructor */
+       ~CRegistry() { reset() ; }
+
+/** Unimplemented, do not use (need for CBaseType pure virtual class) */
+      void fromString(const string& str) ;
+
+/** Dump registry to a string (need for CBaseType pure virtual class)*/
+      string toString(void) const ;
+
+/** Clone the registry (need for CBaseType pure virtual class)*/
+      CRegistry* clone(void) const { return new CRegistry(*this); }
+
+/** return the size needed to bufferize the registry (need for CBaseType pure virtual class)*/
+      size_t size(void) const ;
+
+/** return true if the registry is empty (need for CBaseType pure virtual class)*/
+      bool isEmpty(void) const { return registry.empty(); }
+
+/** Clean the registry and delete associated memory (need for CBaseType pure virtual class)*/
+      void reset(void) ;
+
+/** Set the prefix added systematically to the keys, with "::" as separator*/
+      void setPath(const string& str) { path=str+"::" ; }
+
+    private:
+
+/** insert a value associated to a key (internal use)*/
+      void setKey_(const std::string& key, const CBaseType& value) ;
+
+/** retrieve a value from a key (internal use)*/
+      void getKey_(const std::string& key, CBaseType& value) ;
+
+/** use internally for recursivity */
+      void gatherRegistry(const MPI_Comm& comm) ;
+
+/** use internally for recursivity */
+      void hierarchicalGatherRegistry(const MPI_Comm& comm) ;
+
+
+/** Prefix added systematically to the keys, with "::" as separator*/
+      std::string path ;
+
+/** Map containing registry, the key is a string type and the value is stored in a pair with the size
+ *  of the memory bloc and the associated pointer*/
+      std::map<std::string,std::pair<size_t,char*> > registry ;
+
+/** MPI communicator used for broadcast and gather operation */
+      MPI_Comm communicator ;
+  } ;
+
+  inline CMessage& operator<<(CMessage& msg, CRegistry& registry)
+  {
+      msg.push(registry) ;
+      return msg ;
+  }
+
+  inline CMessage& operator<<(CMessage& msg, const CRegistry& registry)
+  {
+      msg.push(registry) ;
+      return msg ;
+  }
+
+}
+
+#endif
