Import Geant4 11.1.0.beta source tree

source/externals/g4tools/include/toolx/mpi/hmpi

@@ -0,0 +1,266 @@
+// Copyright (C) 2010, Guy Barrand. All rights reserved.
+// See the file tools.license for terms.
+
+#ifndef toolx_mpi_hmpi
+#define toolx_mpi_hmpi
+
+// code to send, receive histos through MPI.
+
+#include <tools/histo/hmpi>
+#include <tools/histo/hd2mpi>
+
+#include <tools/histo/h1d>
+#include <tools/histo/h2d>
+#include <tools/histo/h3d>
+#include <tools/histo/p1d>
+#include <tools/histo/p2d>
+
+#include "wrmpi"
+
+namespace toolx {
+namespace mpi {
+
+class hmpi : public virtual tools::histo::hmpi {
+  typedef tools::histo::hmpi parent;
+protected:
+  typedef unsigned int num_t;
+  static const std::string& s_class() {
+    static const std::string s_v("toolx::mpi::hmpi");
+    return s_v;
+  }
+public:
+  virtual bool pack(const tools::histo::h1d& a_h) {
+    if(!m_wrmpi.spack(a_h.s_cls())) return false;
+    if(!histo_data_duiuid_pack(m_wrmpi,a_h.dac())) return false;
+    return true;
+  }
+  virtual bool pack(const tools::histo::h2d& a_h) {
+    if(!m_wrmpi.spack(a_h.s_cls())) return false;
+    if(!histo_data_duiuid_pack(m_wrmpi,a_h.dac())) return false;
+    return true;
+  }
+  virtual bool pack(const tools::histo::h3d& a_h) {
+    if(!m_wrmpi.spack(a_h.s_cls())) return false;
+    if(!histo_data_duiuid_pack(m_wrmpi,a_h.dac())) return false;
+    return true;
+  }
+  virtual bool pack(const tools::histo::p1d& a_h) {
+    if(!m_wrmpi.spack(a_h.s_cls())) return false;
+    if(!profile_data_duiuidd_pack(m_wrmpi,a_h.get_histo_data())) return false;
+    return true;
+  }
+  virtual bool pack(const tools::histo::p2d& a_h) {
+    if(!m_wrmpi.spack(a_h.s_cls())) return false;
+    if(!profile_data_duiuidd_pack(m_wrmpi,a_h.get_histo_data())) return false;
+    return true;
+  }
+public:
+  virtual bool beg_send(unsigned int a_nhist) {
+    m_wrmpi.pack_reset();
+    return m_wrmpi.pack(a_nhist);
+  }
+  virtual bool send(int a_dest) {
+    if(::MPI_Send(m_wrmpi.buffer(),m_wrmpi.ipos(),MPI_CHAR,a_dest,m_tag,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::hmpi::send : rank " << m_rank << " : MPI_Send failed." << std::endl;
+      return false;
+    }
+    m_wrmpi.pack_reset();
+    return true;
+  }
+public:
+  virtual bool wait_histos(int a_src,std::vector< std::pair<std::string,void*> >& a_hists) {
+    a_hists.clear();
+
+    typedef std::pair<std::string,void*> class_pointer;
+
+    MPI_Status status;
+    if(::MPI_Probe(a_src,m_tag,m_comm,&status)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : MPI_Probe : failed." << std::endl;
+      return false;
+    }
+
+    int buffer_size = 0;
+    if(::MPI_Get_count(&status,MPI_CHAR,&buffer_size)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : MPI_Get_count : failed." << std::endl;
+      return false;
+    }
+
+    if(!buffer_size) {
+      m_out << "exlb::mpi::wait_histos : MPI_Get_count returns zero data." << std::endl;
+      return false;
+    }
+
+    if(m_verbose) m_out << "rank " << m_rank << " : get_count " << buffer_size << std::endl;
+
+    char* buffer = new char[buffer_size];
+    if(!buffer) {
+      m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : can't alloc buffer of size " << buffer_size << std::endl;
+      return false;
+    }
+
+    if(::MPI_Recv(buffer,buffer_size,MPI_CHAR,a_src,m_tag,m_comm,&status)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : MPI_Recv : failed." << std::endl;
+      delete [] buffer;
+      return false;
+    }
+
+    if(m_verbose) m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : unpack data ..." << std::endl;
+
+    wrmpi _mpi(m_out,m_comm,buffer_size,buffer); //give ownership of buffer to _mpi.
+
+    num_t nhist;
+    if(!_mpi.unpack(nhist)) return false;
+
+    if(m_verbose)
+      m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank << " : number of histos to unpack " << nhist << std::endl;
+
+   {for(num_t ihist=0;ihist<nhist;ihist++) {
+
+      std::string scls;
+      if(!_mpi.sunpack(scls)) return false;
+
+      if(scls==tools::histo::h1d::s_class()) {
+        tools::histo::histo_data<double,unsigned int,unsigned int,double> hdata;
+        if(!histo_data_duiuid_unpack(_mpi,hdata)) return false;
+        tools::histo::h1d* h = new tools::histo::h1d("",10,0,1);
+        h->copy_from_data(hdata);
+        if(m_verbose) {
+          m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+                << " : got a " << scls
+                << ", title " << h->title()
+                << ", mean_x " << h->mean() << ", rms " << h->rms()
+                << std::endl;
+        }
+        a_hists.push_back(class_pointer(h->s_cls(),h)); //give ownership of h.
+
+      } else if(scls==tools::histo::h2d::s_class()) {
+        tools::histo::histo_data<double,unsigned int,unsigned int,double> hdata;
+        if(!histo_data_duiuid_unpack(_mpi,hdata)) return false;
+        tools::histo::h2d* h = new tools::histo::h2d("",10,0,1,10,0,1);
+        h->copy_from_data(hdata);
+        if(m_verbose) {
+          m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+                << " : got a " << scls
+                << ", title " << h->title()
+                << ", mean_x " << h->mean_x() << ", rms_x " << h->rms_x()
+                << ", mean_y " << h->mean_y() << ", rms_y " << h->rms_y()
+                << std::endl;
+        }
+        a_hists.push_back(class_pointer(h->s_cls(),h)); //give ownership of h.
+
+      } else if(scls==tools::histo::h3d::s_class()) {
+        tools::histo::histo_data<double,unsigned int,unsigned int,double> hdata;
+        if(!histo_data_duiuid_unpack(_mpi,hdata)) return false;
+        tools::histo::h3d* h = new tools::histo::h3d("",10,0,1,10,0,1,10,0,1);
+        h->copy_from_data(hdata);
+        if(m_verbose) {
+          m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+                << " : got a " << scls
+                << ", title " << h->title()
+                << ", mean_x " << h->mean_x() << ", rms_x " << h->rms_x()
+                << ", mean_y " << h->mean_y() << ", rms_y " << h->rms_y()
+                << ", mean_z " << h->mean_z() << ", rms_z " << h->rms_z()
+                << std::endl;
+        }
+        a_hists.push_back(class_pointer(h->s_cls(),h)); //give ownership of h.
+
+      } else if(scls==tools::histo::p1d::s_class()) {
+        tools::histo::profile_data<double,unsigned int,unsigned int,double,double> pdata;
+        if(!profile_data_duiuidd_unpack(_mpi,pdata)) return false;
+        tools::histo::p1d* h = new tools::histo::p1d("",10,0,1);
+        h->copy_from_data(pdata);
+        if(m_verbose) {
+          m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+                << " : got a " << scls
+                << ", title " << h->title()
+                << ", mean_x " << h->mean() << ", rms " << h->rms()
+                << std::endl;
+        }
+        a_hists.push_back(class_pointer(h->s_cls(),h)); //give ownership of h.
+
+      } else if(scls==tools::histo::p2d::s_class()) {
+        tools::histo::profile_data<double,unsigned int,unsigned int,double,double> pdata;
+        if(!profile_data_duiuidd_unpack(_mpi,pdata)) return false;
+        tools::histo::p2d* h = new tools::histo::p2d("",10,0,1,10,0,1);
+        h->copy_from_data(pdata);
+        if(m_verbose) {
+          m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+                << " : got a " << scls
+                << ", title " << h->title()
+                << ", mean_x " << h->mean_x() << ", rms_x " << h->rms_x()
+                << ", mean_y " << h->mean_y() << ", rms_y " << h->rms_y()
+                << std::endl;
+        }
+        a_hists.push_back(class_pointer(h->s_cls(),h)); //give ownership of h.
+
+      } else {
+        m_out << "toolx::mpi::hmpi::wait_histos : rank " << m_rank
+              << " : got not treated class " << scls
+              << std::endl;
+      }
+
+    }} //ihist
+
+    return true;
+  }
+
+public:
+  virtual int rank() const { return m_rank;}
+  virtual bool comm_rank(int& a_rank) const {
+    if(::MPI_Comm_rank(m_comm,&a_rank)!=MPI_SUCCESS) {a_rank=-1;return false;}
+    return true;
+  }
+  virtual bool comm_size(int& a_size) const {
+    if(::MPI_Comm_size(m_comm,&a_size)!=MPI_SUCCESS) {a_size=0;return false;}
+    return true;
+  }
+public:
+  hmpi(std::ostream& a_out,int a_rank,int a_tag,const MPI_Comm& a_comm,bool a_verbose = false)
+  :m_out(a_out)
+  ,m_rank(a_rank)
+  ,m_tag(a_tag)
+  ,m_comm(a_comm)
+  ,m_verbose(a_verbose)
+  ,m_wrmpi(a_out,a_comm)
+  {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+  }
+  virtual ~hmpi(){
+#ifdef TOOLS_MEM
+    tools::mem::decrement(s_class().c_str());
+#endif
+  }
+protected:
+  hmpi(const hmpi& a_from)
+  :parent(a_from)
+  ,m_out(a_from.m_out)
+  ,m_rank(a_from.m_rank)
+  ,m_tag(a_from.m_tag)
+  ,m_comm(a_from.m_comm)
+  ,m_verbose(a_from.m_verbose)
+  ,m_wrmpi(a_from.m_out,a_from.m_comm)
+  {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+  }
+  hmpi& operator=(const hmpi& a_from){
+    m_rank = a_from.m_rank;
+    m_tag = a_from.m_tag;
+    m_verbose = a_from.m_verbose;
+    return *this;
+  }
+protected:
+  std::ostream& m_out;
+  int m_rank;
+  int m_tag;
+  const MPI_Comm& m_comm;
+  bool m_verbose;
+  wrmpi m_wrmpi;
+};
+
+}}
+
+#endif

source/externals/g4tools/include/toolx/mpi/wait_buffer

@@ -0,0 +1,66 @@
+// Copyright (C) 2010, Guy Barrand. All rights reserved.
+// See the file tools.license for terms.
+
+#ifndef toolx_mpi_wait_buffer
+#define toolx_mpi_wait_buffer
+
+#include <mpi.h>
+
+#include <ostream>
+
+namespace toolx {
+namespace mpi {
+
+inline bool wait_buffer(std::ostream& a_out,int a_rank,int a_src,int a_tag,const MPI_Comm& a_comm,
+                        int& a_buffer_size,char*& a_buffer,int& a_probe_src,bool a_verbose = false) {
+  a_buffer = 0;
+  a_buffer_size = 0;
+  a_probe_src = -1;
+
+  MPI_Status status;
+  if(::MPI_Probe(a_src,a_tag,a_comm,&status)!=MPI_SUCCESS) {
+    a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : MPI_Probe : failed." << std::endl;
+    return false;
+  }
+
+  if(::MPI_Get_count(&status,MPI_CHAR,&a_buffer_size)!=MPI_SUCCESS) {
+    a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : MPI_Get_count : failed." << std::endl;
+    a_buffer_size = 0;
+    return false;
+  }
+
+  a_probe_src = status.MPI_SOURCE;
+
+  if(!a_buffer_size) {
+    a_out << "exlb::mpi::wait_buffer : MPI_Get_count returns zero data." << std::endl;
+    a_probe_src = -1;
+    return false;
+  }
+
+  if(a_verbose) a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : get_count " << a_buffer_size << std::endl;
+
+  a_buffer = new char[a_buffer_size];
+  if(!a_buffer) {
+    a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : can't alloc buffer of size " << a_buffer_size << std::endl;
+    a_buffer_size = 0;
+    a_probe_src = -1;
+    return false;
+  }
+
+  if(::MPI_Recv(a_buffer,a_buffer_size,MPI_CHAR,status.MPI_SOURCE,status.MPI_TAG,a_comm,&status)!=MPI_SUCCESS) {
+    a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : MPI_Recv : failed." << std::endl;
+    a_buffer_size = 0;
+    delete [] a_buffer;
+    a_buffer = 0;
+    a_probe_src = -1;
+    return false;
+  }
+
+  if(a_verbose) a_out << "toolx::mpi::wait_buffer : rank " << a_rank << " : unpack data ..." << std::endl;
+
+  return true;
+}
+
+}}
+
+#endif

source/externals/g4tools/include/toolx/mpi/world

@@ -0,0 +1,71 @@
+// Copyright (C) 2010, Guy Barrand. All rights reserved.
+// See the file tools.license for terms.
+
+#ifndef toolx_mpi_world
+#define toolx_mpi_world
+
+// code to wrap MPI global things by having an interface (toolx::mpi).
+
+#include <tools/impi_world>
+
+#include <mpi.h>
+
+#ifdef TOOLS_MEM
+#include <tools/mem>
+#endif
+
+namespace toolx {
+namespace mpi {
+
+class world : public virtual tools::impi_world {
+  typedef tools::impi_world parent;
+#ifdef TOOLS_MEM
+protected:
+  static const std::string& s_class() {
+    static const std::string s_v("toolx::mpi::world");
+    return s_v;
+  }
+#endif
+public:
+  virtual bool init(int* a_argc,char*** a_argv) {
+    if(::MPI_Init(a_argc,a_argv)!=MPI_SUCCESS) return false;
+    return true;
+  }
+  virtual bool rank(int& a_rank) const {
+    if(::MPI_Comm_rank(MPI_COMM_WORLD,&a_rank)!=MPI_SUCCESS) {a_rank=-1;return false;}
+    return true;
+  }
+  virtual bool size(int& a_size) const {
+    if(::MPI_Comm_size(MPI_COMM_WORLD,&a_size)!=MPI_SUCCESS) {a_size=0;return false;}
+    return true;
+  }
+  virtual bool processor_name(std::string& a_s) const {
+    char name[MPI_MAX_PROCESSOR_NAME];
+    int lname;
+    if(::MPI_Get_processor_name(name,&lname)!=MPI_SUCCESS) {a_s.clear();return false;}
+    a_s = std::string(name);
+    return true;
+  }
+public:
+  world() {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+  }
+  virtual ~world(){
+#ifdef TOOLS_MEM
+    tools::mem::decrement(s_class().c_str());
+#endif
+  }
+protected:
+  world(const world& a_from):parent(a_from) {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+  }
+  world& operator=(const world&) {return *this;}
+};
+
+}}
+
+#endif

source/externals/g4tools/include/toolx/mpi/wrmpi

@@ -0,0 +1,528 @@
+// Copyright (C) 2010, Guy Barrand. All rights reserved.
+// See the file tools.license for terms.
+
+#ifndef toolx_mpi_wrmpi
+#define toolx_mpi_wrmpi
+
+#include "wait_buffer"
+
+#include <tools/impi>
+#include <tools/vdata>
+#include <tools/realloc>
+#include <tools/mnmx>
+
+#ifdef TOOLS_MEM
+#include <tools/mem>
+#endif
+
+// the below must be in sync with tools/typedefs
+#ifdef _MSC_VER
+//typedef __int64 int64;
+//typedef unsigned __int64 uint64;
+#define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG_LONG
+#define TOOLX_MPI_INT64  MPI_LONG_LONG
+#elif defined(_LP64)
+// 64 Bit Platforms
+//typedef long int64;
+//typedef unsigned long uint64;
+#define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG
+#define TOOLX_MPI_INT64  MPI_LONG
+#else
+// 32-Bit Platforms
+//typedef long long int64;
+//typedef unsigned long long uint64;
+#define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG_LONG
+#define TOOLX_MPI_INT64  MPI_LONG_LONG
+#endif
+
+namespace toolx {
+namespace mpi {
+
+class wrmpi : public virtual tools::impi {
+  typedef tools::impi parent;
+public:
+  typedef unsigned int num_t;
+protected:
+  static const std::string& s_class() {
+    static const std::string s_v("toolx::mpi::wrmpi");
+    return s_v;
+  }
+public: //tools::impi
+  virtual bool pack(char a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(char));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(char) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(short a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(short));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_SHORT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(short) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(int a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(int));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(int) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(unsigned int a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(unsigned int));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(unsigned int) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(tools::uint64 a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(tools::uint64));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,TOOLX_MPI_UINT64,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(uint64) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(tools::int64 a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(tools::int64));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,TOOLX_MPI_INT64,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(int64) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(float a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(float));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_FLOAT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(float) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(double a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(double));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    if(::MPI_Pack(&a_val,1,MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(double) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool bpack(bool a_val) {
+    tools::uint32 sz = tools::uint32(sizeof(unsigned char));
+    if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
+    unsigned char val = a_val?1:0;
+    if(::MPI_Pack(&val,1,MPI_UNSIGNED_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(bool) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool spack(const std::string& a_s) {
+    if(!pack((num_t)a_s.size())) return false;
+    tools::uint32 sz = (tools::uint32)a_s.size();
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<char*>(a_s.c_str()),a_s.size(),MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(a_s.c_str(),a_s.size(),MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(std::string) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool vpack(const std::vector<unsigned int>& a_v) {
+    if(!pack((num_t)a_v.size())) return false;
+    tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(unsigned int));
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<unsigned int*>(tools::vec_data(a_v)),a_v.size(),
+                  MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(tools::vec_data(a_v),a_v.size(),MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<unsigned int>) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool vpack(const std::vector<int>& a_v) {
+    if(!pack((num_t)a_v.size())) return false;
+    tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(int));
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<int*>(tools::vec_data(a_v)),a_v.size(),MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(tools::vec_data(a_v),a_v.size(),MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<int>) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool vpack(const std::vector<double>& a_v) {
+    if(!pack((num_t)a_v.size())) return false;
+    tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(double));
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<double*>(tools::vec_data(a_v)),a_v.size(),MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(tools::vec_data(a_v),a_v.size(),MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<double>) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+  virtual bool pack(tools::uint32 a_size,const char* a_buffer) {
+    if(!pack((num_t)a_size)) return false;
+    tools::uint32 sz = (tools::uint32)(a_size*sizeof(char));
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<char*>(a_buffer),a_size,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(a_buffer,a_size,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(char*) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+
+  virtual bool pack(tools::uint32 a_size,const int* a_buffer) {
+    if(!pack((num_t)a_size)) return false;
+    tools::uint32 sz = (tools::uint32)(a_size*sizeof(int));
+    if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+    if(::MPI_Pack(const_cast<int*>(a_buffer),a_size,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#else
+    if(::MPI_Pack(a_buffer,a_size,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
+#endif
+      m_out << "toolx::mpi::wrmpi : MPI_Pack(int*) failed." << std::endl;
+      return false;
+    }
+    m_pos += sz;
+    return true;
+  }
+public: //tools::impi
+  virtual bool unpack(char& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_CHAR,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(char) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(short& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_SHORT,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(short) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(int& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_INT,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(int) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(unsigned int& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_UNSIGNED,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(unsigned int) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(tools::uint64& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,TOOLX_MPI_UINT64,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(uint64) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(tools::int64& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,TOOLX_MPI_INT64,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(int64) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(float& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_FLOAT,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(float) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(double& a_val) {
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_DOUBLE,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(double) failed." << std::endl;
+      a_val = 0;
+      return false;
+    }
+    return true;
+  }
+  virtual bool bunpack(bool& a_val) {
+    typedef unsigned char bool_t;
+    bool_t val;
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&val,1,MPI_UNSIGNED_CHAR,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(bool) failed." << std::endl;
+      a_val = false;
+      return false;
+    }
+    a_val = val==1?true:false;
+    return true;
+  }
+  virtual bool vunpack(std::vector<unsigned int>& a_v) {
+    num_t num;
+    if(!unpack(num)) {a_v.clear();return false;}
+    a_v.resize(num);
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,tools::vec_data(a_v),a_v.size(),MPI_UNSIGNED,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<unsigned int>) failed." << std::endl;
+      a_v.clear();
+      return false;
+    }
+    return true;
+  }
+  virtual bool vunpack(std::vector<int>& a_v) {
+    num_t num;
+    if(!unpack(num)) {a_v.clear();return false;}
+    a_v.resize(num);
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,tools::vec_data(a_v),a_v.size(),MPI_INT,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<int>) failed." << std::endl;
+      a_v.clear();
+      return false;
+    }
+    return true;
+  }
+  virtual bool vunpack(std::vector<double>& a_v) {
+    num_t num;
+    if(!unpack(num)) {a_v.clear();return false;}
+    a_v.resize(num);
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,tools::vec_data(a_v),a_v.size(),MPI_DOUBLE,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<double>) failed." << std::endl;
+      a_v.clear();
+      return false;
+    }
+    return true;
+  }
+  virtual bool sunpack(std::string& a_s) {
+    num_t num;
+    if(!unpack(num)) {a_s.clear();return false;}
+    a_s.resize(num);
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,const_cast<char*>(a_s.c_str()),a_s.size(),MPI_CHAR,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::string) failed." << std::endl;
+      a_s.clear();
+      return false;
+    }
+    return true;
+  }
+  virtual bool unpack(tools::uint32& a_size,char*& a_buffer) {
+    num_t num;
+    if(!unpack(num)) {a_size = 0;a_buffer = 0;return false;}
+    a_buffer = new char[num];
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_buffer,num,MPI_CHAR,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(char*) failed." << std::endl;
+      delete [] a_buffer;
+      a_size = 0;
+      a_buffer = 0;
+      return false;
+    }
+    a_size = num;
+    return true;
+  }
+  virtual bool unpack(tools::uint32& a_size,int*& a_buffer) {
+    num_t num;
+    if(!unpack(num)) {a_size = 0;a_buffer = 0;return false;}
+    a_buffer = new int[num];
+    if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_buffer,num,MPI_INT,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi : MPI_Unpack(int*) failed." << std::endl;
+      delete [] a_buffer;
+      a_size = 0;
+      a_buffer = 0;
+      return false;
+    }
+    a_size = num;
+    return true;
+  }
+
+  virtual void pack_reset() {
+    delete [] m_buffer;
+    m_size = 128;
+    m_buffer = new char[m_size];
+    //if(!m_buffer) {}
+    m_max = m_buffer+m_size;
+    m_pos = m_buffer;
+    m_ipos = 0; //IMPORTANT
+  }
+
+  virtual bool send_buffer(int a_dest,int a_tag) { // used in tools/mpi/pntuple.
+    if(::MPI_Send(m_buffer,m_ipos,MPI_CHAR,a_dest,a_tag,m_comm)!=MPI_SUCCESS) {
+      m_out << "toolx::mpi::wrmpi::send_buffer : MPI_Send() failed for rank destination " << a_dest << "." << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool wait_buffer(int a_rank,int a_src,int a_tag,int& a_probe_src,bool a_verbose = false) {
+    int buffer_size = 0;
+    char* _buffer = 0;
+    if (!mpi::wait_buffer(m_out,a_rank,a_src,a_tag,m_comm,buffer_size,_buffer,a_probe_src,a_verbose)) {
+      m_out << "toolx::mpi::wrmpi::wait_buffer : failed for rank " << a_rank << " and source " << a_src <<"." << std::endl;
+      return false;
+    }
+    // we take ownership of buffer :
+    delete [] m_buffer;
+    m_size = buffer_size;
+    m_buffer = _buffer;
+    m_max = m_buffer+m_size;
+    m_pos = m_buffer;
+    m_ipos = 0; //IMPORTANT
+    return true;
+  }
+
+  virtual bool wait_buffer(int a_rank,int a_tag,int& a_probe_src,bool a_verbose = false) {
+    return wait_buffer(a_rank,MPI_ANY_SOURCE,a_tag,a_probe_src,a_verbose);
+  }
+
+public:
+  wrmpi(std::ostream& a_out,const MPI_Comm& a_comm,tools::uint32 a_size = 128) // we expect a_size!=0
+  :m_out(a_out)
+  ,m_comm(a_comm)
+  ,m_size(0)
+  ,m_buffer(0)
+  ,m_max(0)
+  ,m_pos(0)
+  ,m_ipos(0)
+  {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+    m_size = a_size;
+    m_buffer = new char[m_size];
+    //if(!m_buffer) {}
+    m_max = m_buffer+m_size;
+    m_pos = m_buffer;
+  }
+   wrmpi(std::ostream& a_out,const MPI_Comm& a_comm,tools::uint32 a_size,char* a_buffer) //we take ownership of a_buffer.
+  :m_out(a_out)
+  ,m_comm(a_comm)
+  ,m_size(a_size)
+  ,m_buffer(a_buffer)
+  ,m_max(0)
+  ,m_pos(0)
+  ,m_ipos(0)
+  {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+    m_max = m_buffer+m_size;
+    m_pos = m_buffer;
+  }
+  virtual ~wrmpi(){
+    delete [] m_buffer;
+#ifdef TOOLS_MEM
+    tools::mem::decrement(s_class().c_str());
+#endif
+  }
+protected:
+  wrmpi(const wrmpi& a_from)
+  :parent(a_from)
+  ,m_out(a_from.m_out)
+  ,m_comm(a_from.m_comm)
+  ,m_size(0)
+  ,m_buffer(0)
+  ,m_max(0)
+  ,m_pos(0)
+  ,m_ipos(0)
+  {
+#ifdef TOOLS_MEM
+    tools::mem::increment(s_class().c_str());
+#endif
+  }
+  wrmpi& operator=(const wrmpi&){return *this;}
+public:
+  int ipos() const {return m_ipos;}
+#if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
+  char* buffer() {return m_buffer;}
+#else
+  const char* buffer() const {return m_buffer;}
+#endif
+
+protected:
+  bool expand2(tools::uint32 a_new_size) {return expand(tools::mx<tools::uint32>(2*m_size,a_new_size));} //CERN-ROOT logic.
+
+  bool expand(tools::uint32 a_new_size) {
+    tools::diff_pointer_t len = m_pos-m_buffer;
+    if(!tools::realloc<char>(m_buffer,a_new_size,m_size)) {
+      m_out << "toolx::mpi::wrmpi::expand :"
+            << " can't realloc " << a_new_size << " bytes."
+            << std::endl;
+      m_size = 0;
+      m_max = 0;
+      m_pos = 0;
+      //m_wb.set_eob(m_max);
+      return false;
+    }
+    m_size = a_new_size;
+    m_max = m_buffer + m_size;
+    m_pos = m_buffer + len;
+    return true;
+  }
+
+protected:
+  std::ostream& m_out;
+  const MPI_Comm& m_comm;
+  tools::uint32 m_size;
+  char* m_buffer;
+  char* m_max;
+  char* m_pos;
+  //
+  int m_ipos;
+};
+
+}}
+
+#ifdef TOOLX_MPI_UINT64
+#undef TOOLX_MPI_UINT64
+#endif
+
+#ifdef TOOLX_MPI_INT64
+#undef TOOLX_MPI_INT64
+#endif
+
+#endif