tlm2_base_protocol_checker.h

这是一个systemc语言的几个实例。都能正常运行。

{
  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, "6.5 s)", true);
  }
  if (trans.get_data_ptr() == 0)
  {
    txt << "Transaction not properly initialized: data_ptr == 0, detected in " << txt2;
    tlm2error(trans, "6.10 e)");
  }
  if (trans.get_data_length() == 0)
  {
    txt << "Transaction not properly initialized: data_langth == 0, detected in " << txt2;
    tlm2error(trans, "6.11 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, "6.13 f)");
  }
  if (trans.get_streaming_width() == 0)
  {
    txt << "Transaction not properly initialized: streaming_width == 0, detected in " << txt2;
    tlm2error(trans, "6.14 f)");
  }
  if (trans.is_dmi_allowed())
  {
    txt << "Transaction not properly initialized: dmi_allowed == true, detected in " << txt2;
    tlm2error(trans, "6.15)");
  }
  if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE)
  {
    txt << "Transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE, detected in " << txt2;
    tlm2error(trans, "6.16 e)");
  }

  // 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, "6.5");
  }
  shared_map[&trans].ok_response = false;
  shared_map[&trans].path.push_back(this);
}


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, "6.7)");
  }
  if (trans.get_data_ptr() != m_map[&trans].data_ptr)
  {
    txt << "Data pointer attribute modified during transaction lifetime, detected in " << txt2;
    tlm2error(trans, "6.7)");
  }
  if (trans.get_data_length() != init->get_data_length())
  {
    txt << "Data length attribute modified during transaction lifetime, detected in " << txt2;
    tlm2error(trans, "6.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, "6.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, "6.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, "6.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, "6.7)");
      }
  if (trans.get_streaming_width() != init->get_streaming_width())
  {
    txt << "Streaming width attribute modified during transaction lifetime, detected in " << txt2;
    tlm2error(trans, "6.7)");
  }
  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, "6.5y)");
    }
    for (unsigned int i = 0; i < tlm::max_num_extensions(); i++)
      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, "6.5 y)");
        }
  }

  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, "6.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, "7.2.5 m-n)");
    }
    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 u_char[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 )
{
  if (dmi_data.get_dmi_ptr() != 0)
  {
    txt << "DMI descriptor not properly initialized: dmi_ptr != 0";
    tlm2error(trans, "4.2.5 f)");
  }
  if (!dmi_data.is_none_allowed())
  {
    txt << "DMI descriptor not properly initialized: granted_access != DMI_ACCESS_NONE";
    tlm2error(trans, "4.2.5 a)");
  }
  if (dmi_data.get_start_address() != 0)
  {
    txt << "DMI descriptor not properly initialized: start_address != 0";
    tlm2error(trans, "4.2.5 s)");
  }
  if (dmi_data.get_end_address() != (sc_dt::uint64)(-1))
  {
    txt << "DMI descriptor not properly initialized: end_address != 0";
    tlm2error(trans, "4.2.5 s)");
  }
  if (dmi_data.get_read_latency() != sc_core::SC_ZERO_TIME)
  {
    txt << "DMI descriptor not properly initialized: read_latency != SC_ZERO_TIME";
    tlm2error(trans, "4.2.5 aa)");
  }
  if (dmi_data.get_write_latency() != sc_core::SC_ZERO_TIME)
  {
    txt << "DMI descriptor not properly initialized: write_latency != SC_ZERO_TIME";
    tlm2error(trans, "4.2.5 aa)");
  }
}


BOILERPLATE
transport_dbg_pre_checks( tlm::tlm_generic_payload& trans )
{
  if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0)
  {
    txt << "Debug transaction has data_ptr == 0";
    tlm2error(trans, "4.3.4 j)");
  }
}


BOILERPLATE
transport_dbg_post_checks( tlm::tlm_generic_payload& trans, unsigned int count )
{
  if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0)
  {
    txt << "Debug transaction has data_ptr == 0";
    tlm2error(trans, "4.3.4 j)");
  }
  if (count > trans.get_data_length())
  {
    txt << "Count returned from transport_dbg is greater than data_length";
    tlm2error(trans, "4.3.4 o)");
  }
}


BOILERPLATE
tlm2error( tlm::tlm_generic_payload& trans, const char* ref, bool warning )
{
  txt << "\n\nRefer to TLM-2.0 User Manual, version JA22, 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  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__