Initial commit of OpenSPARC T2 design and verification files.

[OpenSPARC-T2-DV] / verif / model / vendor / TLM-2006-11-29 / tlm / tlm_core / tlm_fifo / circular_buffer.h

/*****************************************************************************\r
\r
  The following code is derived, directly or indirectly, from the SystemC\r
  source code Copyright (c) 1996-2004 by all Contributors.\r
  All Rights reserved.\r
\r
  The contents of this file are subject to the restrictions and limitations\r
  set forth in the SystemC Open Source License Version 2.4 (the "License");\r
  You may not use this file except in compliance with such restrictions and\r
  limitations. You may obtain instructions on how to receive a copy of the\r
  License at http://www.systemc.org/. Software distributed by Contributors\r
  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF\r
  ANY KIND, either express or implied. See the License for the specific\r
  language governing rights and limitations under the License.\r
\r
 *****************************************************************************/\r
\r
\r
//\r
// To the LRM writer : this class is purely an artifact of the implementation.\r
//\r
\r
#ifndef CIRCULAR_BUFFER_HEADER\r
#define CIRCULAR_BUFFER_HEADER\r
\r
#include <iostream>\r
\r
using std::cout;\r
using std::endl;\r
\r
template < typename T >\r
class circular_buffer\r
{\r
public:\r
  circular_buffer( int size );\r
\r
  circular_buffer<T> &operator=( const circular_buffer<T> & ); \r
\r
  ~circular_buffer() { delete [] m_buf; }\r
  \r
  void resize( int size );\r
\r
  const T &read();\r
  void write( const T & );\r
\r
  bool is_empty() const { return used() == 0; }\r
  bool is_full() const { return free() == 0; }\r
\r
  int size() const { return m_size; }\r
  int used() const { return m_used; }\r
  int free() const { return m_free; }\r
\r
  T &write_data() { return m_buf[m_wi]; }\r
  const T &read_data() const { return m_buf[m_ri]; }\r
\r
  const T &peek_data( int i ) const { return m_buf[(m_ri + i) % size()]; }\r
  T &poke_data( int i ) { return m_buf[(m_ri + i) % size()]; }\r
\r
  void increment_write_pos( int i = 1 );\r
  void increment_read_pos( int i = 1 );\r
\r
  void init();\r
\r
  void debug() const;\r
\r
private:\r
  circular_buffer( const circular_buffer<T> &b ); // disabled\r
  void copy( const circular_buffer<T> &b );\r
\r
private:\r
  int m_size;			// size of the buffer\r
  T*  m_buf;			// the buffer\r
  int m_free;                   // number of free spaces\r
  int m_used;                   // number of used spaces\r
  int m_ri;			// index of next read\r
  int m_wi;			// index of next write\r
  \r
};\r
\r
template< typename T >\r
void\r
circular_buffer<T>::debug() const\r
{\r
\r
  cout << "Buffer debug" << endl;\r
  cout << "Size : " << size() << endl;\r
  cout << "Free/Used " << free() << "/" << used() << endl;\r
  cout << "Indeces : r/w = " << m_ri << "/" << m_wi << endl;\r
\r
  if( is_empty() ) {\r
\r
    cout << "empty" << endl;\r
\r
  }\r
\r
  if( is_full() ) {\r
\r
    cout << "full" << endl;\r
\r
  }\r
\r
  cout << "Data : " << endl;\r
  for( int i = 0; i < used(); i++ ) {\r
\r
    cout << peek_data( i ) << endl;\r
\r
  }\r
\r
\r
}\r
\r
template < typename T >\r
circular_buffer<T>::\r
circular_buffer( int size ) {\r
\r
  m_size = size;\r
  m_buf = new T[m_size];\r
\r
  init();\r
\r
}\r
 \r
template < typename T >\r
circular_buffer<T> &\r
circular_buffer<T>::operator=( const circular_buffer<T> &b ) {\r
\r
  init();\r
\r
  for( int i = 0; i < size() && i < b.used(); i++ ) {\r
\r
    write( b.peek_data( i ) );\r
\r
  }\r
\r
  return *this;\r
  \r
}\r
\r
template < typename T >\r
void\r
circular_buffer<T>::resize( int size )\r
{\r
\r
  int i;\r
  T *new_buf = new T[size];\r
\r
  for( i = 0; i < size && i < used(); i++ ) {\r
\r
    new_buf[i] = peek_data( i );\r
\r
  }\r
\r
  delete [] m_buf;\r
\r
  m_size = size;\r
  m_ri = 0;\r
  m_wi = i % m_size;\r
  m_used = i;\r
  m_free = m_size - m_used;\r
  \r
  m_buf = new_buf;\r
\r
}\r
 \r
\r
template < typename T >\r
void\r
circular_buffer<T>::init() {\r
\r
  m_free = m_size;\r
  m_used = 0;\r
  m_ri = 0;\r
  m_wi = 0;\r
\r
}\r
\r
template < typename T >\r
void\r
circular_buffer<T>::copy( const circular_buffer<T> &b )\r
{\r
\r
  m_size = b.m_size;   // size of the buffer\r
  m_buf = b.m_buf;     // the buffer\r
  m_free = b.m_free;   // number of free spaces\r
  m_used = b.m_used;   // number of used spaces\r
  m_ri = b.m_ri;       // index of next read\r
  m_wi = b.m_wi;       // index of next write  \r
\r
}\r
\r
template < typename T >\r
const T &\r
circular_buffer<T>::read()\r
{\r
\r
  const T &t = read_data();\r
\r
  increment_read_pos();\r
\r
  return t;\r
\r
}\r
\r
template < typename T >\r
void\r
circular_buffer<T>::write( const T &t )\r
{\r
\r
  write_data() = t;\r
  increment_write_pos();\r
\r
}\r
\r
\r
template < typename T >\r
void\r
circular_buffer<T>::increment_write_pos( int i ) {\r
\r
  m_wi = ( m_wi + i ) % m_size;\r
  m_used += i;\r
  m_free -= i;\r
  \r
}\r
\r
template < typename T >\r
void\r
circular_buffer<T>::increment_read_pos( int i ) {\r
\r
  m_ri = ( m_ri + i ) % m_size;\r
  m_used -= i;\r
  m_free += i;\r
  \r
}\r
\r
#endif\r
\r