Communicator.h

Go to the documentation of this file.

//
//------------------------------------------------------------------------
//
// File   : Communicator.h
// Author : Patrick McCormick (pat@acl.lanl.gov)
// 
// $Date: 2003/09/09 10:12:57 $
// $Revision: 1.17 $
//
// 
// This class forms the basis for a set of Communicator classes that 
// can be used to communicate via a messaging based interface.  This 
// base class should define all the basic operations that are needed
// to support basic communcation.  This class may not be as flexible 
// as possible but is geared towards MPI-like support code.
//
// There are no real implementation details (so to speak) in this 
// class.  The only true purpose it serves is to provide an interface
// definition for sending messages. 
// 
// After recv. operations you can call the RecvMesgSize() method to 
// get the actual size of the message received. 
//
//------------------------------------------------------------------------

#ifndef _KOKO_COMMUNICATOR_H_
#define _KOKO_COMMUNICATOR_H_

#include "koko.h"
#include "KokoBuffer.h"

class Communicator
{
  public:
    inline Communicator(void) 
    { 
      _nprocs     = -1;
      _id         = -1;
      _recv_bytes = 0;
      _recv_tag   = KOKO_ANY_TAG;
      _recv_src   = 0;

    };

    inline ~Communicator(void)  
    { };

    // Blocking send.  Return of true = successful send, false = failure. 
    virtual bool Send(KokoProcID id, KokoBuffer &buf, KokoTag tag) = 0;

    // Blocking receive. Returns the number of bytes received. The nbytes
    // parameter is the number of bytes that can be stored in the buffer 
    // not the expected size of the message. 
    virtual int Recv(KokoProcID id, KokoBuffer &buf, KokoTag tag) = 0;

    // SendRecv combination.
    virtual int SendRecv(KokoProcID to, KokoBuffer &sendbuf, 
                         KokoTag sendtag, KokoProcID from, KokoBuffer &recvbuf, 
                         KokoTag recvtag) = 0; 

    // Non-blocking send. 
    virtual KokoMesgHandle ASend(KokoProcID id, KokoBuffer &buf, KokoTag tag) = 0;

    // Non-blocking receive. 
    virtual KokoMesgHandle ARecv(KokoProcID id, KokoBuffer &buf, KokoTag tag) = 0;

    // Non-blocking completion operations.

    // Return when the operation ID'ed by the given handle completes.  Return 
    // value indicates error condition -- true == error. 
    virtual bool Wait(KokoMesgHandle &hand) = 0;

    // Check to see if the operation ID'ed by the given handle completes.  
    // Return value indicates if the operation is complete.  Error 
    // conditions are reported to std::cerr. 
    virtual bool Test(KokoMesgHandle &hand) = 0; 


    // Broadcast -- send the message to all nodes, including ourself.  The 
    // processor performing the broadcast should be specified by the root 
    // argument.  All other processors (!= root) will receive the broadcat. 
    virtual bool Broadcast(KokoBuffer &buf, KokoProcID root, KokoTag tag) = 0;

    // Barrier -- a standard barrier.
    virtual bool Barrier(void) = 0;

    // What is our ID?
    inline virtual KokoProcID ID(void)
    { return _id; };

    inline virtual KokoProcID Rank(void)
    { return _id; };

    // Total number of processors in use. 
    inline virtual unsigned int NumProcessors(void)
    { return _nprocs; };

    // You'll have to call this routine to determine how many 
    // bytes were transfered during a receive operation. 
    inline virtual int RecvSize(void) 
    { return _recv_bytes; };

    // If you use an "any" tag request, this routine will give
    // you the tag used by a received message. 
    inline virtual KokoTag RecvTag(void)
    { return _recv_tag; };

    inline virtual KokoProcID RecvSource(void)
    { return _recv_src; };

  protected:
    KokoProcID       _id;          // Processor/process ID. 
    int              _nprocs;      // Total number of processors.
    KokoProcID       _recv_src;    // Who did we receive a message from.
    int              _recv_bytes;  // Total bytes received in a message. 
    KokoTag          _recv_tag;    // The tag that was attached to the last 
                                   //  recv'ed message. 
};

#endif

---

Send questions, comments, and bug reports to: