src/IplPaws/PawsDataConnect.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 <iostream.h>
#include "IpplPaws/PawsDataConnect.h"
#include "Paws/PawsApplication.h"
#include "Message/Message.h"
#include "Utility/IpplInfo.h"


// static data members of this class
PawsApplication *PawsDataConnect::PawsApp   = 0;
bool             PawsDataConnect::PawsReady = false;
int              PawsDataConnect::NumPawsConnect = 0;


// constructor: initialize PAWS application by connecting with controller
PawsDataConnect::PawsDataConnect(const char *nm, int n)
  : DataConnect(nm, "paws", DataSource::OUTPUT, n) {

  // do initialization the first time this application is started under paws
  if (PawsApp == 0) {
    PawsApp  = new PawsApplication;
    PawsApp->initialize(nm, Ippl::getArgc(), Ippl::getArgv(),
                        Ippl::myNode(), Ippl::getNodes());
  }

  // indicate we're one more object using this PawsApp
  if (PawsApp != 0)
    NumPawsConnect++;
}


// destructor: disconnect all data objects, and close window
PawsDataConnect::~PawsDataConnect() {
  //Inform dbgmsg("PawsDataConnect::~PawsDataConnect", INFORM_ALL_NODES);
  //dbgmsg << "In PawsDataConnect destructor, wtih NumPawsConnect = ";
  //dbgmsg << NumPawsConnect << endl;

  if (PawsApp != 0) {
    // disconnect any remaining data objects
    //dbgmsg << "Calling disconnectConnections from the destructor" << endl;
    disconnectConnections();

    // and then shut down our application
    if (--NumPawsConnect == 0) {
      //dbgmsg << "Waiting at barrier before deleting PawsApplication" << endl;
      barrier();

      //dbgmsg << "Deleting the PawsApplication object ..." << endl;
      delete PawsApp; 

      PawsApp = 0;
      PawsReady = false;
    }
  }
}


// perform a "paws-aware" barrier, where we do not do a
// communicate barrier, but instead do it through messages to/from
// node zero in a loop that also does a poll.
void PawsDataConnect::barrier() {

  // If there is only one node, just do a poll and exit
  if (Ippl::getNodes() == 1) {
    poll();
    return;
  }

  // Get to/from tags
  int stag = Ippl::Comm->next_tag(COMM_REDUCE_SEND_TAG, COMM_REDUCE_CYCLE);
  int rtag = Ippl::Comm->next_tag(COMM_REDUCE_RECV_TAG, COMM_REDUCE_CYCLE);

  // All nodes except node zero send to node zero
  if (Ippl::myNode() != 0) {
    // Put our node number in a message and send it to node zero
    Message *msg = new Message;
    msg->put(Ippl::myNode());
    Ippl::Comm->send(msg, 0, stag);

    // Wait for the reply, polling as we go
    Message *rmsg = 0;
    int sender = 0;
    while (rmsg == 0) {
      // Do a PAWS poll

      poll();

      // ... and then look for a message

      rmsg = Ippl::Comm->receive(sender, rtag);
    }

    // Get the replies node number, delete it, and we're done on this node
    rmsg->get(sender);
    if (sender != 0) {
      ERRORMSG("Bad reply node " << sender << " in PawsDataConnect::barrier");
      ERRORMSG(endl);
    }
    delete rmsg;

  } else {

    // On node zero, we wait for messages from all other nodes, while
    // doing polls as well.  As a sanity check, we can add all the
    // received node numbers, it should be == sum(n), where n = 1 ... N-1
    // so it should be (N-1)(N)/2

    int nodetotal = 0;
    int received = 1;           // we don't worry about ourselves
    while (received < Ippl::getNodes()) {
      // Do a PAWS poll

      poll();

      // ... and then look for a message

      int sender = COMM_ANY_NODE;
      Message *msg = Ippl::Comm->receive(sender, stag);
      while (msg != 0) {
        // We did receive a message, so get the sender's node number,
        // make sure it is correct, and add it in
        int s;
        msg->get(s);
        if (s != sender) {
          ERRORMSG("Bad sender's node " << s << " (should be " << sender);
          ERRORMSG(") in PawsDataConnect::barrier" << endl);
        }
        delete msg;
        msg = 0;
        nodetotal += s;
        received += 1;

        // Look for another message, if we still need more
        if (received < Ippl::getNodes()) {
          sender = COMM_ANY_NODE;
          msg = Ippl::Comm->receive(sender, stag);
        }
      }
    }

    // Sanity check
    if (nodetotal != (Ippl::getNodes() * (Ippl::getNodes()-1))/2) {
      ERRORMSG("Not all nodes reported properly in PawsDataConnect::barrier");
      ERRORMSG(" (nodetotal is " << nodetotal << ")" << endl);
    }

    // Now, send a reply back to all the others
    Message *rmsg = new Message;
    rmsg->put(0);
    Ippl::Comm->broadcast_others(rmsg, rtag);
  }
}


// perform a poll 
void PawsDataConnect::poll() {
  if (PawsApp != 0)
    PawsApp->poll();
}

// perform a ready
void PawsDataConnect::ready() {
  if (PawsApp != 0)
    PawsApp->ready();
}


// are we currently connected to a receiver?  The base-class default
// behavior for this is to indicate that we're not connected.
bool PawsDataConnect::connected() const {
  return (PawsApp != 0);
}


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

---