KokoBuffer.cpp

Go to the documentation of this file.

//
//------------------------------------------------------------------------
//
// File   : KokoBuffer.cpp 
// Author : Patrick McCormick (pat@acl.lanl.gov)
// 
// $Date: 2003/08/04 04:57:49 $
// $Revision: 1.8 $
//
// This class implements a very simple buffer for holding bytes of data. 
// The main purpose of the class is to support the packing of data for
// sending it over the network. 
//
// This code has similar features to the MPI pack and unpack routines.
//
// TODO NOTE: It may be necessary to use MPI_Alloc() for memory allocation if
//       you plan on using these buffers as contents for messages.  Is 
//       this only an issue with MPIPro???  
//
//------------------------------------------------------------------------
#include <iostream>
#include <string.h>

#include "koko.h"

#include "KokoBuffer.h"

//
// When we grow a buffer we'll add an extra number
// of bytes.  This is the default.  TOTO: We should
// probably just make this a factor (e.g. grow in 
// size by a factor of...).
//
const float KOKOBUF_GROWTH_FACTOR = 2.0;  

using namespace std;

// ------------------
// --- KokoBuffer ---
// ------------------
//
KokoBuffer::KokoBuffer(void)
{
  _locked   = false;
  _size     = 0; 
  _start    = 0;
  _buf      = 0;
  _aptr     = 0;
  _eptr     = 0;
  _cursize  = 0;
  _growfact = KOKOBUF_GROWTH_FACTOR;
}


// ------------------
// --- KokoBuffer ---
// ------------------
//
KokoBuffer::KokoBuffer(unsigned int size)
{
  _locked   = false;
  _size     = size;
  _start    = new unsigned char[_size + sizeof(KokoTag)];
  _buf      = _start + sizeof(KokoTag);
  _aptr     = _buf;
  _eptr     = _buf;
  _cursize  = 0;  // no data in buffer yet.
  _growfact = KOKOBUF_GROWTH_FACTOR;
}


// ------------------
// --- KokoBuffer ---
// ------------------
//
KokoBuffer::KokoBuffer(unsigned char *buf, unsigned int size, bool pad)
{
  _growfact = KOKOBUF_GROWTH_FACTOR;
  if (pad == true)
    _size = (int)(size + _growfact);
  else
    _size = size;
 
  _locked  = false;
  _start   = new unsigned char[_size + sizeof(KokoTag)];
  _buf     = _start + sizeof(KokoTag);
  _cursize = size;
  _aptr    = _buf + _cursize;
  _eptr    = _buf;
  memcpy((void *)_buf, buf, sizeof(unsigned char) * size);
}


// ------------------
// --- KokoBuffer ---
// ------------------
//
KokoBuffer::KokoBuffer(const KokoBuffer &kbuf)
{
  _locked    = false;        // For our purposes, it isn't a good 
                             //   idea to copy the lock state.
  _size      = kbuf._size;
  _start     = new unsigned char[_size + sizeof(KokoTag)];
  _buf       = _start + sizeof(KokoTag);
  _cursize   = kbuf._cursize;
  _growfact  = kbuf._growfact;

  memcpy((void *)_buf, (const void *)kbuf._buf, sizeof(unsigned char) * _size);
  _aptr      = _buf + (kbuf._aptr - kbuf._buf);
  _eptr      = _buf + (kbuf._eptr - kbuf._buf);
}


// ---------------
// --- memcopy ---
// ---------------
//
void KokoBuffer::Memcopy(unsigned char *bufp, unsigned int size)
{
  if (bufp == 0) {
    cerr << "KokoBuffer::Memcopy() : Warning! Buffer pointer is null.\n";
    return;
  }

  if (_locked) {
    cerr << "KokoBuffer::Memcopy() : Buffer is locked!  Copy can't proceed.\n";
    return;
  }

  if (_size < size) {
    delete []_start;
    _start   = new unsigned char[size + sizeof(KokoTag)];
    _buf     = _start + sizeof(KokoBuffer);
    _size    = size;
    _cursize = size;
  } else {
    _cursize = size;
  }

  // Note that we currently don't copy the tag portion
  // of the buffer. 
  memcpy((void *)_buf, (const void *)bufp, size);
}


// ------------
// --- Pack ---
// ------------
//
bool KokoBuffer::Pack(unsigned char *bufp, unsigned int size)
{
  if (bufp == 0) {
    cerr << "KokoBuffer::Pack() : Warning! Buffer pointer is null.\n";
    return false;
  }

  if (_locked) {
    cerr << "KokoBuffer::Pack() : Buffer is locked!  Pack can't proceed.\n";
    return false;
  }

  if (size > bytes_free()) {
    grow(_size + (int)(size * _growfact));
    _growfact *= 2; //
  }

  memcpy((void *)_aptr, (const void *)bufp, size);
  _aptr    += size;
  _cursize += size;
  return true;
}


// --------------
// --- Unpack ---
// --------------
//
bool KokoBuffer::Unpack(unsigned char *dest, unsigned int size)
{
  if (dest == 0) {
    cerr << "KokoBuffer::Unpack() : Warning!  Destination pointer is null.\n";
    return false;
  }

  if (_buf == 0) {
    cerr << "KokoBuffer::Unpack() : Warning! Buffer is empty!\n";
    return false;
  }

  if (_locked) {
    cerr << "KokoBuffer::Unpack() : Buffer is locked! Unpack can't proceed.\n";
    return false;
  }

  if (size > _size) {
    cerr << "KokoBuffer::Unpack() : Warning! Requested size exceeds "
         << "entire buffer size.\n";
    cerr << "\t*** Total buffer size   = " << _size << endl;
    cerr << "\t*** Unpack request size = " << size << endl;
    return false;
  }

  unsigned int bytes_left = _cursize - (_eptr - _buf);

  if (size > bytes_left) {
    cerr << "KokoBuffer::Unpack() : Warning! Request size exceeds space "
         << "remaining in buffer.\n";
    cerr << "\t*** Size       = " << size << endl;
    cerr << "\t*** bytes left = " << bytes_left << endl; 
    cerr << "\t*** cursize    = " << _cursize << endl;
    return false;
  }

  memcpy((void *)dest, (const void *)_eptr, size);
  _eptr += size;

  bytes_left = _cursize - (_eptr - _buf);

  return true;
}


// --------------
// --- SetTag ---
// --------------
// Set the buffer's tag value -- stored at the front of the 
// buffer. 
//
void KokoBuffer::SetTag(KokoTag &tag)
{
  if( _start != 0) 
    memcpy((void *)_start, (const void *)&tag, sizeof(KokoTag));
}


// --------------
// --- GetTag ---
// --------------
// Get the buffer's tag value -- stored at the front of the 
// buffer. 
//
KokoTag KokoBuffer::GetTag(void)
{
  KokoTag  tag;
  if (_start != 0) {
    memcpy((void *)&tag, (const void *)_start, sizeof(KokoTag));
    return tag;
  } else {
    return KOKO_ANY_TAG;  // Not sure if this is wise -- perhaps
                          // we should have a KOKO_INVALID_TAG
                          // value?
  }
}


// ------------
// --- grow ---
// ------------
// Grow the buffer to the new size. 
//
void KokoBuffer::grow(unsigned int new_size)
{
  if (_locked) {
    cerr << "KokoBuffer::grow() : Buffer is locked.  "
         << "Resize/grow can't proceed.\n";
    return;
  }

  cerr << "growing kokobuffer to " << new_size << " bytes.\n";
  unsigned char *nbuf = new unsigned char[new_size];
  memcpy((void *)nbuf, (const void *)_buf, _cursize);
  delete []_buf;  // clean up.
  _buf    = nbuf;
  _aptr   = _buf + _cursize;
  _size   = new_size;
}

---

Send questions, comments, and bug reports to: