derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fc80e7b8ecd3d3b2ead81a8bdbef247cfb18b3a6
gem5/src/mem/tlm2_base_protocol_checker.h
Derek Christ fc80e7b8ec First PIM modifications
2023-11-09 15:46:02 +01:00

1049 lines
38 KiB
C++
Raw Blame History

// Filename: tlm2_base_protocol_checker.h
//----------------------------------------------------------------------
// Copyright (c) 2008-2013 by Doulos Ltd.
//
// Licensed 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.
//----------------------------------------------------------------------
// Author: John Aynsley, Doulos
// Version 1, 11 July 2008
// Version 2, 16 July 2008 Only generate ref_count > 1 warning from 1st checker of path
// Version 3, 17 July 2008 Support compilation under SystemC 2.1.v1
// Version 4, 12 Aug 2008 Add header #include <map>
// Version 5, 08 Sep 2008 Fix bugs in message text
// Version 6, 01 Aug 2010 Update messages to refer to OSCI TLM-2.0 LRM of July 2009
// Version 7, 25 Oct 2011 Minor bug fix for certain compilers: replace u_char with uchar_t
// Version 8, 02 Nov 2011 Support the endianness conversion functions by excluding the
// tlm_endian_context extension from the protocol checks
// Version 9, 17 Aug 2012 Fix LRM reference on line 805 (should be 8.2.11 a) [NOT YET RELEASED]
// Version 10, 3 Jan 2013 Updated messages to refer to IEEE Std 1666-2011, the combined SystemC + TLM-2.0 LRM
// Added checks related to the generic payload option attribute
// Version 11, 14 Mar 2016 Fix minor bug - start_phase should be a copy, not a reference
// TLM-2.0 Base Protocol Compliance Checker
/*
Instantiate this checker module in-line between initiator and target, initiator and interconnect,
or interconnect and target by binding the target_socket and initiator_socket
Binding two checkers either side of an interconnect component, or interleaving a series of
checkers with interconnect components, will enable some deeper checks as against having just
a single checker
For example
Initiator *initiator;
Bus *bus;
Memory *memory;
...
initiator->socket.bind(bus->target_socket);
bus->initiator_socket.bind(memory->socket);
might become
tlm_utils::tlm2_base_protocol_checker<32> *checker1;
tlm_utils::tlm2_base_protocol_checker<32> *checker2;
...
initiator->socket.bind(checker1->target_socket);
checker1->initiator_socket.bind(bus->target_socket);
bus->initiator_socket.bind(checker2->target_socket);
checker2->initiator_socket.bind(memory->socket);
GENERAL FEATURES OF THE BASE PROTOCOL CHECKER
The checks are relatively expensive, hence by default the number of checks is limited.
A maximum number can be set explicitly by calling set_num_checks(max)
Checking can be deactivated at any time by calling set_num_checks(0)
All checkers decrement a single global count, because having some checkers running and
others not can cause bogus violation reports
It is not permitted to turn checks on by calling set_num_checks() once checking has been
deactivated, because this could cause bogus violation reports
The DMI and debug checks are unaffected by the num_checks count (because they are cheap)
The error messages contain User Manual references
The checker is designed to be used with a transaction pool: otherwise it could consume
a lot of memory. The checker keeps a local copy of each transaction object
Failures are reported with a severity of SC_ERROR. The actions may be overridden by calling:
sc_report_handler::set_actions("tlm2_protocol_checker", ...);
SPECIFIC CHECKS
nb_transport: phase sequence BEGIN_REQ -> END_REQ -> BEGIN_RESP -> END_RESP
Must not have two outstanding requests or responses (exclusion rules)
Must not have decreasing timing annotations on calls to or returns from nb_transport_fw/bw
Phase extensions permitted and ignored
Must not call b_transport during nb_transport phase sequence and vice-versa
nb_transport: memory manager must be set
nb_transport: reference count must be non-zero
First checker in BEGIN_REQ path should see ref_count == 1 (warning only)
An interconnect component that sets a memory manager should also clear it
An interconnect component that sets extensions with no memory manager should also clear them
(Does not bother with these memory manager checks for DMI and debug)
Transaction object must be properly initialized
Many generic payload attributes must not be modified during the transaction lifetime
Transaction object must not be re-allocated for a new transaction while still in use
DMI descriptor must be properly initialized
Debug transaction must be properly initialized
Debug byte count must be less than data_length
Checks that require multiple checkers to be instantiated along a transaction path:
The BEGIN_RESP path must be the reverse of the BEGIN_REQ path
Transaction object must not be sent with BEGIN_REQ while participating in a previous response
Interconnect component must not set response status attribute to TLM_OK_RESPONSE
Interconnect component must not modify data array on the response path
Generic payload option attribute (IEEE Std 1666-2011, SystemC 2.3.x)
gp_option must be properly initialized and only used for DMI and debug transport
When gp_option is used, other gp attributes must be initalized and used as per the transport interfaces
*/
// ******************** PREAMBLE ********************
#ifndef __tlm2_base_protocol_checker__
#define __tlm2_base_protocol_checker__
#include "systemc"
using std::cout;
using std::endl;
using std::dec;
using std::hex;
#include "tlm.h"
#include <sstream>
#include <map>
namespace tlm_utils {
// Number of checks remaining
const sc_dt::uint64 default_num_checks = 100000;
static sc_dt::uint64 num_checks = default_num_checks;
// Types used when building a trace of the transaction path
typedef unsigned char uchar_t;
typedef std::deque<sc_core::sc_module *> deque_t;
struct path_t {
path_t ()
{
response_in_progress = false;
ok_response = false;
resp_data_ptr = 0;
}
bool response_in_progress;
bool ok_response;
deque_t path;
uchar_t *resp_data_ptr; // Copy of data on response path
};
// Global variable used for checks involving multiple checkers along a transaction path
static std::map<tlm::tlm_generic_payload *, path_t> shared_map;
// ******************** CLASS DEFINITION ********************
template <unsigned int BUSWIDTH = 32>
class tlm2_base_protocol_checker
: public sc_core::sc_module
, public tlm::tlm_fw_transport_if<tlm::tlm_base_protocol_types>
, public tlm::tlm_bw_transport_if<tlm::tlm_base_protocol_types>
{
public:
// Instantiate and bind checker inline between an existing pair of initiator and target sockets
tlm::tlm_target_socket <BUSWIDTH, tlm::tlm_base_protocol_types, 1>
target_socket;
tlm::tlm_initiator_socket<BUSWIDTH, tlm::tlm_base_protocol_types, 1>
initiator_socket;
SC_CTOR(tlm2_base_protocol_checker)
: m_request_in_progress(0), m_response_in_progress(0)
{
target_socket .bind( *this );
initiator_socket.bind( *this );
}
// Access methods for num_checks count
static void set_num_checks(sc_dt::uint64 n)
{
if (num_checks == 0)
SC_REPORT_FATAL("tlm2_protocol_checker",
"Method set_num_checks called after checking has stopped due to maximum number of checks being reached");
num_checks = n;
}
static sc_dt::uint64 get_num_checks()
{
return num_checks;
}
// TLM-2.0 interface methods for initiator and target sockets, instrumented with checks
virtual tlm::tlm_sync_enum nb_transport_fw(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay)
{
tlm::tlm_phase start_phase = phase;
if (num_checks)
nb_transport_fw_pre_checks( trans, phase, delay );
tlm::tlm_sync_enum status;
status = initiator_socket->nb_transport_fw( trans, phase, delay );
if (num_checks)
nb_transport_fw_post_checks( trans, start_phase, phase, delay, status );
return status;
}
virtual tlm::tlm_sync_enum nb_transport_bw(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay)
{
if (num_checks)
nb_transport_bw_pre_checks( trans, phase, delay );
tlm::tlm_sync_enum status;
status = target_socket->nb_transport_bw( trans, phase, delay );
if (num_checks)
nb_transport_bw_post_checks( trans, phase, delay, status );
return status;
}
virtual void b_transport( tlm::tlm_generic_payload &trans,
sc_core::sc_time &delay )
{
if (num_checks)
b_transport_pre_checks( trans, delay );
initiator_socket->b_transport( trans, delay );
if (num_checks)
b_transport_post_checks( trans, delay );
}
virtual bool get_direct_mem_ptr(tlm::tlm_generic_payload &trans,
tlm::tlm_dmi &dmi_data)
{
get_direct_mem_ptr_pre_checks( trans, dmi_data );
bool status;
status = initiator_socket->get_direct_mem_ptr( trans, dmi_data );
get_direct_mem_ptr_post_checks( trans, dmi_data );
return status;
}
virtual void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
sc_dt::uint64 end_range)
{
target_socket->invalidate_direct_mem_ptr(start_range, end_range);
}
virtual unsigned int transport_dbg(tlm::tlm_generic_payload &trans)
{
transport_dbg_pre_checks( trans );
unsigned int count;
count = initiator_socket->transport_dbg( trans );
transport_dbg_post_checks( trans, count );
return count;
}
private:
void b_transport_pre_checks( tlm::tlm_generic_payload &trans,
sc_core::sc_time &delay);
void b_transport_post_checks( tlm::tlm_generic_payload &trans,
sc_core::sc_time &delay);
void nb_transport_fw_pre_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase,
sc_core::sc_time &delay);
void nb_transport_fw_post_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &start_phase,
tlm::tlm_phase &phase,
sc_core::sc_time &delay, tlm::tlm_sync_enum status);
void nb_transport_bw_pre_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase,
sc_core::sc_time &delay);
void nb_transport_bw_post_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay,
tlm::tlm_sync_enum status);
void nb_transport_response_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay,
const char *txt2, const char *txt3, const char *txt4);
void check_initial_state( tlm::tlm_generic_payload &trans,
const char *txt2 );
void check_trans_not_modified( tlm::tlm_generic_payload &trans,
const char *txt2 );
void check_response_path( tlm::tlm_generic_payload &trans,
const char *txt2 );
void remember_gp_option( tlm::tlm_generic_payload &trans );
void get_direct_mem_ptr_pre_checks( tlm::tlm_generic_payload &trans,
tlm::tlm_dmi &dmi_data );
void get_direct_mem_ptr_post_checks( tlm::tlm_generic_payload &trans,
tlm::tlm_dmi &dmi_data );
void transport_dbg_pre_checks( tlm::tlm_generic_payload &trans );
void transport_dbg_post_checks( tlm::tlm_generic_payload &trans,
unsigned int count );
void tlm2error( tlm::tlm_generic_payload &trans, const char *ref,
bool warning = false );
private:
struct state_t {
state_t()
{
b_call = 0;
ph = tlm::UNINITIALIZED_PHASE;
gp = 0;
}
bool has_mm;
unsigned int b_call; // Number of b_transport calls in progress
tlm::tlm_phase ph;
sc_core::sc_time time; // Current time + annotated delay
tlm::tlm_generic_payload
*gp; // Points to new data and byte enable buffers
uchar_t *data_ptr; // Stores original pointers
uchar_t *byte_enable_ptr;
};
// Transaction state for the specific hop where this checker is inlined
std::map<tlm::tlm_generic_payload *, state_t> m_map;
// Flags for exclusion rules
tlm::tlm_generic_payload *m_request_in_progress;
tlm::tlm_generic_payload *m_response_in_progress;
std::ostringstream txt;
};
// ******************** MEMBER FUNCTION DEFINITIONS ********************
#define BOILERPLATE \
template <unsigned int BUSWIDTH> \
void tlm2_base_protocol_checker<BUSWIDTH>::
BOILERPLATE
b_transport_pre_checks(
tlm::tlm_generic_payload &trans, sc_core::sc_time & /*delay*/)
{
++ m_map[&trans].b_call;
if ( trans.has_mm() && trans.get_ref_count() == 0) {
txt << "Transaction passed to b_transport with memory manager and reference count of 0";
tlm2error(trans, "14.5 t)");
}
check_initial_state(trans, "b_transport");
#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
if (sc_core::sc_get_current_process_handle().proc_kind() ==
sc_core::SC_METHOD_PROC_) {
txt << "b_transport called from method process";
tlm2error(trans, "11.1.1.4 b)");
}
#endif
if (m_map[&trans].ph > 0 && m_map[&trans].ph < 4) {
txt << "b_transport called during a sequence of nb_transport calls";
tlm2error(trans, "15.2.10 c)");
}
}
BOILERPLATE
b_transport_post_checks(
tlm::tlm_generic_payload &trans, sc_core::sc_time & /*delay*/)
{
check_response_path(trans, "b_transport");
check_trans_not_modified(trans, "b_transport");
-- m_map[&trans].b_call;
}
BOILERPLATE
nb_transport_fw_pre_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay)
{
if ( !trans.has_mm() ) {
txt << "Transaction passed to nb_transport_fw with no memory manager set";
tlm2error(trans, "14.5 i)");
}
if ( trans.get_ref_count() == 0) {
txt << "Transaction passed to nb_transport_fw with reference count of 0";
tlm2error(trans, "14.5 t)");
}
switch (phase) {
case tlm::BEGIN_REQ:
check_initial_state(trans, "nb_transport_fw");
if (m_map[&trans].ph > 0
&& m_map[&trans].ph < 4) { // END_RESP -> BEGIN_REQ is legal
txt << "Phase " << phase <<
" sent out-of-sequence on forward path, detected in nb_transport_fw";
tlm2error(trans, "15.2.4");
}
if (m_request_in_progress) {
txt << "Transaction violates BEGIN_REQ exclusion rule, detected in nb_transport_fw";
tlm2error(trans, "15.2.6 e)");
}
m_request_in_progress = &trans;
if (m_map[&trans].b_call) {
txt << "nb_transport_fw called during a b_transport call";
tlm2error(trans, "15.2.10 c)");
}
break;
case tlm::END_REQ:
case tlm::BEGIN_RESP:
case tlm::UNINITIALIZED_PHASE:
txt << "Phase " << phase <<
" sent on forward path, detected in nb_transport_fw";
tlm2error(trans, " 15.2.3 c)");
break;
case tlm::END_RESP:
if (m_map[&trans].ph != tlm::BEGIN_RESP) {
txt << "Phase " << phase <<
" sent out-of-sequence on forward path, detected in nb_transport_fw";
tlm2error(trans, "15.2.4");
}
m_response_in_progress = 0;
break;
}
if (phase < 5) // Ignore extended phases
m_map[&trans].ph = phase;
if (sc_core::sc_time_stamp() + delay < m_map[&trans].time) {
txt << "nb_transport_fw called with decreasing timing annotation:"
<< " delay = " << delay
<< ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
tlm2error(trans, "15.2.7 c)");
}
m_map[&trans].time = sc_core::sc_time_stamp() + delay;
}
BOILERPLATE
nb_transport_fw_post_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &start_phase,
tlm::tlm_phase &phase,
sc_core::sc_time &delay, tlm::tlm_sync_enum status)
{
if (status == tlm::TLM_UPDATED) {
nb_transport_response_checks(
trans, phase, delay, "(forward) return", "Return from nb_transport_fw",
"nb_transport_fw");
} else if (status == tlm::TLM_COMPLETED) {
if (start_phase == tlm::BEGIN_REQ)
check_response_path(trans, "nb_transport_fw");
m_request_in_progress = 0;
m_map[&trans].ph = tlm::UNINITIALIZED_PHASE;
}
// Transaction object should not be re-allocated, even during the END_RESP phase
//if (phase != tlm::END_RESP)
{
std::ostringstream txt;
txt << "nb_transport_fw, phase = " << phase;
check_trans_not_modified(trans, txt.str().c_str());
}
}
BOILERPLATE
nb_transport_bw_pre_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay)
{
if ( !trans.has_mm() ) {
txt << "Transaction passed to nb_transport_bw with no memory manager set";
tlm2error(trans, "14.5 i)");
}
if ( trans.get_ref_count() == 0) {
txt << "Transaction passed to nb_transport_bw with reference count of 0";
tlm2error(trans, "14.5 t)");
}
nb_transport_response_checks(
trans, phase, delay, "backward", "nb_transport_bw called", "nb_transport_bw");
}
BOILERPLATE
nb_transport_bw_post_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay,
tlm::tlm_sync_enum status)
{
if (status == tlm::TLM_UPDATED) {
switch (phase) {
case tlm::BEGIN_REQ:
txt << "Phase " << phase <<
" sent out-of-sequence on (backward) return path, detected in nb_transport_bw";
tlm2error(trans, "15.2.4");
break;
case tlm::END_REQ:
case tlm::BEGIN_RESP:
case tlm::UNINITIALIZED_PHASE:
txt << "Phase " << phase <<
" sent on (backward) return path, detected in nb_transport_bw";
tlm2error(trans, "15.2.3 c)");
break;
case tlm::END_RESP:
if (m_map[&trans].ph != tlm::BEGIN_RESP) {
txt << "Phase " << phase <<
" sent out-of-sequence on (backward) return path, detected in nb_transport_bw";
tlm2error(trans, "15.2.4");
}
m_response_in_progress = 0;
break;
}
if (phase < 5) // Ignore extended phases
m_map[&trans].ph = phase;
if (sc_core::sc_time_stamp() + delay < m_map[&trans].time) {
txt << "Return from nb_transport_bw with decreasing timing annotation:"
<< " delay = " << delay
<< ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
tlm2error(trans, "15.2.7 c)");
}
m_map[&trans].time = sc_core::sc_time_stamp() + delay;
} else if (status == tlm::TLM_COMPLETED) {
m_response_in_progress = 0;
m_map[&trans].ph = tlm::UNINITIALIZED_PHASE;
}
// Transaction object should not be re-allocated, even during the END_RESP phase
//if (phase != tlm::END_RESP)
{
std::ostringstream txt;
txt << "nb_transport_bw, phase = " << phase;
check_trans_not_modified(trans, txt.str().c_str());
}
}
BOILERPLATE
nb_transport_response_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_phase &phase, sc_core::sc_time &delay,
const char *txt2, const char *txt3, const char *txt4)
{
if (trans.is_response_ok())
if (shared_map[&trans].response_in_progress
&& !shared_map[&trans].ok_response) {
txt << "Interconnect component sets response status attribute to TLM_OK_RESPONSE"
<< ", detected in " << txt4;
tlm2error(trans, "14.7");
}
switch (phase) {
case tlm::BEGIN_REQ:
case tlm::END_RESP:
case tlm::UNINITIALIZED_PHASE:
txt << "Phase " << phase << " sent on " << txt2 << " path"
<< ", detected in " << txt4;
tlm2error(trans, "15.2.3 c)");
break;
case tlm::END_REQ:
if (m_map[&trans].ph != tlm::BEGIN_REQ) {
txt << "Phase " << phase << " sent out-of-sequence on " << txt2 << " path"
<< ", detected in " << txt4;
tlm2error(trans, "15.2.4");
}
m_request_in_progress = 0;
break;
case tlm::BEGIN_RESP:
if (m_map[&trans].ph != tlm::BEGIN_REQ && m_map[&trans].ph != tlm::END_REQ) {
txt << "Phase " << phase << " sent out-of-sequence on " << txt2 << " path"
<< ", detected in " << txt4;
tlm2error(trans, "15.2.4");
}
if (&trans == m_request_in_progress)
m_request_in_progress = 0;
if (m_response_in_progress) {
txt << "Transaction violates BEGIN_RESP exclusion rule"
<< ", detected in " << txt4;
tlm2error(trans, "15.2.6 f)");
}
m_response_in_progress = &trans;
check_response_path(trans, txt4);
break;
}
if (phase < 5) // Ignore extended phases
m_map[&trans].ph = phase;
if (sc_core::sc_time_stamp() + delay < m_map[&trans].time) {
txt << txt3 << " with decreasing timing annotation:"
<< " delay = " << delay
<< ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
tlm2error(trans, "15.2.7 c)");
}
m_map[&trans].time = sc_core::sc_time_stamp() + delay;
}
BOILERPLATE
check_initial_state(
tlm::tlm_generic_payload &trans, const char *txt2 )
{
if (num_checks > 0) {
--num_checks;
if (num_checks == 0)
SC_REPORT_INFO("tlm2_protocol_checker",
"Checkers deactivated after executing the set number of checks");
}
if ( trans.has_mm() && trans.get_ref_count() > 1
&& shared_map[&trans].path.empty() ) {
txt << "New transaction passed to " << txt2 << " with reference count = "
<< trans.get_ref_count();
tlm2error(trans, "14.5 t)", true);
}
if (trans.get_data_ptr() == 0
&& trans.get_command() != tlm::TLM_IGNORE_COMMAND) {
txt << "Transaction not properly initialized: data_ptr == 0, detected in " <<
txt2;
tlm2error(trans, "14.11 e)");
}
if (trans.get_data_length() == 0
&& trans.get_command() != tlm::TLM_IGNORE_COMMAND) {
txt << "Transaction not properly initialized: data_langth == 0, detected in " <<
txt2;
tlm2error(trans, "14.12 d)");
}
if (trans.get_byte_enable_ptr() != 0 && trans.get_byte_enable_length() == 0) {
txt << "Transaction not properly initialized: "
<< "byte_enable_ptr != 0 and byte_enable_length == 0, detected in " << txt2;
tlm2error(trans, "14.14 f)");
}
if (trans.get_streaming_width() == 0) {
txt << "Transaction not properly initialized: streaming_width == 0, detected in "
<< txt2;
tlm2error(trans, "14.15 f)");
}
if (trans.is_dmi_allowed()) {
txt << "Transaction not properly initialized: dmi_allowed == true, detected in "
<< txt2;
tlm2error(trans, "14.16");
}
if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE) {
txt << "Transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE, detected in "
<< txt2;
tlm2error(trans, "14.17 e)");
}
if (trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD) {
txt << "Transaction not properly initialized: gp_option != TLM_MIN_PAYLOAD, detected in "
<< txt2;
tlm2error(trans, "14.8 g)");
}
// Setup clones of transaction and buffers in map
tlm::tlm_generic_payload *gp = m_map[&trans].gp;
if (gp == 0)
gp = new tlm::tlm_generic_payload; // Memory leak: transactions are never cleared from map
else {
delete [] gp->get_data_ptr();
gp->free_all_extensions();
}
gp->set_data_ptr( new uchar_t[trans.get_data_length()] );
m_map[&trans].data_ptr = trans.get_data_ptr();
if (gp->get_byte_enable_ptr())
delete [] gp->get_byte_enable_ptr();
if (trans.get_byte_enable_ptr())
gp->set_byte_enable_ptr( new uchar_t[trans.get_byte_enable_length()] );
else
gp->set_byte_enable_ptr(0);
m_map[&trans].byte_enable_ptr = trans.get_byte_enable_ptr();
gp->deep_copy_from(trans);
m_map[&trans].gp = gp;
m_map[&trans].time = sc_core::SC_ZERO_TIME;
m_map[&trans].has_mm = trans.has_mm();
// Store request path checker sequence
if (shared_map[&trans].resp_data_ptr) {
delete [] shared_map[&trans].resp_data_ptr;
shared_map[&trans].resp_data_ptr = 0;
}
if (shared_map[&trans].response_in_progress) {
txt << "Transaction object sent with BEGIN_REQ while still being used on a previous response path, detected in "
<< txt2;
tlm2error(trans, "14.5 x)");
}
shared_map[&trans].ok_response = false;
shared_map[&trans].path.push_back(this);
}
BOILERPLATE
remember_gp_option(
tlm::tlm_generic_payload &trans)
{
// Setup clone of transaction in map in order to check gp_option only
tlm::tlm_generic_payload *gp = m_map[&trans].gp;
if (gp == 0)
gp = new tlm::tlm_generic_payload; // Memory leak: transactions are never cleared from map
gp->set_gp_option( trans.get_gp_option() );
m_map[&trans].gp = gp;
}
BOILERPLATE
check_trans_not_modified(
tlm::tlm_generic_payload &trans, const char *txt2 )
{
tlm::tlm_generic_payload *init = m_map[&trans].gp;
if (trans.get_command() != init->get_command()) {
txt << "Command attribute modified during transaction lifetime, detected in " <<
txt2;
tlm2error(trans, "14.7");
}
if (trans.get_data_ptr() != m_map[&trans].data_ptr) {
txt << "Data pointer attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
if (trans.get_data_length() != init->get_data_length()) {
txt << "Data length attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
if (trans.get_command() == tlm::TLM_WRITE_COMMAND)
for (unsigned int i = 0; i < init->get_data_length(); i++)
if (trans.get_data_ptr()[i] != init->get_data_ptr()[i]) {
txt << "Data array modified during transaction lifetime, detected in " << txt2;
tlm2error(trans, "14.7");
}
if (trans.get_byte_enable_ptr() != m_map[&trans].byte_enable_ptr) {
txt << "Byte enable pointer attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
if (trans.get_byte_enable_length() != init->get_byte_enable_length()) {
txt << "Byte enable length attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
if (trans.get_byte_enable_ptr())
for (unsigned int i = 0; i < init->get_byte_enable_length(); i++)
if (trans.get_byte_enable_ptr()[i] != init->get_byte_enable_ptr()[i]) {
txt << "Byte enable array modified during transaction lifetime, detected in " <<
txt2;
tlm2error(trans, "14.7");
}
if (trans.get_streaming_width() != init->get_streaming_width()) {
txt << "Streaming width attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD
&& trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD) {
txt << "Generic payload option attribute modified during transaction lifetime, detected in "
<< txt2;
tlm2error(trans, "14.8 g)");
}
if ( !m_map[&trans].has_mm ) {
if (trans.has_mm()) {
txt << "Interconnect component sets a memory manager, but does not clear it on return, detected in "
<< txt2;
tlm2error(trans, "14.5 aa)");
}
for (unsigned int i = 0; i < tlm::max_num_extensions(); i++)
// Exclude tlm_endian_context extension from the check because it is not cloned in m_map
if (i != tlm::tlm_endian_context::ID)
if (trans.get_extension(i))
if ( !m_map[&trans].gp->get_extension(i) ) {
txt << "Extension set (index = " << i <<
") without also being deleted in the absence of a memory manager, detected in "
<< txt2;
tlm2error(trans, "14.5 aa)");
}
}
uchar_t *resp_data_ptr = shared_map[&trans].resp_data_ptr;
if (resp_data_ptr)
for (unsigned int i = 0; i < trans.get_data_length(); i++)
if (trans.get_data_ptr()[i] != resp_data_ptr[i]) {
txt << "Transaction data array modified in interconnect component on response path, detected in "
<< txt2;
tlm2error(trans, "14.7");
}
}
BOILERPLATE
check_response_path(
tlm::tlm_generic_payload &trans, const char *txt2 )
{
if ( !shared_map[&trans].path.empty() ) {
if ( this != shared_map[&trans].path.back() ) {
txt << "BEGIN_RESP path is not the reverse of the BEGIN_REQ path.";
txt << "\nBEGIN_REQ path includes these checkers: -> ";
deque_t path = shared_map[&trans].path;
for (deque_t::iterator i = path.begin(); i < path.end(); i++)
txt << (*i)->name() << " -> ";
txt << "\nDetected in " << txt2;
tlm2error(trans, "15.2.11 a)");
}
shared_map[&trans].path.pop_back();
shared_map[&trans].response_in_progress = !shared_map[&trans].path.empty();
shared_map[&trans].ok_response = trans.is_response_ok();
// Create a copy of the data array for comparison on the response path
if ( !shared_map[&trans].resp_data_ptr ) {
shared_map[&trans].resp_data_ptr = new uchar_t[trans.get_data_length()];
memcpy(shared_map[&trans].resp_data_ptr, trans.get_data_ptr(),
trans.get_data_length());
}
}
}
BOILERPLATE
get_direct_mem_ptr_pre_checks(
tlm::tlm_generic_payload &trans, tlm::tlm_dmi &dmi_data )
{
remember_gp_option(trans);
if (dmi_data.get_dmi_ptr() != 0) {
txt << "DMI descriptor not properly initialized: dmi_ptr != 0";
tlm2error(trans, "11.2.5 f)");
}
if (!dmi_data.is_none_allowed()) {
txt << "DMI descriptor not properly initialized: granted_access != DMI_ACCESS_NONE";
tlm2error(trans, "11.2.5 a)");
}
if (dmi_data.get_start_address() != 0) {
txt << "DMI descriptor not properly initialized: start_address != 0";
tlm2error(trans, "11.2.5 u)");
}
if (dmi_data.get_end_address() != (sc_dt::uint64)(-1)) {
txt << "DMI descriptor not properly initialized: end_address != 0";
tlm2error(trans, "11.2.5 u)");
}
if (dmi_data.get_read_latency() != sc_core::SC_ZERO_TIME) {
txt << "DMI descriptor not properly initialized: read_latency != SC_ZERO_TIME";
tlm2error(trans, "11.2.5 ac)");
}
if (dmi_data.get_write_latency() != sc_core::SC_ZERO_TIME) {
txt << "DMI descriptor not properly initialized: write_latency != SC_ZERO_TIME";
tlm2error(trans, "11.2.5 ac)");
}
if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD) {
/*
if (trans.is_dmi_allowed()) // Would be rather brutal to flag dmi_allowed as an arror for a DMI transaction!
{
txt << "DMI transaction not properly initialized: dmi_allowed == true";
tlm2error(trans, "14.8 e) & 14.16");
}
*/
if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE) {
txt << "DMI transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE";
tlm2error(trans, "14.8 e) & 14.17 e)");
}
} else if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD_ACCEPTED) {
txt << "DMI transaction not properly initialized: gp_option == TLM_FULL_PAYLOAD_ACCEPTED";
tlm2error(trans, "14.8 c) & e) & j)");
}
}
BOILERPLATE
get_direct_mem_ptr_post_checks( tlm::tlm_generic_payload &trans,
tlm::tlm_dmi & /*dmi_data*/ )
{
tlm::tlm_generic_payload *init = m_map[&trans].gp;
if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD
&& trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD) {
txt << "DMI transaction gp_option attribute value TLM_MIN_PAYLOAD modified during transaction lifetime";
tlm2error(trans, "14.8 h)");
} else if (init->get_gp_option() == tlm::TLM_FULL_PAYLOAD
&& trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD) {
txt << "DMI transaction gp_option attribute value changed from TLM_FULL_PAYLOAD to TLM_MIN_PAYLOAD";
tlm2error(trans, "14.8 j)");
}
}
BOILERPLATE
transport_dbg_pre_checks( tlm::tlm_generic_payload &trans )
{
remember_gp_option(trans);
if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0) {
txt << "Debug transaction has data_ptr == 0";
tlm2error(trans, "11.3.4 l)");
}
if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD) {
if (trans.get_byte_enable_ptr() != 0 && trans.get_byte_enable_length() == 0) {
txt << "Debug transaction not properly initialized: "
<< "byte_enable_ptr != 0 and byte_enable_length == 0";
tlm2error(trans, "14.8 f) & 14.14 f)");
}
if (trans.get_streaming_width() == 0) {
txt << "Debug transaction not properly initialized: streaming_width == 0";
tlm2error(trans, "14.8 f) & 14.15 f)");
}
if (trans.is_dmi_allowed()) {
txt << "Debug transaction not properly initialized: dmi_allowed == true";
tlm2error(trans, "14.8 f) & 14.16");
}
if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE) {
txt << "Debug transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE";
tlm2error(trans, "14.8 f) & 14.17 e)");
}
} else if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD_ACCEPTED) {
txt << "Debug transaction not properly initialized: gp_option == TLM_FULL_PAYLOAD_ACCEPTED";
tlm2error(trans, "14.8 c) & f) & l)");
}
}
BOILERPLATE
transport_dbg_post_checks( tlm::tlm_generic_payload &trans, unsigned int count )
{
tlm::tlm_generic_payload *init = m_map[&trans].gp;
if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0) {
txt << "Debug transaction has data_ptr == 0";
tlm2error(trans, "11.3.4 l)");
}
if (count > trans.get_data_length()) {
txt << "Count returned from transport_dbg is greater than data_length";
tlm2error(trans, "11.3.4 s)");
}
if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD
&& trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD) {
txt << "Debug transaction gp_option attribute value TLM_MIN_PAYLOAD modified during transaction lifetime";
tlm2error(trans, "14.8 h)");
} else if (init->get_gp_option() == tlm::TLM_FULL_PAYLOAD
&& trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD) {
txt << "Debug transaction gp_option attribute value changed from TLM_FULL_PAYLOAD to TLM_MIN_PAYLOAD";
tlm2error(trans, "14.8 l)");
}
}
BOILERPLATE
tlm2error( tlm::tlm_generic_payload &trans, const char *ref, bool warning )
{
txt << "\n\nRefer to IEEE Std 1666-2011, clause " << ref;
txt << "\n\nChecker instance: " << this->name();
txt << "\n\nTransaction details:";
txt << "\n has_mm = " << dec << trans.has_mm() << " (bool)";
txt << "\n ref_count = " << dec << trans.get_ref_count() << " (int)";
txt << "\n\n gp_option = " <<
(trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD ? "TLM_MIN_PAYLOAD"
: trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD ? "TLM_FULL_PAYLOAD"
: "TLM_FULL_PAYLOAD_ACCEPTED");
txt << "\n command = " <<
(trans.get_command() == tlm::TLM_READ_COMMAND ? "TLM_READ_COMMAND"
: trans.get_command() == tlm::TLM_WRITE_COMMAND ? "TLM_WRITE_COMMAND"
: "TLM_IGNORE_COMMAND");
txt << "\n address = " << hex << trans.get_address() << " (hex)";
txt << "\n data_ptr = " << hex
<< reinterpret_cast<int *>(trans.get_data_ptr()) << " (hex)";
txt << "\n data_length = " << hex << trans.get_data_length() <<
" (hex)";
txt << "\n streaming_width = " << hex << trans.get_streaming_width() <<
" (hex)";
txt << "\n byte_enable_ptr = " << hex
<< reinterpret_cast<int *>(trans.get_byte_enable_ptr()) << " (hex)";
txt << "\n byte_enable_length = " << hex << trans.get_byte_enable_length() <<
" (hex)";
txt << "\n dmi_allowed = " << dec << trans.is_dmi_allowed() <<
" (bool)";
txt << "\n response_status = " << trans.get_response_string();
bool extensions_present = false;
for (unsigned int i = 0; i < tlm::max_num_extensions(); i++) {
tlm::tlm_extension_base *ext = trans.get_extension(i);
if (ext) {
if (!extensions_present)
txt << "\n\n extensions:";
txt << "\n index = " << i << " type = " << typeid(*ext).name();
extensions_present = true;
}
}
txt << "\n\n";
if (warning)
SC_REPORT_WARNING("tlm2_protocol_checker", txt.str().c_str());
else
SC_REPORT_ERROR("tlm2_protocol_checker", txt.str().c_str());
}
} // namespace tlm_utils
#endif // __tlm2_base_protocol_checker__
Reference in New Issue View Git Blame Copy Permalink