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_annotated_fifo.h

\r
#ifndef TLM_ANNOTATED_FIFO_HEADER\r
#define TLM_ANNOTATED_FIFO_HEADER\r
\r
#include "tlm_core.h"\r
#include "tlm_annotated/tlm_annotated_ifs/tlm_annotated_ifs.h"\r
#include "tlm_annotated/tlm_annotated_channels/tlm_peq.h"\r
\r
using analysis::analysis_port;\r
using analysis::analysis_if;\r
\r
using tlm_core::tlm_fifo;\r
using tlm_core::tlm_tag;\r
\r
\r
template< typename T >\r
class tlm_internal_annotated_fifo : \r
public tlm_fifo<T> ,\r
  public virtual analysis_if<T> ,\r
  public virtual analysis_if< tlm_tag< T > * > {\r
  \r
 public:\r
  typedef tlm_tag<T> *my_tag_ptr;\r
\r
  tlm_internal_annotated_fifo( const char *nm , int size ) :\r
    tlm_fifo<T>( nm , size ) {}\r
\r
  void write( const T &t ) {\r
    assert( nb_can_put( (my_tag_ptr)0 ) );\r
    nb_put( t );\r
  }\r
  \r
  void write( const my_tag_ptr & ) {\r
    read_event( (my_tag_ptr)0 ).notify( SC_ZERO_TIME );\r
  }\r
  \r
};\r
\r
//\r
// From the put point of view, delayed puts are immediate. The transaction T is\r
// considered to be in the fifo from the time at which nb_put( T , t ) was\r
// called.\r
//\r
// However, from the get point of view, the effect of the delayed put is not\r
// seen until t has expired. We cannot see the new data on the get side until\r
// time t.\r
//\r
// The same rules apply to a delayed get : a get( T , t ) gets T immediately,\r
// but the put side does not see the extra space in the fifo until time t.\r
//\r
// In summary : put->put and get->get is immediate, but put->get and get->put\r
// are delayed.\r
//\r
// Although the precise effects of put and get may vary from channel to channel\r
// these observability rules are part of the definition of the annotated\r
// interfaces.\r
//\r
\r
template< typename T >\r
class tlm_annotated_fifo :\r
public sc_module ,\r
public virtual tlm_annotated_put_if< T  > ,\r
public virtual tlm_annotated_get_peek_if < T  > {\r
\r
 public:\r
\r
   tlm_annotated_fifo( sc_module_name nm , int size = 1 ) :\r
     sc_module( nm ) ,\r
     m_size( size ) ,\r
     m_fifo("internal_fifo" , size ) ,\r
     m_put_peq("put_peq") ,\r
     m_get_peq("pop_peq") {\r
\r
     m_put_peq.ap( m_fifo );\r
     m_get_peq.ap( m_fifo );\r
\r
  }\r
\r
   tlm_annotated_fifo( int size = 1 ) :\r
     sc_module( sc_gen_unique_name("annotated_fifo") ) ,\r
     m_size( size ) ,\r
     m_fifo("internal_fifo" , size ) ,\r
     m_put_peq("put_peq") ,\r
     m_get_peq("pop_peq") {\r
\r
     m_put_peq.ap( m_fifo );\r
     m_get_peq.ap( m_fifo );\r
\r
  }\r
  // non annotated nb_can_* methods\r
\r
  bool nb_can_put( tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.nb_can_put( m_put_peq.size() + m_get_peq.size() + 1 );\r
  }\r
\r
  bool nb_can_get( tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.nb_can_get();\r
  }\r
\r
  bool nb_can_peek( tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.nb_can_peek();\r
  }\r
\r
  //\r
  // annotated nb_can_* methods\r
  //\r
  // these are virtual because we may want to add some additional time based\r
  // restrictions re: what can can be put and popped when : for example, we \r
  // might want to insist that we only ever post to the end of both peqs, to \r
  // preserve the ordering of the transactions.\r
  //\r
\r
  // nb_can_put is part of the annotated non blocking put interface\r
  \r
  virtual bool nb_can_put( const sc_time &time , tlm_tag<T> *t = 0 ) const {\r
    return nb_can_put();\r
  }\r
  \r
  virtual bool nb_can_get( const sc_time &time , tlm_tag<T> *t = 0 ) const {\r
    return nb_can_get();\r
  }\r
\r
  // ok_to_* methods \r
\r
  const sc_event &ok_to_put(  tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.ok_to_put();\r
  }\r
\r
  const sc_event &ok_to_get(  tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.ok_to_get();\r
  }\r
\r
  const sc_event &ok_to_peek(  tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.ok_to_peek();\r
  }\r
  \r
  // non annotated nonblocking put, get + peek\r
 \r
  bool nb_put( const T &t ) {\r
\r
    if( !nb_can_put() ) {\r
      return false;\r
    }\r
 \r
    assert( m_fifo.nb_can_put() );\r
    m_fifo.nb_put( t );\r
    return true;\r
\r
  }\r
  \r
  bool nb_get( T &t ) {\r
\r
    if( !nb_can_get() ) {\r
      return false;\r
    }\r
 \r
    assert( m_fifo.nb_can_get() );\r
    m_fifo.nb_get( t );\r
    return true;\r
\r
  }\r
\r
  bool nb_peek( T &t ) const {\r
    return m_fifo.nb_peek( t );\r
  }\r
\r
  // annotated nonblocking methods\r
\r
  \r
  bool nb_put( const T &transaction , const sc_time &time ) {\r
\r
    if( !nb_can_put( time ) ) {\r
      return false;\r
    }\r
    \r
    m_put_peq.write( transaction , time );\r
    return true;\r
\r
  }\r
\r
  virtual bool nb_get( T &transaction , const sc_time &time ) {\r
    static tlm_tag<T> *t;\r
\r
    if( !m_fifo.nb_get_no_notify( transaction ) ) {\r
      return false;\r
    }\r
\r
    m_get_peq.write( t , time );\r
    return true;\r
\r
  }\r
  \r
  // blocking put, get and peek\r
\r
  void put( const T &t ) {\r
    while( !nb_put( t ) ) {\r
      wait( ok_to_put() );\r
    }\r
  }\r
\r
  T get( tlm_tag<T> *t = 0 ) {\r
\r
    T trans;\r
\r
    while( !nb_get( trans ) ) {\r
      wait( ok_to_get() );\r
    }\r
\r
    return trans;\r
  }\r
\r
  T peek( tlm_tag<T> *t = 0 ) const {\r
    return m_fifo.peek();\r
  }\r
\r
  int size() { return m_size; }\r
\r
 private:\r
  int m_size;\r
\r
 protected: // to allow for overriding of annotated can_put and can_get\r
\r
  tlm_internal_annotated_fifo<T> m_fifo;\r
\r
  tlm_peq<T> m_put_peq;\r
  tlm_peq< tlm_tag<T> *> m_get_peq;\r
\r
};\r
#endif\r