From 7364acfc758a30f81aa75844f6b96b1e4e19990a Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 8 Dec 2018 01:58:26 -0800 Subject: systemc: Initial import of TLM headers from Accellera. These headers will need to be cleaned up and have some Accellera specific quirks ironed out of them, but I'll do that in a later change to make it clear what those changes are. Change-Id: Ia4e08633ab552b4c616c66c9b7e2bbd78ebfe7b9 Reviewed-on: https://gem5-review.googlesource.com/c/15055 Reviewed-by: Anthony Gutierrez Maintainer: Anthony Gutierrez --- .../tlm_channels/tlm_fifo/circular_buffer.h | 268 +++++++++++++++++++++ .../tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h | 263 ++++++++++++++++++++ .../tlm_channels/tlm_fifo/tlm_fifo_peek.h | 98 ++++++++ .../tlm_channels/tlm_fifo/tlm_fifo_put_get.h | 140 +++++++++++ .../tlm_channels/tlm_fifo/tlm_fifo_resize.h | 93 +++++++ .../tlm_req_rsp_channels/tlm_put_get_imp.h | 114 +++++++++ .../tlm_req_rsp_channels/tlm_req_rsp_channels.h | 155 ++++++++++++ 7 files changed, 1131 insertions(+) create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h create mode 100644 src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h (limited to 'src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels') diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h new file mode 100644 index 000000000..50309e31b --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h @@ -0,0 +1,268 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +// +// To the LRM writer : this class is purely an artifact of the implementation. +// + +#ifndef __CIRCULAR_BUFFER_H__ +#define __CIRCULAR_BUFFER_H__ + +#include + +namespace tlm { + +template < typename T > +class circular_buffer +{ +public: + + explicit + circular_buffer( int size = 0 ); + ~circular_buffer(); + + void resize( int size ); + void clear(); + + T read(); + void write( const T & ); + + bool is_empty() const { return used() == 0; } + bool is_full() const { return free() == 0; } + + int size() const { return m_size; } + int used() const { return m_used; } + int free() const { return m_free; } + + const T& read_data() const + { return buf_read( m_buf, m_ri ); } + + const T& peek_data( int i ) const + { return buf_read( m_buf, (m_ri + i) % size() ); } + + T & poke_data( int i ) + { return buf_read( m_buf , (m_wi + i) % size() ); } + + void debug() const; + +private: + void increment_write_pos( int i = 1 ); + void increment_read_pos( int i = 1 ); + + void init(); + + circular_buffer( const circular_buffer &b ); // disabled + circular_buffer &operator=( const circular_buffer & ); // disabled + + void* buf_alloc( int size ); + void buf_free( void*& buf ); + void buf_write( void* buf, int n, const T & t ); + T& buf_read( void* buf, int n ) const; + void buf_clear( void* buf, int n ); + +private: + int m_size; // size of the buffer + void* m_buf; // the buffer + int m_free; // number of free spaces + int m_used; // number of used spaces + int m_ri; // index of next read + int m_wi; // index of next write + +}; + +template< typename T > +void +circular_buffer::debug() const +{ + + std::cout << "Buffer debug" << std::endl; + std::cout << "Size : " << size() << std::endl; + std::cout << "Free/Used " << free() << "/" << used() << std::endl; + std::cout << "Indices : r/w = " << m_ri << "/" << m_wi << std::endl; + + if( is_empty() ) { + + std::cout << "empty" << std::endl; + + } + + if( is_full() ) { + + std::cout << "full" << std::endl; + + } + + std::cout << "Data : " << std::endl; + for( int i = 0; i < used(); i++ ) { + + std::cout << peek_data( i ) << std::endl; + + } + + +} + +template < typename T > +circular_buffer::circular_buffer( int size ) + : m_size(size) + , m_buf(0) +{ + init(); + +} + +template < typename T > +void +circular_buffer::clear() +{ + for( int i=0; i < used(); i++ ) { + buf_clear( m_buf, (m_ri + i) % m_size ); + } + m_free = m_size; + m_used = m_ri = m_wi = 0; +} + +template < typename T > +circular_buffer::~circular_buffer() +{ + clear(); + buf_free( m_buf ); +} + +template < typename T > +void +circular_buffer::resize( int size ) +{ + + int i; + void * new_buf = buf_alloc(size); + + for( i = 0; i < size && i < used(); i++ ) { + + buf_write( new_buf, i, peek_data( i ) ); + buf_clear( m_buf, (m_ri + i) % m_size ); + + } + + buf_free( m_buf ); + + m_size = size; + m_ri = 0; + m_wi = i % m_size; + m_used = i; + m_free = m_size - m_used; + + m_buf = new_buf; +} + + +template < typename T > +void +circular_buffer::init() { + + if( m_size > 0 ) { + m_buf = buf_alloc( m_size ); + } + + m_free = m_size; + m_used = 0; + m_ri = 0; + m_wi = 0; + +} + +template < typename T > +T +circular_buffer::read() +{ + T t = read_data(); + + buf_clear( m_buf, m_ri ); + increment_read_pos(); + + return t; +} + +template < typename T > +void +circular_buffer::write( const T &t ) +{ + buf_write( m_buf, m_wi, t ); + increment_write_pos(); +} + + +template < typename T > +void +circular_buffer::increment_write_pos( int i ) { + + m_wi = ( m_wi + i ) % m_size; + m_used += i; + m_free -= i; + +} + +template < typename T > +void +circular_buffer::increment_read_pos( int i ) { + + m_ri = ( m_ri + i ) % m_size; + m_used -= i; + m_free += i; + +} + +template < typename T > +inline void* +circular_buffer::buf_alloc( int size ) + { return new unsigned char[ size * sizeof(T) ]; } + +template < typename T > +inline void +circular_buffer::buf_free( void* & buf ) + { delete [] static_cast(buf); buf = 0; } + +template < typename T > +inline void +circular_buffer::buf_write( void* buf, int n, const T & t ) +{ + T* p = static_cast(buf) + n; + new (p) T(t); +} + +template < typename T > +inline T& +circular_buffer::buf_read( void* buf, int n ) const +{ + T* p = static_cast(buf) + n; + return *p; +} + +template < typename T > +inline void +circular_buffer::buf_clear( void* buf, int n ) +{ + T* p = static_cast(buf) + n; + p->~T(); +} + +} // namespace tlm + +#endif + diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h new file mode 100644 index 000000000..7b44a32ee --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h @@ -0,0 +1,263 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +#ifndef __TLM_FIFO_H__ +#define __TLM_FIFO_H__ + +// +// This implements put, get and peek +// +// It also implements 0 and infinite size fifos - but the size +// zero fifos aren't rendezvous like zero length fifos, they simply are both +// full and empty at the same time. +// +// The size can be dynamically changed using the resize interface +// +// To get an infinite fifo use a -ve size in the constructor. +// The absolute value of the size is taken as the starting size of the +// actual physical buffer. +// + +//#include + +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h" +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h" + +namespace tlm { + +template +class tlm_fifo : + public virtual tlm_fifo_get_if, + public virtual tlm_fifo_put_if, + public sc_core::sc_prim_channel +{ +public: + + // constructors + + explicit tlm_fifo( int size_ = 1 ) + : sc_core::sc_prim_channel( sc_core::sc_gen_unique_name( "fifo" ) ) { + + init( size_ ); + + } + + explicit tlm_fifo( const char* name_, int size_ = 1 ) + : sc_core::sc_prim_channel( name_ ) { + + init( size_ ); + + } + + // destructor + + virtual ~tlm_fifo() {} + + // tlm get interface + + T get( tlm_tag * = 0 ); + + bool nb_get( T& ); + bool nb_can_get( tlm_tag * = 0 ) const; + const sc_core::sc_event &ok_to_get( tlm_tag * = 0 ) const { + return m_data_written_event; + } + + // tlm peek interface + + T peek( tlm_tag * = 0 ) const; + + bool nb_peek( T& ) const; + bool nb_can_peek( tlm_tag * = 0 ) const; + const sc_core::sc_event &ok_to_peek( tlm_tag * = 0 ) const { + return m_data_written_event; + } + + // tlm put interface + + void put( const T& ); + + bool nb_put( const T& ); + bool nb_can_put( tlm_tag * = 0 ) const; + + const sc_core::sc_event& ok_to_put( tlm_tag * = 0 ) const { + return m_data_read_event; + } + + // resize if + + void nb_expand( unsigned int n = 1 ); + void nb_unbound( unsigned int n = 16 ); + + bool nb_reduce( unsigned int n = 1 ); + bool nb_bound( unsigned int n ); + + // debug interface + + bool nb_peek( T & , int n ) const; + bool nb_poke( const T & , int n = 0 ); + + int used() const { + return m_num_readable - m_num_read; + } + + int size() const { + return m_size; + } + + void debug() const { + + if( is_empty() ) std::cout << "empty" << std::endl; + if( is_full() ) std::cout << "full" << std::endl; + + std::cout << "size " << size() << " - " << used() << " used " + << std::endl; + std::cout << "readable " << m_num_readable + << std::endl; + std::cout << "written/read " << m_num_written << "/" << m_num_read + << std::endl; + + } + + // support functions + + static const char* const kind_string; + + const char* kind() const + { return kind_string; } + + +protected: + sc_core::sc_event &read_event( tlm_tag * = 0 ) { + return m_data_read_event; + } + +protected: + + void update(); + + // support methods + + void init( int ); + +protected: + + circular_buffer buffer; + + int m_size; // logical size of fifo + + int m_num_readable; // #samples readable + int m_num_read; // #samples read during this delta cycle + int m_num_written; // #samples written during this delta cycle + bool m_expand; // has an expand occurred during this delta cycle ? + int m_num_read_no_notify; // #samples read without notify during this delta cycle + + sc_core::sc_event m_data_read_event; + sc_core::sc_event m_data_written_event; + +private: + + // disabled + tlm_fifo( const tlm_fifo& ); + tlm_fifo& operator = ( const tlm_fifo& ); + + // + // use nb_can_get() and nb_can_put() rather than the following two + // private functions + // + + bool is_empty() const { + return used() == 0; + } + + bool is_full() const { + //return size() == m_num_readable + m_num_written; // Old buggy code + if( size() < 0 ) + return false; + else + return size() <= m_num_readable + m_num_written; + } + +}; + +template +const char* const tlm_fifo::kind_string = "tlm_fifo"; + + +/****************************************************************** +// +// init and update +// +******************************************************************/ + +template< typename T > +inline +void +tlm_fifo::init( int size_ ) { + + if( size_ > 0 ) { + buffer.resize( size_ ); + } + + else if( size_ < 0 ) { + buffer.resize( -size_ ); + } + + else { + buffer.resize( 16 ); + } + + m_size = size_; + m_num_readable = 0; + m_num_read = 0; + m_num_written = 0; + m_expand = false; + m_num_read_no_notify = false; + +} + +template < typename T> +inline +void +tlm_fifo::update() +{ + if( m_num_read > m_num_read_no_notify || m_expand ) { + m_data_read_event.notify( sc_core::SC_ZERO_TIME ); + } + + if( m_num_written > 0 ) { + m_data_written_event.notify( sc_core::SC_ZERO_TIME ); + } + + m_expand = false; + m_num_read = 0; + m_num_written = 0; + m_num_readable = buffer.used(); + m_num_read_no_notify = 0; + +} + +} // namespace tlm + +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h" +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h" +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h" + +#endif + diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h new file mode 100644 index 000000000..e856c5657 --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h @@ -0,0 +1,98 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +#ifndef __TLM_FIFO_PEEK_H__ +#define __TLM_FIFO_PEEK_H__ + +namespace tlm { + +template < typename T> +inline +T +tlm_fifo::peek( tlm_tag * ) const { + + while( is_empty() ) { + + // call free-standing sc_core::wait(), + // since sc_prim_channel::wait(.) is not const + + sc_core::wait( m_data_written_event ); + } + + return buffer.read_data(); + +} + +template < typename T> +inline +bool +tlm_fifo::nb_peek( T &t ) const { + + if( used() < 1 ) { + return false; + } + + t = buffer.peek_data( 0 ); + return true; + +} + +template < typename T> +inline +bool +tlm_fifo::nb_peek( T &t , int n ) const { + + if( n >= used() || n < -1 ) { + return false; + } + + if( n == -1 ) { + n = used() - 1; + } + + t = buffer.peek_data( n ); + return true; + +} + +template< typename T > +inline +bool +tlm_fifo::nb_can_peek( tlm_tag * ) const +{ + return !is_empty(); +} + +template < typename T> +inline +bool +tlm_fifo::nb_poke( const T &t , int n ) { + + if( n >= used() || n < 0 ) { + return false; + } + + buffer.poke_data( n ) = t; + return true; + +} + +} // namespace tlm + +#endif diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h new file mode 100644 index 000000000..2728e0394 --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h @@ -0,0 +1,140 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +#ifndef __TLM_FIFO_PUT_GET_IF_H__ +#define __TLM_FIFO_PUT_GET_IF_H__ + +namespace tlm { + +/****************************************************************** +// +// get interface +// +******************************************************************/ + +template +inline +T +tlm_fifo::get( tlm_tag * ) +{ + + while( is_empty() ) { + wait( m_data_written_event ); + } + + m_num_read ++; + request_update(); + + return buffer.read(); + +} + +// non-blocking read + +template +inline +bool +tlm_fifo::nb_get( T& val_ ) +{ + + if( is_empty() ) { + return false; + } + + m_num_read ++; + request_update(); + + val_ = buffer.read(); + + return true; + +} + +template +inline +bool +tlm_fifo::nb_can_get( tlm_tag * ) const { + + return !is_empty(); + +} + + +/****************************************************************** +// +// put interface +// +******************************************************************/ + +template +inline +void +tlm_fifo::put( const T& val_ ) +{ + while( is_full() ) { + wait( m_data_read_event ); + } + + if( buffer.is_full() ) { + + buffer.resize( buffer.size() * 2 ); + + } + + m_num_written ++; + buffer.write( val_ ); + + request_update(); +} + +template +inline +bool +tlm_fifo::nb_put( const T& val_ ) +{ + + if( is_full() ) { + return false; + } + + if( buffer.is_full() ) { + + buffer.resize( buffer.size() * 2 ); + + } + + m_num_written ++; + buffer.write( val_ ); + request_update(); + + return true; +} + +template < typename T > +inline +bool +tlm_fifo::nb_can_put( tlm_tag * ) const { + + return !is_full(); + +} + +} // namespace tlm + +#endif diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h new file mode 100644 index 000000000..39932fea1 --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h @@ -0,0 +1,93 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +#ifndef __TLM_FIFO_RESIZE_H__ +#define __TLM_FIFO_RESIZE_H__ + +/****************************************************************** +// +// resize interface +// +******************************************************************/ + +namespace tlm { + +template < typename T> +inline +void +tlm_fifo::nb_expand( unsigned int n ) { + + if( m_size >= 0 ) { + m_expand = true; + m_size += n; + request_update(); + } +} + +template < typename T> +inline +void +tlm_fifo::nb_unbound( unsigned int n ) { + + m_expand = true; + m_size = -n; + + if( buffer.size() < static_cast( n ) ) { + buffer.resize( n ); + } + + request_update(); + +} + +template < typename T> +inline +bool +tlm_fifo::nb_reduce( unsigned int n ) { + + if( m_size < 0 ) { + return false; + } + + return nb_bound( size() - n ); + +} + +template < typename T> +inline +bool +tlm_fifo::nb_bound( unsigned int new_size ) { + + bool ret = true; + + if( static_cast( new_size ) < used() ) { + + new_size = used(); + ret = false; + + } + + m_size = new_size; + return ret; + +} + +} // namespace tlm + +#endif diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h new file mode 100644 index 000000000..36dbd21d6 --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h @@ -0,0 +1,114 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +// +// To the LRM writer : these classes are purely artifacts of the implementation. +// + +#ifndef __TLM_PUT_GET_IMP_H__ +#define __TLM_PUT_GET_IMP_H__ + +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h" + +namespace tlm { + +template < typename PUT_DATA , typename GET_DATA> +class tlm_put_get_imp : + private virtual tlm_put_if< PUT_DATA > , + private virtual tlm_get_peek_if< GET_DATA > +{ +public: + tlm_put_get_imp( tlm_put_if &p , + tlm_get_peek_if &g ) : + put_fifo( p ) , get_fifo( g ) {} + + // put interface + + void put( const PUT_DATA &t ) { put_fifo.put( t ); } + + bool nb_put( const PUT_DATA &t ) { return put_fifo.nb_put( t ); } + bool nb_can_put( tlm_tag *t = 0 ) const { + return put_fifo.nb_can_put( t ); + } + const sc_core::sc_event &ok_to_put( tlm_tag *t = 0 ) const { + return put_fifo.ok_to_put( t ); + } + + // get interface + + GET_DATA get( tlm_tag * = 0 ) { return get_fifo.get(); } + + bool nb_get( GET_DATA &t ) { return get_fifo.nb_get( t ); } + + bool nb_can_get( tlm_tag *t = 0 ) const { + return get_fifo.nb_can_get( t ); + } + + virtual const sc_core::sc_event &ok_to_get( tlm_tag *t = 0 ) const { + return get_fifo.ok_to_get( t ); + } + + // peek interface + + GET_DATA peek( tlm_tag * = 0 ) const { return get_fifo.peek(); } + + bool nb_peek( GET_DATA &t ) const { return get_fifo.nb_peek( t ); } + + bool nb_can_peek( tlm_tag *t = 0 ) const { + return get_fifo.nb_can_peek( t ); + } + + virtual const sc_core::sc_event &ok_to_peek( tlm_tag *t = 0 ) const { + return get_fifo.ok_to_peek( t ); + } + +private: + tlm_put_if &put_fifo; + tlm_get_peek_if &get_fifo; +}; + +template < typename REQ , typename RSP > +class tlm_master_imp : + private tlm_put_get_imp< REQ , RSP > , + public virtual tlm_master_if< REQ , RSP > +{ +public: + + tlm_master_imp( tlm_put_if &req , + tlm_get_peek_if &rsp ) : + tlm_put_get_imp( req , rsp ) {} + +}; + +template < typename REQ , typename RSP > +class tlm_slave_imp : + private tlm_put_get_imp< RSP , REQ > , + public virtual tlm_slave_if< REQ , RSP > +{ +public: + + tlm_slave_imp( tlm_get_peek_if &req , + tlm_put_if &rsp ) : + tlm_put_get_imp( rsp , req ) {} + +}; + +} // namespace tlm + +#endif diff --git a/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h new file mode 100644 index 000000000..7bd5652f7 --- /dev/null +++ b/src/systemc/ext/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h @@ -0,0 +1,155 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +#ifndef __TLM_REQ_RSP_CHANNELS_H__ +#define __TLM_REQ_RSP_CHANNELS_H__ + +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h" +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h" +#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h" + +namespace tlm { + +template < typename REQ , typename RSP , + typename REQ_CHANNEL = tlm_fifo , + typename RSP_CHANNEL = tlm_fifo > + +class tlm_req_rsp_channel : public sc_core::sc_module +{ +public: + // uni-directional slave interface + + sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export; + sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export; + + // uni-directional master interface + + sc_core::sc_export< tlm_fifo_put_if< REQ > > put_request_export; + sc_core::sc_export< tlm_fifo_get_if< RSP > > get_response_export; + + // master / slave interfaces + + sc_core::sc_export< tlm_master_if< REQ , RSP > > master_export; + sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export; + + + tlm_req_rsp_channel( int req_size = 1 , int rsp_size = 1 ) : + sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("tlm_req_rsp_channel") ) ) , + request_fifo( req_size ) , + response_fifo( rsp_size ) , + master( request_fifo , response_fifo ) , + slave( request_fifo , response_fifo ) + { + + bind_exports(); + + } + + tlm_req_rsp_channel( sc_core::sc_module_name module_name , + int req_size = 1 , int rsp_size = 1 ) : + sc_core::sc_module( module_name ) , + request_fifo( req_size ) , + response_fifo( rsp_size ) , + master( request_fifo , response_fifo ) , + slave( request_fifo , response_fifo ) + { + + bind_exports(); + + } + +private: + void bind_exports() { + + put_request_export( request_fifo ); + get_request_export( request_fifo ); + + put_response_export( response_fifo ); + get_response_export( response_fifo ); + + master_export( master ); + slave_export( slave ); + + } + +protected: + REQ_CHANNEL request_fifo; + RSP_CHANNEL response_fifo; + + tlm_master_imp< REQ , RSP > master; + tlm_slave_imp< REQ , RSP > slave; +}; + +template < typename REQ , typename RSP , + typename REQ_CHANNEL = tlm_fifo , + typename RSP_CHANNEL = tlm_fifo > +class tlm_transport_channel : public sc_core::sc_module +{ +public: + + // master transport interface + + sc_core::sc_export< tlm_transport_if< REQ , RSP > > target_export; + + // slave interfaces + + sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export; + sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export; + + sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export; + + tlm_transport_channel() : + sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("transport_channel" ) ) ) , + target_export("target_export") , + req_rsp( "req_rsp" , 1 , 1 ) , + t2m("ts2m") + { + do_binding(); + } + + tlm_transport_channel( sc_core::sc_module_name nm ) : + sc_core::sc_module( nm ) , + target_export("target_export") , + req_rsp( "req_rsp" , 1 , 1 ) , + t2m("tsm" ) + { + do_binding(); + } + +private: + void do_binding() { + + target_export( t2m.target_export ); + + t2m.master_port( req_rsp.master_export ); + + get_request_export( req_rsp.get_request_export ); + put_response_export( req_rsp.put_response_export ); + slave_export( req_rsp.slave_export ); + + } + + tlm_req_rsp_channel< REQ , RSP , REQ_CHANNEL , RSP_CHANNEL > req_rsp; + tlm_transport_to_master< REQ , RSP > t2m; + +}; + +} // namespace tlm + +#endif -- cgit v1.2.3