src/Message/MessageFunctions.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

// include files
#include "Message/Message.h"
#include "Message/Communicate.h"
#include "Utility/Inform.h"
#include "Utility/IpplInfo.h"
#include "Utility/PAssert.h"
#include "Profile/Profiler.h"

#ifdef IPPL_USE_STANDARD_HEADERS
#include <new>
#include <memory>
using namespace std;
#else
#include <new.h>
#include <memory.h>
#endif

#include <stdlib.h>
#include <stddef.h>


// destructor: delete all items in this message, as if 'get' had been
// called for all the items
Message::~Message() {
  TAU_PROFILE("Message::~Message()", "void (void)", TAU_MESSAGE);

  // remove all unused items
  clear();

  // delete the storage in the existing items
  int n = MsgItemList.size();
  for (int i=0; i < n; ++i)
    MsgItemList[i].deleteData();

  // tell the communicate item to cleanup the provided data,
  // if necessary
  if (comm != 0)
    comm->cleanupMessage(commdata);
}


// remove the top MsgItem
void Message::deleteMsgItem() {
  TAU_PROFILE("Message::deleteMsgItem()", "void (void)", TAU_MESSAGE);

  if (!empty())
    numRemoved++;
}


// general put routine; called by other cases
// arguments are the item, its element size (in bytes),
// and how many items total to copy
Message& Message::putmsg(void *data, int s, int nelem) {
  TAU_PROFILE("Message::putmsg()", "Message (void *, int, int)", TAU_MESSAGE);

  // if this is a scalar, we always copy, and have one element
  if (nelem < 1) {
    nelem = 1;
    DoCopy = true;
  }

  // initialize new MsgItem
  //Inform dbgmsg("Message::putmsg", INFORM_ALL_NODES);
  //dbgmsg << "Putting data " << MsgItemList.size() << " at " << data;
  //dbgmsg << " with " << nelem;
  //dbgmsg << " elements, totbytes=" << s * nelem << ", copy=" << DoCopy;
  //dbgmsg << ", del=" << DoDelete << endl;
  MsgItem m(data, nelem, s * nelem, DoCopy, DoDelete);

  // add MsgItem to the pool
  MsgItemList.push_back(m);

  // reset copy and delete flags to default values
  DoCopy = DoDelete = true;
  return *this;
}


// General get routine; called by other cases.
// Arguments are the location where to write the data.
// If this is called with a 0 destination location, then it just
// deletes the top MsgItem.
Message& Message::getmsg(void *data) {
  TAU_PROFILE("Message::getmsg()", "Message (void *)", TAU_MESSAGE);

  // check to see if there is an item
  if (empty()) {
    ERRORMSG("Message::getmsg() no more items in Message" << endl);
    PAssert(!empty());
  } else {
    // get the next MsgItem off the top of the list
    MsgItem &m = item(0);

    // copy the data into the given location
    if (m.data() != 0 && data != 0) {
      //Inform dbgmsg("Message::getmsg", INFORM_ALL_NODES);
      //dbgmsg << "Getting item " << removed() << " from loc=" << m.data();
      //dbgmsg << " to loc=" << data << " with totbytes=" << m.numBytes();
      //dbgmsg << endl;
      memcpy(data, m.data(), m.numBytes());
    }

    // delete this top MsgItem
    deleteMsgItem();
  }

  return *this;
}


// clear the message; remove all the MsgItems
Message& Message::clear(void) {
  TAU_PROFILE("Message::clear()", "Message ()", TAU_MESSAGE);

  while (!empty())
    deleteMsgItem();

  return *this;
}


// return and remove the next item from this message ... if the item
// does not exist, NULL is returned.  This is similar to get, except that
// just a void* pointer to the data is returned (instead of having the
// data copied into given storage), and this data is DEFINITELY a malloced
// block of data that the user must deallocate using 'free' (NOT delete).
// Like 'get', after this is called, the top MsgItem is removed.
// If you wish to just access the Nth item's item  pointer, use
// item(N).item  .
void *Message::remove() {
  TAU_PROFILE("Message::remove()", "void * ()", TAU_MESSAGE);

  // get the data out of the item
  MsgItem &m = item(0);
  void *retdata = m.data();

  // make a copy of it, or just return it if a delete is needed
  if (m.willNeedDelete()) {
    m.cancelDelete();
  } else if (retdata != 0) {
    retdata = malloc(m.numBytes());
    memcpy(retdata, m.data(), m.numBytes());
  }

  // delete the item
  deleteMsgItem();

  // return the data
  return retdata;
}


// use the << operator to print out a summary of the message
ostream& operator<<(ostream& o, const Message& m) {
  TAU_PROFILE("operator<<()", "ostream& (ostream&, const Message&)", 
    TAU_MESSAGE | TAU_IO);
  o << "Message contains " << m.size() << " items (" << m.removed();
  o << " removed).  Contents:\n";
  for (size_t i = 0 ; i < m.size(); ++i) {
    const Message::MsgItem &mi = m.item(i);
    o << "  Item " << i << ": " << mi.numElems() << " elements, ";
    o << mi.numBytes() << " bytes total, needDelete = ";
    o << mi.willNeedDelete() << endl;
  }
  return o;
}


/***************************************************************************
 * $RCSfile: MessageFunctions.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:28 $
 * IPPL_VERSION_ID: $Id: MessageFunctions.cpp,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $ 
 ***************************************************************************/

---