BCP_buffer Class Reference

#include <BCP_buffer.hpp>

List of all members.

Public Member Functions
Query methods
BCP_message_tag	msgtag () const
const BCP_proc_id *	sender () const
int	size () const
const char *	data () const
Modifying methods
void	set_position (const int pos) throw (BCP_fatal_error)
void	set_msgtag (const BCP_message_tag tag)
void	set_content (const char *data, const size_t size, BCP_proc_id *sender, BCP_message_tag msgtag)
BCP_buffer &	operator= (const BCP_buffer &buf)
void	make_fit (const int add_size)
void	clear ()
template<class T> BCP_buffer &	pack (const T &value)
template<class T> BCP_buffer &	unpack (T &value)
template<class T> BCP_buffer &	pack (const T *const values, const int length)
template<class T> BCP_buffer &	unpack (T *&values, int &length, bool allocate=true) throw (BCP_fatal_error)
BCP_buffer &	pack (const BCP_string &value)
BCP_buffer &	pack (BCP_string &value)
BCP_buffer &	unpack (BCP_string &value)
template<class T> BCP_buffer &	pack (const BCP_vec< T > &vec)
template<class T> BCP_buffer &	pack (const typename std::vector< T > &vec)
template<class T> BCP_buffer &	unpack (BCP_vec< T > &vec)
template<class T> BCP_buffer &	unpack (typename std::vector< T > &vec)
Constructors and destructor
	BCP_buffer ()
	BCP_buffer (const BCP_buffer &buf)
	~BCP_buffer ()
Public Attributes
Data members
The data members are public for efficiency reasons. Access these fields sparingly. THINK: maybe it's not that inefficient to access the fields thru functions... Note that: The size of the buffer never decreases. The buffer size increases when the current size is not sufficient for the message. With normal usage for incoming messages _size stays constant while reading out the message and _pos moves forward in the buffer. With normal usage for outgoing messages _size and _pos moves forward together as the buffer is filled with the message.
BCP_message_tag	_msgtag
BCP_proc_id *	_sender
size_t	_pos
size_t	_max_size
size_t	_size
char *	_data

---

Detailed Description

This class describes the message buffer used for all processes of BCP. This buffer is a character array; the components of a message are simply copied into this array one after the other. Note that each process has only one buffer, which serves both for outgoing and incoming messages. This can be done since when a message arrives it is completely unpacked before anything else is done and conversely, once a message is started to be packed together it will be sent out before another message is received.

NOTE: Only the following type of objects can be packed with the various pack() member methods:

• Objects that can be assigned with memcpy(), i.e., built-in non-pointer types, and structs recursively built from such types;
• BCP_vecs of the above and
• BCP_strings.

Everything else that needs to be packed at any time must have a pack() member method.

Definition at line 39 of file BCP_buffer.hpp.

---

Constructor & Destructor Documentation

BCP_buffer::BCP_buffer (   )  [inline]

The default constructor creates a buffer of size 16 Kbytes with no message in it. Definition at line 372 of file BCP_buffer.hpp. References _data, _max_size, _msgtag, _pos, _sender, and _size. : _msgtag(BCP_Msg_NoMessage), _sender(0), _pos(0), _max_size(0x4000/*16K*/), _size(0), _data(new char[_max_size]) {}

BCP_buffer::BCP_buffer (  const BCP_buffer &  buf  )  [inline]

The copy constructor makes an exact replica of the other buffer. Definition at line 375 of file BCP_buffer.hpp. References _data, _max_size, _msgtag, _pos, _sender, _size, and operator=(). : _msgtag(BCP_Msg_NoMessage), _sender(0), _pos(0), _max_size(0), _size(0), _data(0){ operator=(buf); }

BCP_buffer::~BCP_buffer (   )  [inline]

The desctructor deletes all data members (including freeing the buffer). Definition at line 382 of file BCP_buffer.hpp. References _data, and _sender. { delete _sender; _sender = 0; delete[] _data; }

---

Member Function Documentation

void BCP_buffer::clear (   )  [inline]

Completely clear the buffer. Delete and zero out _msgtag, _size, _pos and _sender. Definition at line 159 of file BCP_buffer.hpp. References _msgtag, _pos, _sender, and _size. Referenced by BCP_cg_user::send_cut(), and BCP_vg_user::send_var(). { _msgtag = BCP_Msg_NoMessage; _size = 0; _pos = 0; delete _sender; _sender = 0; }

const char* BCP_buffer::data (   )  const [inline]

Return a const pointer to the data stored in the buffer. Definition at line 96 of file BCP_buffer.hpp. References _data. { return _data; }

void BCP_buffer::make_fit (  const int  add_size  )  [inline]

Reallocate the buffer if necessary so that at least add_size number of additional bytes will fit into the buffer. Definition at line 147 of file BCP_buffer.hpp. References _data, _max_size, and _size. Referenced by pack(). { if (_max_size < _size + add_size){ _max_size = 2 * (_size + add_size + 0x1000/*4K*/); char *new_data = new char[_max_size]; if (_size) memcpy(new_data, _data, _size); delete[] _data; _data = new_data; } }

BCP_message_tag BCP_buffer::msgtag (   )  const [inline]

Return the message tag of the message in the buffer. Definition at line 89 of file BCP_buffer.hpp. References _msgtag. Referenced by BCP_vg_user::unpack_dual_solution(), and BCP_cg_user::unpack_primal_solution(). { return _msgtag; }

BCP_buffer& BCP_buffer::operator= (  const BCP_buffer &  buf  )  [inline]

Make an exact replica of the other buffer. Definition at line 130 of file BCP_buffer.hpp. References _data, _max_size, _msgtag, _pos, _sender, _size, and BCP_proc_id::clone(). Referenced by BCP_buffer(). { _msgtag = buf._msgtag; _sender = buf._sender ? buf._sender->clone() : 0; _pos = buf._pos; if (_max_size < buf._max_size) { delete[] _data; _data = new char[buf._max_size]; _max_size = buf._max_size; } _size = buf._size; if (_size) memcpy(_data, buf._data, _size * sizeof(char)); return *this; }

template<class T> BCP_buffer& BCP_buffer::pack (  const typename std::vector< T > &  vec  )  [inline]

Pack a std::vector into the buffer. Definition at line 309 of file BCP_buffer.hpp. References _data, _size, make_fit(), and size(). { int objnum = vec.size(); int new_bytes = objnum * sizeof(T); make_fit( sizeof(int) + new_bytes ); memcpy(_data + _size, &objnum, sizeof(int)); _size += sizeof(int); if (objnum > 0){ memcpy(_data + _size, &vec[0], new_bytes); _size += new_bytes; } return *this; }

template<class T> BCP_buffer& BCP_buffer::pack (  const BCP_vec< T > &  vec  )  [inline]

Pack a BCP_vec into the buffer. Definition at line 295 of file BCP_buffer.hpp. References _data, _size, BCP_vec< T >::begin(), make_fit(), and BCP_vec< T >::size(). { int objnum = vec.size(); int new_bytes = objnum * sizeof(T); make_fit( sizeof(int) + new_bytes ); memcpy(_data + _size, &objnum, sizeof(int)); _size += sizeof(int); if (objnum > 0){ memcpy(_data + _size, vec.begin(), new_bytes); _size += new_bytes; } return *this; }

BCP_buffer& BCP_buffer::pack (  BCP_string &  value  )  [inline]

Pack a BCP_string into the buffer. Definition at line 272 of file BCP_buffer.hpp. References _data, _size, BCP_string::c_str(), BCP_string::length(), and make_fit(). { // must define here, 'cos in BCP_message.C we have only templated members int len = value.length(); make_fit( sizeof(int) + len ); memcpy(_data + _size, &len, sizeof(int)); _size += sizeof(int); if (len > 0){ memcpy(_data + _size, value.c_str(), len); _size += len; } return *this; }

BCP_buffer& BCP_buffer::pack (  const BCP_string &  value  )  [inline]

Pack a BCP_string into the buffer. Definition at line 259 of file BCP_buffer.hpp. References _data, _size, BCP_string::c_str(), BCP_string::length(), and make_fit(). { // must define here, 'cos in BCP_message.C we have only templated members int len = value.length(); make_fit( sizeof(int) + len ); memcpy(_data + _size, &len, sizeof(int)); _size += sizeof(int); if (len > 0){ memcpy(_data + _size, value.c_str(), len); _size += len; } return *this; }

template<class T> BCP_buffer& BCP_buffer::pack (  const T *const  values, const int  length )  [inline]

Pack a C style array of objects of type T. Definition at line 188 of file BCP_buffer.hpp. References _data, _size, and make_fit(). { make_fit( sizeof(int) + sizeof(T) * length ); memcpy(_data + _size, &length, sizeof(int)); _size += sizeof(int); if (length > 0){ memcpy(_data + _size, values, sizeof(T) * length); _size += sizeof(T) * length; } return *this; }

template<class T> BCP_buffer& BCP_buffer::pack (  const T &  value  )  [inline]

Pack a single object of type T. Copies sizeof(T) bytes from the address of the object. Definition at line 168 of file BCP_buffer.hpp. References _data, _size, and make_fit(). Referenced by BCP_vec_change< char >::pack(), BCP_problem_core_change::pack(), BCP_problem_core::pack(), BCP_parameter_set< BCP_tm_par >::pack(), BCP_lp_relax::pack(), BCP_internal_brobj::pack(), BCP_lp_user::pack_dual_solution(), BCP_lp_user::pack_feasible_solution(), BCP_lp_user::pack_primal_solution(), BCP_cg_user::send_cut(), and BCP_vg_user::send_var(). { make_fit( sizeof(T) ); memcpy(_data + _size, &value, sizeof(T)); _size += sizeof(T); return *this; }

const BCP_proc_id* BCP_buffer::sender (   )  const [inline]

Return a const pointer to the process id of the sender of the message in the buffer. Definition at line 92 of file BCP_buffer.hpp. References _sender. { return _sender; }

void BCP_buffer::set_content (  const char *  data, const size_t  size, BCP_proc_id *  sender, BCP_message_tag  msgtag )  [inline]

Set the buffer to be a copy of the given data. Use this with care! Definition at line 113 of file BCP_buffer.hpp. References _data, _max_size, _msgtag, _pos, _sender, and _size. { _sender = sender; _msgtag = msgtag; if (_max_size < size) { delete[] _data; _data = new char[size]; _max_size = size; } _pos = 0; _size = size; if (_size) memcpy(_data, data, size * sizeof(char)); }

void BCP_buffer::set_msgtag (  const BCP_message_tag  tag  )  [inline]

Set the message tag on the buffer Definition at line 110 of file BCP_buffer.hpp. References _msgtag. Referenced by BCP_lp_user::pack_dual_solution(), and BCP_lp_user::pack_primal_solution(). { _msgtag = tag; }

void BCP_buffer::set_position (  const int  pos  )  throw (BCP_fatal_error) [inline]

Position the read/write head in the buffer. Must be between 0 and size(). Definition at line 104 of file BCP_buffer.hpp. References _pos, and size(). { if (pos < 0 || pos >= size()) throw BCP_fatal_error("Incorrest buffer position setting.\n"); _pos = pos; }

int BCP_buffer::size (   )  const [inline]

Return the size of the current message in the buffer. Definition at line 94 of file BCP_buffer.hpp. References _size. Referenced by pack(), and set_position(). { return _size; }

template<class T> BCP_buffer& BCP_buffer::unpack (  typename std::vector< T > &  vec  )  [inline]

Unpack a std::vector from the buffer. Definition at line 345 of file BCP_buffer.hpp. References _data, _pos, and _size. { int objnum; #ifdef PARANOID if (_pos + sizeof(int) > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(&objnum, _data + _pos, sizeof(int)); _pos += sizeof(int); vec.clear(); if (objnum > 0){ #ifdef PARANOID if (_pos + sizeof(T)*objnum > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif vec.insert(vec.end(), objnum, T()); memcpy(&vec[0], _data + _pos, objnum * sizeof(T)); _pos += objnum * sizeof(T); } return *this; }

template<class T> BCP_buffer& BCP_buffer::unpack (  BCP_vec< T > &  vec  )  [inline]

Unpack a BCP_vec from the buffer. Definition at line 323 of file BCP_buffer.hpp. References _data, _pos, _size, BCP_vec< T >::clear(), BCP_vec< T >::end(), BCP_vec< T >::insert(), and BCP_vec< T >::reserve(). { int objnum; #ifdef PARANOID if (_pos + sizeof(int) > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(&objnum, _data + _pos, sizeof(int)); _pos += sizeof(int); vec.clear(); if (objnum > 0){ #ifdef PARANOID if (_pos + sizeof(T)*objnum > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif vec.reserve(objnum); vec.insert(vec.end(), _data + _pos, objnum); _pos += objnum * sizeof(T); } return *this; }

BCP_buffer& BCP_buffer::unpack (  BCP_string &  value  )  [inline]

Unpack a BCP_string from the buffer. Definition at line 285 of file BCP_buffer.hpp. References _data, _pos, BCP_string::assign(), and unpack(). { int len; unpack(len); value.assign(_data + _pos, len); _pos += len; return *this; }

template<class T> BCP_buffer& BCP_buffer::unpack (  T *&  values, int &  length, bool  allocate = true )  throw (BCP_fatal_error) [inline]

Unpack an array of objects of type T, where T must be a built-in type (ar at least something that can be copied with memcpy). If the third argument is true then memory is allocated for the array and the array pointer and the length of the array are returned in the arguments. If the third argument is false then the arriving array's length is compared to length and an exception is thrown if they are not the same. Also, the array passed as the first argument will be filled with the arriving array. Definition at line 213 of file BCP_buffer.hpp. References _data, _pos, and _size. { if (allocate) { #ifdef PARANOID if (_pos + sizeof(int) > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(&length, _data + _pos, sizeof(int)); _pos += sizeof(int); if (length > 0){ #ifdef PARANOID if (_pos + sizeof(T)*length > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif values = new T[length]; memcpy(values, _data + _pos, sizeof(T)*length); _pos += sizeof(T) * length; } } else { /* ! allocate */ int l; #ifdef PARANOID if (_pos + sizeof(int) > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(&l, _data + _pos, sizeof(int)); _pos += sizeof(int); if (l != length) throw BCP_fatal_error("BCP_buffer::unpack() : bad array lentgh.\n"); if (length > 0){ #ifdef PARANOID if (_pos + sizeof(T)*length > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(values, _data + _pos, sizeof(T)*length); _pos += sizeof(T) * length; } } return *this; }

template<class T> BCP_buffer& BCP_buffer::unpack (  T &  value  )  [inline]

Unpack a single object of type T. Copies sizeof(T) bytes to the address of the object. Definition at line 177 of file BCP_buffer.hpp. References _data, _pos, and _size. Referenced by BCP_vg_prob::probe_messages(), BCP_cg_prob::probe_messages(), BCP_vec_change< char >::unpack(), BCP_problem_core_change::unpack(), BCP_problem_core::unpack(), BCP_parameter_set< BCP_tm_par >::unpack(), BCP_lp_relax::unpack(), unpack(), BCP_internal_brobj::unpack(), BCP_vg_prob::unpack_cut(), BCP_vg_user::unpack_dual_solution(), BCP_tm_user::unpack_feasible_solution(), BCP_cg_user::unpack_primal_solution(), and BCP_cg_prob::unpack_var(). { #ifdef PARANOID if (_pos + sizeof(T) > _size) throw BCP_fatal_error("Reading over the end of buffer.\n"); #endif memcpy(&value, _data + _pos, sizeof(T)); _pos += sizeof(T); return *this; }

---

Member Data Documentation

char* BCP_buffer::_data

Pointer to the buffer itself. Definition at line 81 of file BCP_buffer.hpp. Referenced by BCP_buffer(), data(), make_fit(), operator=(), pack(), set_content(), unpack(), and ~BCP_buffer().

size_t BCP_buffer::_max_size

The amount of memory allocated for the buffer. Definition at line 76 of file BCP_buffer.hpp. Referenced by BCP_buffer(), make_fit(), operator=(), and set_content().

BCP_message_tag BCP_buffer::_msgtag

The message tag of the last received message. This member has no meaning if the buffer holds an outgoing message. Definition at line 69 of file BCP_buffer.hpp. Referenced by BCP_buffer(), clear(), msgtag(), operator=(), set_content(), and set_msgtag().

size_t BCP_buffer::_pos

The next read/write position in the buffer. Definition at line 74 of file BCP_buffer.hpp. Referenced by BCP_buffer(), clear(), operator=(), set_content(), set_position(), and unpack().

BCP_proc_id* BCP_buffer::_sender

The process id of the sender of the last received message. This member has no meaning if the buffer holds an outgoing message. Definition at line 72 of file BCP_buffer.hpp. Referenced by BCP_buffer(), clear(), operator=(), sender(), set_content(), and ~BCP_buffer().

size_t BCP_buffer::_size

The current size of the message (the first _size bytes of the buffer). Definition at line 79 of file BCP_buffer.hpp. Referenced by BCP_buffer(), clear(), make_fit(), operator=(), pack(), set_content(), size(), and unpack().

---

The documentation for this class was generated from the following file:

• BCP_buffer.hpp

---