src/IplPaws/DLDescriptor.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://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

#include "Paws/PawsMessage.h"
#include "IpplPaws/DLDescriptor.h"
#include "Field/LField.h"
#include "Field/BareField.h"
#include "Utility/PAssert.h"


//
// Construct a DLRepresentation given a global domain.
// Right now this does not subdivide the representation at all.
// IPPL Fields are always stored in column-major order.
//

template<class D, unsigned Dim, class C, class T>
DLDescriptor<D,Dim,C,T>::DLDescriptor(DLRepresentation<D,Dim>& rep, C* coll)
  : PawsArrayDescriptor<T>(rep, PAWS_COLUMN, PAWS_PARALLEL), collection(coll)
{
}


//
// Update the DLDescriptor with a pointer to new data and a new representation
//
template<class D, unsigned Dim, class C, class T>
void
DLDescriptor<D,Dim,C,T>::update(const DLRepresentation<D,Dim>& rep, C* coll)
{
   PawsArrayDescriptor<T>::update(rep);
   collection = coll;
}


//
// Using the Abstract Schedule, pack the data for sending
// packData() can handle local anomalies such as compression
//

template<class D, unsigned Dim, class C, class T>
PawsMessage*
DLDescriptor<D,Dim,C,T>::packData(const char* loc_id, const char* rem_id,
                              PawsAbstractMessage* am,
                              PawsRepresentation& remote_rep, int snum)
{
  static char* id = "DLDescriptor:packData()";
  PDebug(PAWSD_APP, ("%s entering\n", id));

  int i;
  const char* header = am->header().c_str();
  int src_block = am->srcBlock();
  int first[Dim];
  int last[Dim];
  int stride[Dim];
  am->srcDomain(Dim, first, last, stride);
  D src_domain = makeDomain(first, last, stride);

  // Create an empty message to fill with data and send
  //
  PawsMessage* message = app->myComm()->createMessage();
  message->pack(N_SENDING_DATA);
  message->pack(loc_id);
  message->pack(rem_id);
  message->pack(snum);
  message->pack(header);
  message->pack(PAWS_COLUMN);

  // Collection* data is a BareField, iterate over all the local LFields
  //
  BareField<T,Dim>::iterator_if lfield;
  int block_num = 0;
  for (lfield = collection->begin_if(); lfield != collection->end_if();
                                                ++lfield, block_num++) {
    if (src_block == block_num) {
        LField<T,Dim>& l = *((*lfield).second);
        LField<T,Dim>::iterator send;

        // Find out if LField is compressed and handle differently
        int num_data = 1;
        l.TryCompress();

        if (l.IsCompressed()) {
          PDebug(PAWSD_APP, ("%s Send Compressed %d\n", id, num_data));
          message->pack(num_data);
          message->pack(l.getCompressedData());

        } else {
          for (i = 0; i < Dim; i++)
            num_data *= (src_domain[i].last() - src_domain[i].first() + 1);
          message->pack(num_data);
          PDebug(PAWSD_APP, ("%s Send Uncompressed %d\n", id, num_data));

          // Move data in contiguous chunks into buffer
          int n = 0;
          send = l.begin(src_domain);
          int data_width = send.size(0);
          while (send != l.end()) {
            message->pack(&(*send), data_width);
            n += data_width;
            for (i = 0; i < data_width; ++i)
              ++send;
          }
        }
        PDebug(PAWSD_APP, ("%s header=%s seq=%d num=%d\n", id, header, snum, num_data));
    }
  }

  PDebug(PAWSD_APP, ("%s exiting\n", id));
  return message;
}


//
// Pack the data for sending according to the AbstractMessage
// Pack in standard format must send compressed data in uncompressed form
//

template<class D, unsigned Dim, class C, class T>
PawsMessage*
DLDescriptor<D,Dim,C,T>::packStdData(const char* loc_id, const char* rem_id,
                        PawsAbstractMessage* am,
                        PawsRepresentation& remote_rep, int snum)
{
  static char* id = "DLDescriptor:packStdData()";
  PDebug(PAWSD_APP, ("%s entering\n", id));

  int i;
  const char* header = am->header().c_str();
  int src_block = am->srcBlock();
  int first[Dim];
  int last[Dim];
  int stride[Dim];
  am->srcDomain(Dim, first, last, stride);
  D src_domain = makeDomain(first, last, stride);

  // Create an empty message to fill with data and send
  //
  PawsMessage* message = app->myComm()->createMessage();
  message->pack(N_SENDING_DATA);
  message->pack(loc_id);
  message->pack(rem_id);
  message->pack(snum);
  message->pack(header);
  message->pack(PAWS_COLUMN);

  // Collection* data is really the Field<T,Dim> which is a BareField
  // BareField has an iterator over all local LFields
  //
  BareField<T,Dim>::iterator_if lfield;
  int block_num = 0;
  for (lfield = collection->begin_if(); lfield != collection->end_if();
                                                ++lfield, block_num++) {
      if (src_block == block_num) {
        LField<T,Dim>& l = *((*lfield).second);
        LField<T,Dim>::iterator send;

        // Find out if LField is compressed and handle differently
        int num_data = 1;
        for (i = 0; i < Dim; i++)
            num_data *= (src_domain[i].last() - src_domain[i].first() + 1);
        l.TryCompress();

        if (l.IsCompressed()) {
          PDebug(PAWSD_APP, ("%s Send Compressed Expanded\n", id));
          message->pack(num_data);
          T value = l.getCompressedData();
          for (i = 0; i < num_data; i++)
              message->pack(value);

        } else {
          message->pack(num_data);
          PDebug(PAWSD_APP, ("%s Send Uncompressed %d\n", id, num_data));

          // Move data in contiguous chunks into buffer
          int n = 0;
          send = l.begin(src_domain);
          int data_width = send.size(0);
          while (send != l.end()) {
            message->pack(&(*send), data_width);
            n += data_width;
            for (int i = 0; i < data_width; ++i)
              ++send;
          }
        }
        PDebug(PAWSD_APP, ("%s header=%s seq=%d num=%d\n", id, header, snum, num_data));
      }
  }

  PDebug(PAWSD_APP, ("%s exiting\n", id));
  return message;
}


//
// Unpack data into space pointed at by DLRepresentation
//

template<class D, unsigned Dim, class C, class T>
void
DLDescriptor<D,Dim,C,T>::unpackData(PawsMessage& message, const char* header)
{
  static char* id = "DLDescriptor: unpackData()";
  PDebug(PAWSD_APP, ("%s entering\n", id));

  int num_data = 0;
  int remote_order = PAWS_COLUMN;
  T value;
  PawsAbstractMessage recv_message;
  recv_message.unpack(header);
  int dst_block = recv_message.dstBlock();

  int first[Dim];
  int last[Dim];
  int stride[Dim];
  recv_message.dstDomain(Dim, first, last, stride);
  D dst_domain = makeDomain(first, last, stride);

  // Fill the correct LField's sub_domain with the following data
  // Iterate through all the LFields looking for the correct one
  //
  BareField<T,Dim>::iterator_if lfield;
  int block_num = 0;
  for (lfield = collection->begin_if(); lfield != collection->end_if();
                                                ++lfield, block_num++) {
    if (block_num == dst_block) {
      LField<T,Dim>& l = *((*lfield).second);
      LField<T,Dim>::iterator recv = l.begin(dst_domain);
      D& lfield_domain = (D&) l.getOwned();

      // Deal with compression, if number of data sent is one,
      // and dst_domain = lfield_domain then send LField can be compressed
      //
      message.unpack(&remote_order);
      if (remote_order != PAWS_COLUMN) {
          PDebug(PAWSD_APP, ("%s Bad incoming storage order %d\n", id, remote_order));
          PAssert(false);
      }
      message.unpack(&num_data);
      if (num_data == 1) {
        message.unpack(&value);

        if (lfield_domain == dst_domain) {
          PDebug(PAWSD_APP, ("%s Compressed to Compressed %d\n", id, num_data));
          l.Compress(value);
        } else {
          PDebug(PAWSD_APP, ("%s Compressed to Uncompressed %d\n", id, num_data));
          l.Uncompress();
          for (recv = l.begin(dst_domain); recv != l.end(); ++recv)
            (*recv) = value;
        }
      } else {
        // Send LField is not compressed, uncompress receive LField
        //
        if (l.IsCompressed()) {
          PDebug(PAWSD_APP, ("%s Uncompressed to Compressed %d\n", id, num_data));
        } else {
          PDebug(PAWSD_APP, ("%s Uncompressed to Uncompressed %d\n", id, num_data));
        }
        l.Uncompress();
        int n = 0;
        recv = l.begin(dst_domain);
        int data_width = recv.size(0);
        while (recv != l.end()) {
          message.unpack(&(*recv), data_width);
          n += data_width;
          for (int i = 0; i < data_width; ++i)
            ++recv;
        }
      }
    }
  }

  PDebug(PAWSD_APP, ("%s exiting\n", id));
}


//
// Unpack data into space pointed at by the collection
//

template<class D, unsigned Dim, class C, class T>
void
DLDescriptor<D,Dim,C,T>::unpackStdData(PawsMessage& message, const char* header)
{
  static char* id = "DLDescriptor: unpackStdData()";
  PDebug(PAWSD_APP, ("%s entering\n", id));

  int num_data = 0;
  int remote_order = PAWS_COLUMN;
  T value;
  PawsAbstractMessage recv_message;
  recv_message.unpack(header);
  int dst_block = recv_message.dstBlock();

  int first[Dim];
  int last[Dim];
  int stride[Dim];
  recv_message.dstDomain(Dim, first, last, stride);
  D dst_domain = makeDomain(first, last, stride);

  // Fill the correct LField's sub_domain with the following data
  // Iterate through all the LFields looking for the correct one
  //
  BareField<T,Dim>::iterator_if lfield;
  int block_num = 0;
  for (lfield = collection->begin_if(); lfield != collection->end_if();
                                                ++lfield, ++block_num) {
    if (block_num == dst_block) {
      LField<T,Dim>& l = *((*lfield).second);
      LField<T,Dim>::iterator recv = l.begin(dst_domain);
      D& lfield_domain = (D&) l.getOwned();

      // Deal with compression, if number of data sent is one,
      // and dst_domain = lfield_domain then send LField can be compressed
      //
      message.unpack(&remote_order);
      if (remote_order != PAWS_COLUMN) {
          PDebug(PAWSD_APP, ("%s Bad incoming storage order %d\n", id, remote_order));
          PAssert(false);
      }
      message.unpack(&num_data);

      if (num_data == 1) {
        message.unpack(&value);

        if (lfield_domain == dst_domain) {
          PDebug(PAWSD_APP, ("%s Compressed to Compressed %d\n", id, num_data));
          l.Compress(value);
        } else {
          PDebug(PAWSD_APP, ("%s Compressed to Uncompressed %d\n", id, num_data));
          l.Uncompress();
          for (recv = l.begin(dst_domain); recv != l.end(); ++recv)
            (*recv) = value;
        }

      } else {
        // Send LField is not compressed, uncompress receive LField
        //
        if (l.IsCompressed()) {
          PDebug(PAWSD_APP, ("%s Uncompressed to Compressed %d\n", id, num_data));
        } else {
          PDebug(PAWSD_APP, ("%s Uncompressed to Uncompressed %d\n", id, num_data));
        }

        l.Uncompress();
        int n = 0;
        recv = l.begin(dst_domain);
        int data_width = recv.size(0);
        while (recv != l.end()) {
          message.unpack(&(*recv), data_width);
          n += data_width;
          for (int i = 0; i < data_width; ++i)
            ++recv;
        }
      }
    }
  }

  PDebug(PAWSD_APP, ("%s exiting\n", id));
}


//
// Make a local domain given first, last and stride elements
//

template<class D, unsigned Dim, class C, class T>
D
DLDescriptor<D,Dim,C,T>::makeDomain(const int* first,
                                const int* last,
                                const int* stride)
{
  D new_domain;

  for (int i = 0; i < Dim; i++)
    new_domain[i] = Index(first[i], last[i], stride[i]);

  return new_domain;
}

//
// Print out the descriptor
//
template <class D, unsigned Dim, class C, class T>
ostream& operator<<(ostream& out, DLDescriptor<D,Dim,C,T>& dlDesc)
{
  out << (PawsArrayDescriptor<T>&)dlDesc << endl;
  return out;
}

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

---