Initial commit of OpenSPARC T2 design and verification files.

[OpenSPARC-T2-DV] / verif / model / vendor / TLM-2006-11-29 / tlm / tlm_annotated / tlm_annotated_channels / tlm_peq.h

#ifndef TLM_PEQ_HEADER
#define TLM_PEQ_HEADER

#include <map>

#include "analysis.h"

using std::multimap;
using std::pair;

using analysis::delayed_analysis_if;
using analysis::analysis_port;

//
// No lt_sctime operator required, since we have operator< defined for
// sc_time ?
//
// struct lt_sc_time {
//  bool operator<( const sc_time &a , const sc_time &b ) {
//    return a < b;
//  }
// };
//
//
//

//
// This peq implements a delayed write and has an analysis port
//
// If you post many transactions to the same time slot, this will result in
// many transactions coming out of the analysis port in a single delta  
//
// If you want event driven semantics, stuff the output of the analysis port
// into an analysis fifo ( if you want to guarantee no losses ) or
// analysis buffer ( if you don't mind losses but you can't be bothered or are 
// not able to clear the fifo out ).
//
// For example, you can arrive at a blocking get interface by doing get on
// an analysis fifo attached to the analysis port shown below
//
// We could even design a tlm_peq_fifo and/or tlm_peq_buffer with these
// channels built in
//

template< typename T>
class tlm_peq :
  public sc_module ,
  public virtual delayed_analysis_if< T >
{
 public:
  sc_export< delayed_analysis_if< T > > delayed_analysis_export;
  analysis_port< T > ap;

  SC_HAS_PROCESS( tlm_peq );

  tlm_peq( sc_module_name nm ) : sc_module( nm ) , ap("ap") {

    delayed_analysis_export( *this );

    SC_METHOD( wake_up_method );
    dont_initialize();
    sensitive << m_wake_up;

  }

  int size() const { return m_map.size(); }

  int posted_before( const sc_time &time ) const {
    
    int i = 0;

    for( typename multimap< sc_time , T>::const_iterator iter = m_map.begin();
	 iter != m_map.end();
	 ++iter ) {

      if( (*iter).first < time ) {
	i++;
      }

    }

    return i;

  }

  int posted_at( const sc_time &time ) const {
    return m_map.count( time );
  }
 
  void write( const T &transaction , const sc_time &time ) {

    m_map.insert( pair_type( time + sc_time_stamp() , transaction ) );
    m_wake_up.notify( time );
    
  }

 private:
  typedef pair<sc_time,T> pair_type;

  void wake_up_method() {
    
    pair_type p;
    sc_time now = sc_time_stamp();

    // must be something there, and it must be scheduled for now

    assert( m_map.size() > 0 );
    assert( (*(m_map.begin())).first == now );

    for( p = *(m_map.begin());
	 p.first == now;
	 p = *(m_map.begin()) )
    {
   
      ap.write( p.second );
      m_map.erase( m_map.begin() );

      if( m_map.size() == 0 ) {
	return;
      }

      p = *(m_map.begin());

    }

    m_wake_up.notify( p.first - now );
 
  }

  sc_event m_wake_up;
  multimap< sc_time , T> m_map;

};

#endif