Warning, /include/Geant4/toolx/mpi/wrmpi is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef toolx_mpi_wrmpi
0005 #define toolx_mpi_wrmpi
0006
0007 #include "wait_buffer"
0008
0009 #include <tools/impi>
0010 #include <tools/cmemT>
0011 #include <tools/mnmx>
0012
0013 // the below must be in sync with tools/typedefs
0014 #if defined(_MSC_VER) || defined(__MINGW32__)
0015 #define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG_LONG
0016 #define TOOLX_MPI_INT64 MPI_LONG_LONG
0017 #elif defined(_LP64)
0018 // 64 Bit Platforms
0019 #define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG
0020 #define TOOLX_MPI_INT64 MPI_LONG
0021 #else
0022 // 32-Bit Platforms
0023 #define TOOLX_MPI_UINT64 MPI_UNSIGNED_LONG_LONG
0024 #define TOOLX_MPI_INT64 MPI_LONG_LONG
0025 #endif
0026
0027 namespace toolx {
0028 namespace mpi {
0029
0030 class wrmpi : public virtual tools::impi {
0031 typedef tools::impi parent;
0032 public:
0033 typedef unsigned int num_t;
0034 protected:
0035 static const std::string& s_class() {
0036 static const std::string s_v("toolx::mpi::wrmpi");
0037 return s_v;
0038 }
0039 public: //tools::impi
0040 virtual bool pack(char a_val) {
0041 tools::uint32 sz = tools::uint32(sizeof(char));
0042 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0043 if(::MPI_Pack(&a_val,1,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0044 m_out << "toolx::mpi::wrmpi : MPI_Pack(char) failed." << std::endl;
0045 return false;
0046 }
0047 m_pos += sz;
0048 return true;
0049 }
0050 virtual bool pack(short a_val) {
0051 tools::uint32 sz = tools::uint32(sizeof(short));
0052 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0053 if(::MPI_Pack(&a_val,1,MPI_SHORT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0054 m_out << "toolx::mpi::wrmpi : MPI_Pack(short) failed." << std::endl;
0055 return false;
0056 }
0057 m_pos += sz;
0058 return true;
0059 }
0060 virtual bool pack(int a_val) {
0061 tools::uint32 sz = tools::uint32(sizeof(int));
0062 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0063 if(::MPI_Pack(&a_val,1,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0064 m_out << "toolx::mpi::wrmpi : MPI_Pack(int) failed." << std::endl;
0065 return false;
0066 }
0067 m_pos += sz;
0068 return true;
0069 }
0070 virtual bool pack(unsigned int a_val) {
0071 tools::uint32 sz = tools::uint32(sizeof(unsigned int));
0072 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0073 if(::MPI_Pack(&a_val,1,MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0074 m_out << "toolx::mpi::wrmpi : MPI_Pack(unsigned int) failed." << std::endl;
0075 return false;
0076 }
0077 m_pos += sz;
0078 return true;
0079 }
0080 virtual bool pack(tools::uint64 a_val) {
0081 tools::uint32 sz = tools::uint32(sizeof(tools::uint64));
0082 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0083 if(::MPI_Pack(&a_val,1,TOOLX_MPI_UINT64,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0084 m_out << "toolx::mpi::wrmpi : MPI_Pack(uint64) failed." << std::endl;
0085 return false;
0086 }
0087 m_pos += sz;
0088 return true;
0089 }
0090 virtual bool pack(tools::int64 a_val) {
0091 tools::uint32 sz = tools::uint32(sizeof(tools::int64));
0092 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0093 if(::MPI_Pack(&a_val,1,TOOLX_MPI_INT64,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0094 m_out << "toolx::mpi::wrmpi : MPI_Pack(int64) failed." << std::endl;
0095 return false;
0096 }
0097 m_pos += sz;
0098 return true;
0099 }
0100 virtual bool pack(float a_val) {
0101 tools::uint32 sz = tools::uint32(sizeof(float));
0102 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0103 if(::MPI_Pack(&a_val,1,MPI_FLOAT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0104 m_out << "toolx::mpi::wrmpi : MPI_Pack(float) failed." << std::endl;
0105 return false;
0106 }
0107 m_pos += sz;
0108 return true;
0109 }
0110 virtual bool pack(double a_val) {
0111 tools::uint32 sz = tools::uint32(sizeof(double));
0112 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0113 if(::MPI_Pack(&a_val,1,MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0114 m_out << "toolx::mpi::wrmpi : MPI_Pack(double) failed." << std::endl;
0115 return false;
0116 }
0117 m_pos += sz;
0118 return true;
0119 }
0120 virtual bool bpack(bool a_val) {
0121 tools::uint32 sz = tools::uint32(sizeof(unsigned char));
0122 if(m_pos+sz>m_max) {if(!expand2(m_size+sz)) return false;}
0123 unsigned char val = a_val?1:0;
0124 if(::MPI_Pack(&val,1,MPI_UNSIGNED_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0125 m_out << "toolx::mpi::wrmpi : MPI_Pack(bool) failed." << std::endl;
0126 return false;
0127 }
0128 m_pos += sz;
0129 return true;
0130 }
0131 virtual bool spack(const std::string& a_s) {
0132 if(!pack((num_t)a_s.size())) return false;
0133 tools::uint32 sz = (tools::uint32)a_s.size();
0134 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0135 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0136 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) {
0137 #else
0138 if(::MPI_Pack(a_s.c_str(),a_s.size(),MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0139 #endif
0140 m_out << "toolx::mpi::wrmpi : MPI_Pack(std::string) failed." << std::endl;
0141 return false;
0142 }
0143 m_pos += sz;
0144 return true;
0145 }
0146 virtual bool vpack(const std::vector<unsigned int>& a_v) {
0147 if(!pack((num_t)a_v.size())) return false;
0148 tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(unsigned int));
0149 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0150 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0151 if(::MPI_Pack(const_cast<unsigned int*>(a_v.data()),a_v.size(),
0152 MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0153 #else
0154 if(::MPI_Pack(a_v.data(),a_v.size(),MPI_UNSIGNED,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0155 #endif
0156 m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<unsigned int>) failed." << std::endl;
0157 return false;
0158 }
0159 m_pos += sz;
0160 return true;
0161 }
0162 virtual bool vpack(const std::vector<int>& a_v) {
0163 if(!pack((num_t)a_v.size())) return false;
0164 tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(int));
0165 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0166 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0167 if(::MPI_Pack(const_cast<int*>(a_v.data()),a_v.size(),MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0168 #else
0169 if(::MPI_Pack(a_v.data(),a_v.size(),MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0170 #endif
0171 m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<int>) failed." << std::endl;
0172 return false;
0173 }
0174 m_pos += sz;
0175 return true;
0176 }
0177 virtual bool vpack(const std::vector<double>& a_v) {
0178 if(!pack((num_t)a_v.size())) return false;
0179 tools::uint32 sz = (tools::uint32)(a_v.size()*sizeof(double));
0180 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0181 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0182 if(::MPI_Pack(const_cast<double*>(a_v.data()),a_v.size(),MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0183 #else
0184 if(::MPI_Pack(a_v.data(),a_v.size(),MPI_DOUBLE,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0185 #endif
0186 m_out << "toolx::mpi::wrmpi : MPI_Pack(std::vector<double>) failed." << std::endl;
0187 return false;
0188 }
0189 m_pos += sz;
0190 return true;
0191 }
0192 virtual bool pack(tools::uint32 a_size,const char* a_buffer) {
0193 if(!pack((num_t)a_size)) return false;
0194 tools::uint32 sz = (tools::uint32)(a_size*sizeof(char));
0195 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0196 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0197 if(::MPI_Pack(const_cast<char*>(a_buffer),a_size,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0198 #else
0199 if(::MPI_Pack(a_buffer,a_size,MPI_CHAR,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0200 #endif
0201 m_out << "toolx::mpi::wrmpi : MPI_Pack(char*) failed." << std::endl;
0202 return false;
0203 }
0204 m_pos += sz;
0205 return true;
0206 }
0207
0208 virtual bool pack(tools::uint32 a_size,const int* a_buffer) {
0209 if(!pack((num_t)a_size)) return false;
0210 tools::uint32 sz = (tools::uint32)(a_size*sizeof(int));
0211 if((m_pos+sz)>m_max) {if(!expand2(m_size+sz)) return false;}
0212 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0213 if(::MPI_Pack(const_cast<int*>(a_buffer),a_size,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0214 #else
0215 if(::MPI_Pack(a_buffer,a_size,MPI_INT,m_buffer,m_size,&m_ipos,m_comm)!=MPI_SUCCESS) {
0216 #endif
0217 m_out << "toolx::mpi::wrmpi : MPI_Pack(int*) failed." << std::endl;
0218 return false;
0219 }
0220 m_pos += sz;
0221 return true;
0222 }
0223 public: //tools::impi
0224 virtual bool unpack(char& a_val) {
0225 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_CHAR,m_comm)!=MPI_SUCCESS) {
0226 m_out << "toolx::mpi::wrmpi : MPI_Unpack(char) failed." << std::endl;
0227 a_val = 0;
0228 return false;
0229 }
0230 return true;
0231 }
0232 virtual bool unpack(short& a_val) {
0233 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_SHORT,m_comm)!=MPI_SUCCESS) {
0234 m_out << "toolx::mpi::wrmpi : MPI_Unpack(short) failed." << std::endl;
0235 a_val = 0;
0236 return false;
0237 }
0238 return true;
0239 }
0240 virtual bool unpack(int& a_val) {
0241 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_INT,m_comm)!=MPI_SUCCESS) {
0242 m_out << "toolx::mpi::wrmpi : MPI_Unpack(int) failed." << std::endl;
0243 a_val = 0;
0244 return false;
0245 }
0246 return true;
0247 }
0248 virtual bool unpack(unsigned int& a_val) {
0249 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_UNSIGNED,m_comm)!=MPI_SUCCESS) {
0250 m_out << "toolx::mpi::wrmpi : MPI_Unpack(unsigned int) failed." << std::endl;
0251 a_val = 0;
0252 return false;
0253 }
0254 return true;
0255 }
0256 virtual bool unpack(tools::uint64& a_val) {
0257 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,TOOLX_MPI_UINT64,m_comm)!=MPI_SUCCESS) {
0258 m_out << "toolx::mpi::wrmpi : MPI_Unpack(uint64) failed." << std::endl;
0259 a_val = 0;
0260 return false;
0261 }
0262 return true;
0263 }
0264 virtual bool unpack(tools::int64& a_val) {
0265 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,TOOLX_MPI_INT64,m_comm)!=MPI_SUCCESS) {
0266 m_out << "toolx::mpi::wrmpi : MPI_Unpack(int64) failed." << std::endl;
0267 a_val = 0;
0268 return false;
0269 }
0270 return true;
0271 }
0272 virtual bool unpack(float& a_val) {
0273 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_FLOAT,m_comm)!=MPI_SUCCESS) {
0274 m_out << "toolx::mpi::wrmpi : MPI_Unpack(float) failed." << std::endl;
0275 a_val = 0;
0276 return false;
0277 }
0278 return true;
0279 }
0280 virtual bool unpack(double& a_val) {
0281 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&a_val,1,MPI_DOUBLE,m_comm)!=MPI_SUCCESS) {
0282 m_out << "toolx::mpi::wrmpi : MPI_Unpack(double) failed." << std::endl;
0283 a_val = 0;
0284 return false;
0285 }
0286 return true;
0287 }
0288 virtual bool bunpack(bool& a_val) {
0289 typedef unsigned char bool_t;
0290 bool_t val;
0291 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,&val,1,MPI_UNSIGNED_CHAR,m_comm)!=MPI_SUCCESS) {
0292 m_out << "toolx::mpi::wrmpi : MPI_Unpack(bool) failed." << std::endl;
0293 a_val = false;
0294 return false;
0295 }
0296 a_val = val==1?true:false;
0297 return true;
0298 }
0299 virtual bool vunpack(std::vector<unsigned int>& a_v) {
0300 num_t num;
0301 if(!unpack(num)) {a_v.clear();return false;}
0302 a_v.resize(num);
0303 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_v.data(),a_v.size(),MPI_UNSIGNED,m_comm)!=MPI_SUCCESS) {
0304 m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<unsigned int>) failed." << std::endl;
0305 a_v.clear();
0306 return false;
0307 }
0308 return true;
0309 }
0310 virtual bool vunpack(std::vector<int>& a_v) {
0311 num_t num;
0312 if(!unpack(num)) {a_v.clear();return false;}
0313 a_v.resize(num);
0314 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_v.data(),a_v.size(),MPI_INT,m_comm)!=MPI_SUCCESS) {
0315 m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<int>) failed." << std::endl;
0316 a_v.clear();
0317 return false;
0318 }
0319 return true;
0320 }
0321 virtual bool vunpack(std::vector<double>& a_v) {
0322 num_t num;
0323 if(!unpack(num)) {a_v.clear();return false;}
0324 a_v.resize(num);
0325 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_v.data(),a_v.size(),MPI_DOUBLE,m_comm)!=MPI_SUCCESS) {
0326 m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::vector<double>) failed." << std::endl;
0327 a_v.clear();
0328 return false;
0329 }
0330 return true;
0331 }
0332 virtual bool sunpack(std::string& a_s) {
0333 num_t num;
0334 if(!unpack(num)) {a_s.clear();return false;}
0335 a_s.resize(num);
0336 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) {
0337 m_out << "toolx::mpi::wrmpi : MPI_Unpack(std::string) failed." << std::endl;
0338 a_s.clear();
0339 return false;
0340 }
0341 return true;
0342 }
0343 virtual bool unpack(tools::uint32& a_size,char*& a_buffer) {
0344 num_t num;
0345 if(!unpack(num)) {a_size = 0;a_buffer = 0;return false;}
0346 a_buffer = new char[num];
0347 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_buffer,num,MPI_CHAR,m_comm)!=MPI_SUCCESS) {
0348 m_out << "toolx::mpi::wrmpi : MPI_Unpack(char*) failed." << std::endl;
0349 delete [] a_buffer;
0350 a_size = 0;
0351 a_buffer = 0;
0352 return false;
0353 }
0354 a_size = num;
0355 return true;
0356 }
0357 virtual bool unpack(tools::uint32& a_size,int*& a_buffer) {
0358 num_t num;
0359 if(!unpack(num)) {a_size = 0;a_buffer = 0;return false;}
0360 a_buffer = new int[num];
0361 if(::MPI_Unpack(m_buffer,m_size,&m_ipos,a_buffer,num,MPI_INT,m_comm)!=MPI_SUCCESS) {
0362 m_out << "toolx::mpi::wrmpi : MPI_Unpack(int*) failed." << std::endl;
0363 delete [] a_buffer;
0364 a_size = 0;
0365 a_buffer = 0;
0366 return false;
0367 }
0368 a_size = num;
0369 return true;
0370 }
0371
0372 virtual void pack_reset() {
0373 delete [] m_buffer;
0374 m_size = 128;
0375 m_buffer = new char[m_size];
0376 m_max = m_buffer+m_size;
0377 m_pos = m_buffer;
0378 m_ipos = 0; //IMPORTANT
0379 }
0380
0381 virtual bool send_buffer(int a_dest,int a_tag) { // used in tools/mpi/pntuple.
0382 if(::MPI_Send(m_buffer,m_ipos,MPI_CHAR,a_dest,a_tag,m_comm)!=MPI_SUCCESS) {
0383 m_out << "toolx::mpi::wrmpi::send_buffer : MPI_Send() failed for rank destination " << a_dest << "." << std::endl;
0384 return false;
0385 }
0386 return true;
0387 }
0388
0389 virtual bool wait_buffer(int a_rank,int a_src,int a_tag,int& a_probe_src,bool a_verbose = false) {
0390 int buffer_size = 0;
0391 char* _buffer = 0;
0392 if (!mpi::wait_buffer(m_out,a_rank,a_src,a_tag,m_comm,buffer_size,_buffer,a_probe_src,a_verbose)) {
0393 m_out << "toolx::mpi::wrmpi::wait_buffer : failed for rank " << a_rank << " and source " << a_src <<"." << std::endl;
0394 return false;
0395 }
0396 // we take ownership of buffer :
0397 delete [] m_buffer;
0398 m_size = buffer_size;
0399 m_buffer = _buffer;
0400 m_max = m_buffer+m_size;
0401 m_pos = m_buffer;
0402 m_ipos = 0; //IMPORTANT
0403 return true;
0404 }
0405
0406 virtual bool wait_buffer(int a_rank,int a_tag,int& a_probe_src,bool a_verbose = false) {
0407 return wait_buffer(a_rank,MPI_ANY_SOURCE,a_tag,a_probe_src,a_verbose);
0408 }
0409
0410 public:
0411 wrmpi(std::ostream& a_out,const MPI_Comm& a_comm,tools::uint32 a_size = 128) // we expect a_size!=0
0412 :m_out(a_out)
0413 ,m_comm(a_comm)
0414 ,m_size(0)
0415 ,m_buffer(0)
0416 ,m_max(0)
0417 ,m_pos(0)
0418 ,m_ipos(0)
0419 {
0420 m_size = a_size;
0421 m_buffer = new char[m_size];
0422 //if(!m_buffer) {}
0423 m_max = m_buffer+m_size;
0424 m_pos = m_buffer;
0425 }
0426 wrmpi(std::ostream& a_out,const MPI_Comm& a_comm,tools::uint32 a_size,char* a_buffer) //we take ownership of a_buffer.
0427 :m_out(a_out)
0428 ,m_comm(a_comm)
0429 ,m_size(a_size)
0430 ,m_buffer(a_buffer)
0431 ,m_max(0)
0432 ,m_pos(0)
0433 ,m_ipos(0)
0434 {
0435 m_max = m_buffer+m_size;
0436 m_pos = m_buffer;
0437 }
0438 virtual ~wrmpi(){
0439 delete [] m_buffer;
0440 }
0441 protected:
0442 wrmpi(const wrmpi& a_from)
0443 :parent(a_from)
0444 ,m_out(a_from.m_out)
0445 ,m_comm(a_from.m_comm)
0446 ,m_size(0)
0447 ,m_buffer(0)
0448 ,m_max(0)
0449 ,m_pos(0)
0450 ,m_ipos(0)
0451 {
0452 }
0453 wrmpi& operator=(const wrmpi&){return *this;}
0454 public:
0455 int ipos() const {return m_ipos;}
0456 #if defined(TOOLX_USE_MPI_PACK_NOT_CONST) || defined(TOOLS_USE_MPI_PACK_NOT_CONST)
0457 char* buffer() {return m_buffer;}
0458 #else
0459 const char* buffer() const {return m_buffer;}
0460 #endif
0461
0462 protected:
0463 bool expand2(tools::uint32 a_new_size) {return expand(tools::max_of<tools::uint32>(2*m_size,a_new_size));} //CERN-ROOT logic.
0464
0465 bool expand(tools::uint32 a_new_size) {
0466 tools::diff_pointer_t len = m_pos-m_buffer;
0467 if(!tools::cmem_realloc<char>(m_buffer,a_new_size,m_size)) {
0468 m_out << "toolx::mpi::wrmpi::expand :"
0469 << " can't realloc " << a_new_size << " bytes."
0470 << std::endl;
0471 m_size = 0;
0472 m_max = 0;
0473 m_pos = 0;
0474 return false;
0475 }
0476 m_size = a_new_size;
0477 m_max = m_buffer + m_size;
0478 m_pos = m_buffer + len;
0479 return true;
0480 }
0481
0482 protected:
0483 std::ostream& m_out;
0484 const MPI_Comm& m_comm;
0485 tools::uint32 m_size;
0486 char* m_buffer;
0487 char* m_max;
0488 char* m_pos;
0489 //
0490 int m_ipos;
0491 };
0492
0493 }}
0494
0495 #ifdef TOOLX_MPI_UINT64
0496 #undef TOOLX_MPI_UINT64
0497 #endif
0498
0499 #ifdef TOOLX_MPI_INT64
0500 #undef TOOLX_MPI_INT64
0501 #endif
0502
0503 #endif
