/*****************************************************************************
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.
*****************************************************************************/
/*****************************************************************************
sc_port.cpp -- Base classes of all port classes.
Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
CHANGE LOG AT THE END OF THE FILE
*****************************************************************************/
#include "sysc/kernel/sc_simcontext.h"
#include "sysc/kernel/sc_module.h"
#include "sysc/kernel/sc_object_int.h"
#include "sysc/kernel/sc_method_process.h"
#include "sysc/kernel/sc_thread_process.h"
#include "sysc/communication/sc_communication_ids.h"
#include "sysc/utils/sc_utils_ids.h"
#include "sysc/communication/sc_event_finder.h"
#include "sysc/communication/sc_port.h"
#include "sysc/communication/sc_signal_ifs.h"
namespace sc_core {
// ----------------------------------------------------------------------------
// STRUCT : sc_bind_elem
// ----------------------------------------------------------------------------
struct sc_bind_elem
{
// constructors
sc_bind_elem();
explicit sc_bind_elem( sc_interface* interface_ );
explicit sc_bind_elem( sc_port_base* parent_ );
sc_interface* iface;
sc_port_base* parent;
};
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
// constructors
sc_bind_elem::sc_bind_elem()
: iface( 0 ),
parent( 0 )
{}
sc_bind_elem::sc_bind_elem( sc_interface* interface_ )
: iface( interface_ ),
parent( 0 )
{}
sc_bind_elem::sc_bind_elem( sc_port_base* parent_ )
: iface( 0 ),
parent( parent_ )
{}
// ----------------------------------------------------------------------------
// STRUCT : sc_bind_ef
// ----------------------------------------------------------------------------
struct sc_bind_ef
{
// constructor
sc_bind_ef( sc_process_b* , sc_event_finder* );
// destructor
~sc_bind_ef();
sc_process_b* handle;
sc_event_finder* event_finder;
};
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
// constructor
sc_bind_ef::sc_bind_ef( sc_process_b* handle_,
sc_event_finder* event_finder_ )
: handle( handle_ ),
event_finder( event_finder_ )
{}
// destructor
sc_bind_ef::~sc_bind_ef()
{
}
// ----------------------------------------------------------------------------
// STRUCT : sc_bind_info
// ----------------------------------------------------------------------------
struct sc_bind_info
{
// constructor
explicit sc_bind_info( int max_size_,
sc_port_policy policy_=SC_ONE_OR_MORE_BOUND );
// destructor
~sc_bind_info();
int max_size() const;
sc_port_policy policy() const;
int size() const;
int m_max_size;
sc_port_policy m_policy;
std::vector<sc_bind_elem*> vec;
bool has_parent;
int last_add;
bool is_leaf;
bool complete;
std::vector<sc_bind_ef*> thread_vec;
std::vector<sc_bind_ef*> method_vec;
};
// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
// constructor
sc_bind_info::sc_bind_info( int max_size_, sc_port_policy policy_ )
: m_max_size( max_size_ ),
m_policy( policy_ ),
vec(),
has_parent( false ),
last_add( -1 ),
is_leaf( true ),
complete( false ),
thread_vec(),
method_vec()
{}
// destructor
sc_bind_info::~sc_bind_info()
{
for( int i = size() - 1; i >= 0; -- i ) {
delete vec[i];
}
}
int
sc_bind_info::max_size() const
{
return m_max_size ? m_max_size : (int) vec.size();
}
sc_port_policy
sc_bind_info::policy() const
{
return m_policy;
}
int
sc_bind_info::size() const
{
return vec.size();
}
// ----------------------------------------------------------------------------
// CLASS : sc_port_base
//
// Abstract base class for class sc_port_b.
// ----------------------------------------------------------------------------
// This method exists to get around a problem in VCC 6.0 where you cannot
// have a friend class that is templated. So sc_port_b<IF> calls this class
// instead of sc_process_b::add_static_event.
void sc_port_base::add_static_event(
sc_method_handle process_p, const sc_event& event ) const
{
process_p->add_static_event( event );
}
void sc_port_base::add_static_event(
sc_thread_handle process_p, const sc_event& event ) const
{
process_p->add_static_event( event );
}
// return number of interfaces that will be bound, or are bound:
int sc_port_base::bind_count()
{
if ( m_bind_info )
return m_bind_info->size();
else
return interface_count();
}
// error reporting
void
sc_port_base::report_error( const char* id, const char* add_msg ) const
{
char msg[BUFSIZ];
if( add_msg != 0 ) {
std::sprintf( msg, "%s: port '%s' (%s)", add_msg, name(), kind() );
} else {
std::sprintf( msg, "port '%s' (%s)", name(), kind() );
}
SC_REPORT_ERROR( id, msg );
}
// constructors
sc_port_base::sc_port_base(
int max_size_, sc_port_policy policy
) :
sc_object( sc_gen_unique_name( "port" ) ),
m_bind_info(NULL)
{
simcontext()->get_port_registry()->insert( this );
m_bind_info = new sc_bind_info( max_size_, policy );
}
sc_port_base::sc_port_base(
const char* name_, int max_size_, sc_port_policy policy
) :
sc_object( name_ ),
m_bind_info(NULL)
{
simcontext()->get_port_registry()->insert( this );
m_bind_info = new sc_bind_info( max_size_, policy );
}
// destructor
sc_port_base::~sc_port_base()
{
simcontext()->get_port_registry()->remove( this );
delete m_bind_info;
}
// bind interface to this port
void
sc_port_base::bind( sc_interface& interface_ )
{
if( m_bind_info == 0 ) {
// cannot bind an interface after elaboration
report_error( SC_ID_BIND_IF_TO_PORT_, "simulation running" );
}
m_bind_info->vec.push_back( new sc_bind_elem( &interface_ ) );
if( ! m_bind_info->has_parent ) {
// add (cache) the interface
add_interface( &interface_ );
m_bind_info->last_add ++;
}
}
// bind parent port to this port
void
sc_port_base::bind( this_type& parent_ )
{
if( m_bind_info == 0 ) {
// cannot bind a parent port after elaboration
report_error( SC_ID_BIND_PORT_TO_PORT_, "simulation running" );
}
if( &parent_ == this ) {
report_error( SC_ID_BIND_PORT_TO_PORT_, "same port" );
}
// check if parent port is already bound to this port
#if 0
for( int i = m_bind_info->size() - 1; i >= 0; -- i ) {
if( &parent_ == m_bind_info->vec[i]->parent ) {
report_error( SC_ID_BIND_PORT_TO_PORT_, "already bound" );
}
}
#endif //
m_bind_info->vec.push_back( new sc_bind_elem( &parent_ ) );
m_bind_info->has_parent = true;
parent_.m_bind_info->is_leaf = false;
}
// called by construction_done (null by default)
void sc_port_base::before_end_of_elaboration()
{}
// called by elaboration_done (does nothing)
void
sc_port_base::end_of_elaboration()
{}
// called by sc_port_registry::start_simulation (does nothing by default)
void sc_port_base::start_of_simulation()
{}
// called by sc_port_registry::simulation_done (does nothing by default)
void sc_port_base::end_of_simulation()
{}
// called by class sc_module for positional binding
int
sc_port_base::pbind( sc_interface& interface_ )
{
if( m_bind_info == 0 ) {
// cannot bind an interface after elaboration
report_error( SC_ID_BIND_IF_TO_PORT_, "simulation running" );
}
if( m_bind_info->size() != 0 ) {
// first interface already bound
return 1;
}
return vbind( interface_ );
}
int
sc_port_base::pbind( sc_port_base& parent_ )
{
if( m_bind_info == 0 ) {
// cannot bind a parent port after elaboration
report_error( SC_ID_BIND_PORT_TO_PORT_, "simulation running" );
}
if( m_bind_info->size() != 0 ) {
// first interface already bound
return 1;
}
return vbind( parent_ );
}
// called by the sc_sensitive* classes
void
sc_port_base::make_sensitive( sc_thread_handle handle_,
sc_event_finder* event_finder_ ) const
{
assert( m_bind_info != 0 );
m_bind_info->thread_vec.push_back(
new sc_bind_ef( (sc_process_b*)handle_, event_finder_ ) );
}
void
sc_port_base::make_sensitive( sc_method_handle handle_,
sc_event_finder* event_finder_ ) const
{
assert( m_bind_info != 0 );
m_bind_info->method_vec.push_back(
new sc_bind_ef( (sc_process_b*)handle_, event_finder_ ) );
}
// support methods
int
sc_port_base::first_parent()
{
for( int i = 0; i < m_bind_info->size(); ++ i ) {
if( m_bind_info->vec[i]->parent != 0 ) {
return i;
}
}
return -1;
}
void
sc_port_base::insert_parent( int i )
{
std::vector<sc_bind_elem*>& vec = m_bind_info->vec;
this_type* parent = vec[i]->parent;
// IF OUR PARENT HAS NO BINDING THEN IGNORE IT:
//
// Note that the zeroing of the parent pointer must occur before this
// test
vec[i]->parent = 0;
if ( parent->m_bind_info->vec.size() == 0 ) return;
vec[i]->iface = parent->m_bind_info->vec[0]->iface;
int n = parent->m_bind_info->size() - 1;
if( n > 0 ) {
// resize the bind vector (by adding new elements)
for( int k = 0; k < n; ++ k ) {
vec.push_back( new sc_bind_elem() );
}
// move elements in the bind vector
for( int k = m_bind_info->size() - n - 1; k > i; -- k ) {
vec[k + n]->iface = vec[k]->iface;
vec[k + n]->parent = vec[k]->parent;
}
// insert parent interfaces into the bind vector
for( int k = i + 1; k <= i + n; ++ k ) {
vec[k]->iface = parent->m_bind_info->vec[k - i]->iface;
vec[k]->parent = 0;
}
}
}
// called when elaboration is done
void
sc_port_base::complete_binding()
{
char msg_buffer[128]; // For error message construction.
// IF BINDING HAS ALREADY BEEN COMPLETED IGNORE THIS CALL:
assert( m_bind_info != 0 );
if( m_bind_info->complete ) {
return;
}
// COMPLETE BINDING OF OUR PARENT PORTS SO THAT WE CAN USE THAT INFORMATION:
int i = first_parent();
while( i >= 0 ) {
m_bind_info->vec[i]->parent->complete_binding();
insert_parent( i );
i = first_parent();
}
// LOOP OVER BINDING INFORMATION TO COMPLETE THE BINDING PROCESS:
int size;
for( int j = 0; j < m_bind_info->size(); ++ j ) {
sc_interface* iface = m_bind_info->vec[j]->iface;
// if the interface is zero this was for an unbound port.
if ( iface == 0 ) continue;
// add (cache) the interface
if( j > m_bind_info->last_add ) {
add_interface( iface );
}
// only register "leaf" ports (ports without children)
if( m_bind_info->is_leaf ) {
iface->register_port( *this, if_typename() );
}
// complete static sensitivity for methods
size = m_bind_info->method_vec.size();
for( int k = 0; k < size; ++ k ) {
sc_bind_ef* p = m_bind_info->method_vec[k];
const sc_event& event = ( p->event_finder != 0 )
? p->event_finder->find_event(iface)
: iface->default_event();
p->handle->add_static_event( event );
}
// complete static sensitivity for threads
size = m_bind_info->thread_vec.size();
for( int k = 0; k < size; ++ k ) {
sc_bind_ef* p = m_bind_info->thread_vec[k];
const sc_event& event = ( p->event_finder != 0 )
? p->event_finder->find_event(iface)
: iface->default_event();
p->handle->add_static_event( event );
}
}
// MAKE SURE THE PROPER NUMBER OF BINDINGS OCCURRED:
//
// Make sure there are enough bindings, and not too many.
int actual_binds = interface_count();
if ( actual_binds > m_bind_info->max_size() )
{
sprintf(msg_buffer, "%d binds exceeds maximum of %d allowed",
actual_binds, m_bind_info->max_size() );
report_error( SC_ID_COMPLETE_BINDING_, msg_buffer );
}
switch ( m_bind_info->policy() )
{
case SC_ONE_OR_MORE_BOUND:
if ( actual_binds < 1 ) {
report_error( SC_ID_COMPLETE_BINDING_, "port not bound" );
}
break;
case SC_ALL_BOUND:
if ( actual_binds < m_bind_info->max_size() || actual_binds < 1 ) {
sprintf(msg_buffer, "%d actual binds is less than required %d",
actual_binds, m_bind_info->max_size() );
report_error( SC_ID_COMPLETE_BINDING_, msg_buffer );
}
break;
default: // SC_ZERO_OR_MORE_BOUND:
break;
}
// CLEAN UP: FREE BINDING STORAGE:
size = m_bind_info->method_vec.size();
for( int k = 0; k < size; ++ k ) {
delete m_bind_info->method_vec[k];
}
m_bind_info->method_vec.resize(0);
size = m_bind_info->thread_vec.size();
for( int k = 0; k < size; ++ k ) {
delete m_bind_info->thread_vec[k];
}
m_bind_info->thread_vec.resize(0);
m_bind_info->complete = true;
}
void
sc_port_base::construction_done()
{
sc_module* parent = static_cast<sc_module*>( get_parent_object() );
sc_object::hierarchy_scope scope( parent );
before_end_of_elaboration();
}
void
sc_port_base::elaboration_done()
{
assert( m_bind_info != 0 && m_bind_info->complete );
delete m_bind_info;
m_bind_info = 0;
sc_module* parent = static_cast<sc_module*>( get_parent_object() );
sc_object::hierarchy_scope scope( parent );
end_of_elaboration();
}
void
sc_port_base::start_simulation()
{
sc_module* parent = static_cast<sc_module*>( get_parent_object() );
sc_object::hierarchy_scope scope( parent );
start_of_simulation();
}
void
sc_port_base::simulation_done()
{
sc_module* parent = static_cast<sc_module*>( get_parent_object() );
sc_object::hierarchy_scope scope( parent );
end_of_simulation();
}
// ----------------------------------------------------------------------------
// CLASS : sc_port_registry
//
// Registry for all ports.
// FOR INTERNAL USE ONLY!
// ----------------------------------------------------------------------------
void
sc_port_registry::insert( sc_port_base* port_ )
{
if( sc_is_running() ) {
port_->report_error( SC_ID_INSERT_PORT_, "simulation running" );
}
if( m_simc->elaboration_done() ) {
port_->report_error( SC_ID_INSERT_PORT_, "elaboration done" );
}
#if defined(DEBUG_SYSTEMC)
// check if port_ is already inserted
for( int i = size() - 1; i >= 0; -- i ) {
if( port_ == m_port_vec[i] ) {
port_->report_error( SC_ID_INSERT_PORT_, "port already inserted" );
}
}
#endif
// append the port to the current module's vector of ports
sc_module* curr_module = m_simc->hierarchy_curr();
if( curr_module == 0 ) {
port_->report_error( SC_ID_PORT_OUTSIDE_MODULE_ );
}
curr_module->append_port( port_ );
// insert
m_port_vec.push_back( port_ );
}
void
sc_port_registry::remove( sc_port_base* port_ )
{
int i;
for( i = size() - 1; i >= 0; -- i ) {
if( port_ == m_port_vec[i] ) {
break;
}
}
if( i == -1 ) {
port_->report_error( SC_ID_REMOVE_PORT_, "port not registered" );
}
// remove
m_port_vec[i] = m_port_vec[size() - 1];
m_port_vec.resize(size()-1);
}
// constructor
sc_port_registry::sc_port_registry( sc_simcontext& simc_ )
: m_construction_done(0),
m_port_vec(),
m_simc( &simc_ )
{
}
// destructor
sc_port_registry::~sc_port_registry()
{
}
// called when construction is done
bool
sc_port_registry::construction_done()
{
if( size() == m_construction_done )
// nothing has been updated
return true;
for( int i = size()-1; i >= m_construction_done; --i ) {
m_port_vec[i]->construction_done();
}
m_construction_done = size();
return false;
}
// called when when elaboration is done
void
sc_port_registry::complete_binding()
{
for( int i = size() - 1; i >= 0; -- i ) {
m_port_vec[i]->complete_binding();
}
}
// called when elaboration is done
void
sc_port_registry::elaboration_done()
{
complete_binding();
for( int i = size() - 1; i >= 0; -- i ) {
m_port_vec[i]->elaboration_done();
}
}
// called before simulation begins
void
sc_port_registry::start_simulation()
{
for( int i = size() - 1; i >= 0; -- i ) {
m_port_vec[i]->start_simulation();
}
}
// called after simulation ends
void
sc_port_registry::simulation_done()
{
for( int i = size() - 1; i >= 0; -- i ) {
m_port_vec[i]->simulation_done();
}
}
// This is a static member function.
void
sc_port_registry::replace_port( sc_port_registry* /* registry */ )
{
}
void sc_warn_port_constructor()
{
static bool warn_port_constructor=true;
if ( warn_port_constructor )
{
warn_port_constructor = false;
SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
"interface and/or port binding in port constructors is deprecated"
);
}
}
} // namespace sc_core
/*****************************************************************************
MODIFICATION LOG - modifiers, enter your name, affiliation, date and
changes you are making here.
Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
Bishnupriya Bhattacharya, Cadence Design Systems,
25 August, 2003
Description of Modification: phase callbacks
Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
12 December, 2005
Description of Modification: multiport binding policy changes
*****************************************************************************/
// $Log: sc_port.cpp,v $
// Revision 1.8 2011/08/24 22:05:36 acg
// Torsten Maehne: initialization changes to remove warnings.
//
// Revision 1.7 2011/08/15 16:43:24 acg
// Torsten Maehne: changes to remove unused argument warnings.
//
// Revision 1.6 2011/08/07 19:08:01 acg
// Andy Goodrich: moved logs to end of file so line number synching works
// better between versions.
//
// Revision 1.5 2011/08/07 18:53:09 acg
// Philipp A. Hartmann: add virtual instances of the bind function for
// base classes to eliminate warning messages for clang platforms.
//
// Revision 1.4 2011/05/09 04:07:37 acg
// Philipp A. Hartmann:
// (1) Restore hierarchy in all phase callbacks.
// (2) Ensure calls to before_end_of_elaboration.
//
// Revision 1.3 2011/02/18 20:23:45 acg
// Andy Goodrich: Copyright update.
//
// Revision 1.2 2011/02/14 17:50:16 acg
// Andy Goodrich: testing for sc_port and sc_export instantiations during
// end of elaboration and issuing appropriate error messages.
//
// Revision 1.1.1.1 2006/12/15 20:20:04 acg
// SystemC 2.3
//
// Revision 1.11 2006/08/29 23:34:59 acg
// Andy Goodrich: added bind_count() method to allow users to determine which
// ports are connected in before_end_of_elaboration().
//
// Revision 1.10 2006/05/08 17:52:47 acg
// Andy Goodrich:
// (1) added David Long's forward declarations for friend functions,
// methods, and operators to keep the Microsoft compiler happy.
// (2) Added delta_count() method to sc_prim_channel for use by
// sc_signal so that the friend declaration in sc_simcontext.h
// can be for a non-templated class (i.e., sc_prim_channel.)
//
// Revision 1.9 2006/02/02 20:43:09 acg
// Andy Goodrich: Added an existence linked list to sc_event_finder so that
// the dynamically allocated instances can be freed after port binding
// completes. This replaces the individual deletions in ~sc_bind_ef, as these
// caused an exception if an sc_event_finder instance was used more than
// once, due to a double freeing of the instance.
//
// Revision 1.7 2006/01/26 21:00:50 acg
// Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
// sc_event::notify_delayed()
//
// Revision 1.6 2006/01/25 00:31:11 acg
// Andy Goodrich: Changed over to use a standard message id of
// SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
//
// Revision 1.5 2006/01/24 20:46:31 acg
// Andy Goodrich: changes to eliminate use of deprecated features. For instance,
// using notify(SC_ZERO_TIME) in place of notify_delayed().
//
// Revision 1.4 2006/01/13 20:41:59 acg
// Andy Goodrich: Changes to add port registration to the things that are
// checked when SC_NO_WRITE_CHECK is not defined.
//
// Revision 1.3 2006/01/13 18:47:42 acg
// Added $Log command so that CVS comments are reproduced in the source.
//
// Taf!