SDFPortHole.h

/**************************************************************************
Version identification:
@(#)SDFPortHole.h 2.19  3/2/95

Copyright (c) 1990-1995 The Regents of the University of California.
All rights reserved.

Permission is hereby granted, without written agreement and without
license or royalty fees, to use, copy, modify, and distribute this
software and its documentation for any purpose, provided that the
above copyright notice and the following two paragraphs appear in all
copies of this software.

IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.

            PT_COPYRIGHT_VERSION_2
            COPYRIGHTENDKEY

 Programmer:  E. A. Lee and D. G. Messerschmitt
 Date of creation: 5/29/90, J. Buck

This file contains definitions of SDF-specific PortHole classes.

******************************************************************/
#ifndef _SDFPortHole_h
#define _SDFPortHole_h 1
#ifdef __GNUG__
#ifndef CYGWIN
#pragma interface
#endif
#endif

#include "kernel/DFPortHole.h"

extern bool sDebugPorts;

/*****************************************************************
SDF: Synchronous Data Flow

This is a common special case that is handled differently
from other cases:

  Each PortHole promises to consume or generate a fixed
  number of Particles each time the Star is invoked.
  This number is stored in the PortHole and can be accessed
  by the SDFScheduler

  The incrementing of time is forced by the SDFScheduler,
  and not by the Star itself. Incrementing time is effected
  by consuming or generating Particles
****************************************************************/

    

        // class SDFPortHole

// Contains all the special features required for
//   synchronous dataflow (SDF)

class SDFPortHole : public DFPortHole
{
  public:

    // class identification
    int isA(const char*) const;
  const char* className() const;
    /*virtual*/ void initialize();

    void setNumXfer( int pNewRate ); 

    // Services of PortHole that are often used:
    // setPort(DataType d);
    // Particle& operator % (int);
};

  // class InSDFPort

class InSDFPort : public SDFPortHole
{
  public:
    int isItInput () const ; // {return TRUE; }
    
    // Get Particles from input Geodesic
    inline void receiveData()
    {
      if( mNotify || sDebugPorts ) 
        receiveDataWithPortDebug();
      else  
        DFPortHole::receive();
//      NOTIFYDEBUGGER(mNotify);
    }

    void receiveDataWithPortDebug();

      
    template<class T> InSDFPort& operator >> (T** pBuffer);
    
    };

  // class OutSDFPort

class OutSDFPort : public SDFPortHole
{
 public:
    int isItOutput () const; // {return TRUE; }

    void increment();
    
    // Move the current Particle in the input buffer -- this
    // method is invoked by the SDFScheduler before go()
    virtual void receiveData();
    
    // Put the Particles that were generated into the
    // output Geodesic -- this method is invoked by the
    // SDFScheduler after go()
    inline void sendData()
    {
      if( mNotify || sDebugPorts )
        sendDataWithPortDebug();
      else
        DFPortHole::send();
      // <af> note: put the notify after send()
      // to enable inspection of the output in conjunction with the new
      // data transfer mechanism. (as opposed to previous ordering)
//      NOTIFYDEBUGGER(mNotify); 
    }
      
    void sendDataWithPortDebug();

    template< class T>
    OutSDFPort& operator << (T*);

    template<class T>
    void rbwr( T* state_array, int* n_elements, int* status );

};

// class MultiSDFPort

// Synchronous dataflow MultiPortHole: same as DFPortHole

typedef MultiDFPort MultiSDFPort;

// class MultiInSDFPort
        
// MultiInSDFPort is an SDF input MultiPortHole
 
class MultiInSDFPort : public MultiSDFPort
{
 public:
  int isItInput () const; // {return TRUE; }
  
  // Add a new physical port to the MultiPortHole list
  PortHole& newPort();
};
 
 
// class MultiOutSDFPort

// MultiOutSDFPort is an SDF output MultiPortHole  

class MultiOutSDFPort : public MultiSDFPort
{     
 public:
  int isItOutput () const; // {return TRUE; }
  
  // Add a new physical port to the MultiPortHole list
  PortHole& newPort();
};


class InSDFMPHIter : public MPHIter {
public:
  InSDFMPHIter(MultiInSDFPort& mph) : MPHIter(mph) {}
  InSDFPort* next() { return (InSDFPort*) MPHIter::next();}
  InSDFPort* operator++(POSTFIX_OP) { return next();}
};

class OutSDFMPHIter : public MPHIter {
public:
  OutSDFMPHIter(MultiOutSDFPort& mph) : MPHIter(mph) {}
  OutSDFPort* next() { return (OutSDFPort*) MPHIter::next();}
  OutSDFPort* operator++(POSTFIX_OP) { return next();}
};


#endif