select_initiator.cpp

SystemC Transaction Level Modelling. 是基于SystemC之上的总线互联协议

//=============================================================================
    else { 
    msg.str ("");
    msg << "Initiator: " << m_ID               
        << " nb_transport_bw (GP, " 
        << report::print(phase) << ", "
        << delay << ")"
        << endl;

    switch (phase) 
    {

//-----------------------------------------------------------------------------
// Target has responded with END_REQ this is a 4 phase transaction 
//    Verify the previous current tracking enum is Rcved_ACCEPTED_enum  
//    Set tracking enum to Rcved_END_REQ 
//-----------------------------------------------------------------------------
    case tlm::END_REQ:  
      {
        if (transaction_pair->second == Rcved_ACCEPTED_enum) {
          msg << "      "
              << "Initiator: " << m_ID
              << " transaction waiting begin-response on backward path" 
              << endl;
                
          m_enable_next_request_event.notify(SC_ZERO_TIME); 
          transaction_pair->second = Rcved_END_REQ_enum;   
          status = tlm::TLM_ACCEPTED;
          
          msg << "      "
              << "Initiator: " << m_ID
              << " " << report::print(status) <<  " (GP, "
              << report::print(phase) << ", "
              << delay << ")"; 
          REPORT_INFO (filename, __FUNCTION__, msg.str() );

        }
        else {
          msg << "Initiator: " << m_ID 
              << " Unexpected END_REQ";
          REPORT_FATAL (filename, __FUNCTION__, msg.str() );
        }
        break;
      }

//-----------------------------------------------------------------------------
//  Target has responded with BEGIN_RESP 
//    The style could be 2,3 or 4 phase   
//	  Decode the previous tracking enum 
//-----------------------------------------------------------------------------
    case tlm::BEGIN_RESP:
      {
//-----------------------------------------------------------------------------
// Respond to begin-response - 2 phase style  
//-----------------------------------------------------------------------------
        if( transaction_pair->second == Rcved_UPDATED_enum){
        
          msg << "      "
            << "Initiator: " << m_ID
            << " Target response to begin-request was UPDATED" << endl 
            << "      "
            << "Initiator: " << m_ID
            << " indicating 2 phase return COMPLETED and annotate time" << endl; 

          m_enable_next_request_event.notify(SC_ZERO_TIME); // release reqeuster thread
          m_waiting_bw_path_map.erase(&transaction_ref);    // erase from map 

          phase   = tlm::END_RESP;                          // set appropriate return phase
          delay   = m_end_rsp_delay;                        // wait for the response delay
          status  = tlm::TLM_COMPLETED;                     // return status

          msg << "      "
              << "Initiator: " << m_ID
              << " " << report::print(status) <<  " (GP, "
              << report::print(phase) << ", "
              << delay << ")"; 
          REPORT_INFO (filename, __FUNCTION__, msg.str() );

          response_out_port->write(&transaction_ref);     // transaction to rsp fifo port
        }

//-----------------------------------------------------------------------------
//  Respond to begin-response when the target has omitted the 
//  end-request timing-point - 3 phase style 
//-----------------------------------------------------------------------------
        else if ( transaction_pair->second == Rcved_ACCEPTED_enum){

          msg << "      "
              << "Initiator: " << m_ID 
              << " target omitted end-request timing-point returning ACCEPTED ";
          REPORT_INFO (filename, __FUNCTION__, msg.str() );

          m_waiting_bw_path_map.erase(&transaction_ref);    // erase from map 
          
          // use payload event queue to schedule sending end response  
          m_send_end_rsp_PEQ.notify (transaction_ref, m_end_rsp_delay);
          
          m_enable_next_request_event.notify(SC_ZERO_TIME); 

          status = tlm::TLM_ACCEPTED;
        }
        
//-----------------------------------------------------------------------------
// Respond to begin-response - 4 phase style 
//-----------------------------------------------------------------------------
        else if ( transaction_pair->second == Rcved_END_REQ_enum){
          msg << "      "
              << "Initiator: " << m_ID 
              << " transaction moved to send-end-response PEQ "
              << endl;

          m_waiting_bw_path_map.erase(&transaction_ref);    // erase from map 
          
          // use payload event queue to schedule sending end response  
          m_send_end_rsp_PEQ.notify (transaction_ref, m_end_rsp_delay);

          status = tlm::TLM_ACCEPTED;
          
          msg << "      "
              << "Initiator: " << m_ID
              << " " << report::print(status) <<  " (GP, "
              << report::print(phase) << ", "
              << delay << ")" ; 
          REPORT_INFO (filename, __FUNCTION__, msg.str() );
        }

//-----------------------------------------------------------------------------
        else {
          msg.str ("");
          msg << m_ID << " - ** unexpected BEGIN_RESP";
          REPORT_FATAL (filename, __FUNCTION__, msg.str() );
        }

        break;

      }  // end case BEGIN_RESP

//-----------------------------------------------------------------------------
// Invalid phase for backward path 
//-----------------------------------------------------------------------------
    case tlm::BEGIN_REQ: 
    case tlm::END_RESP: 
      {
        msg.str ("");
        msg << m_ID << " Illegal phase on backward path ";
        REPORT_FATAL(filename, __FUNCTION__, msg.str() );
        break;   
      }
//-----------------------------------------------------------------------------
// Unknown phase on backward path  
//-----------------------------------------------------------------------------
    default: 
      {                     
        msg.str ("");
        msg << m_ID << " Unknown phase on the backward path ";
        REPORT_FATAL (filename, __FUNCTION__, msg.str() );
        break;   
      }
    } // end switch (phase)
  }
    return status;
} // end backward nb transport 



//=============================================================================
///  @fn select_initiator::send_end_rsp_method
//
///  @brief send end response method
//
///  @details This method is scheduled to send the end-response timing point.
///           It is sensitive to the m_send_end_rsp_PEQ.get_event() event. 
//
//=============================================================================
void select_initiator::send_end_rsp_method(void)    // send end response method
{
  tlm::tlm_generic_payload* transaction_ptr;
  std::ostringstream        msg;                    // log message

//-----------------------------------------------------------------------------  
//  Process all transactions scheduled for current time a return value of NULL 
//  indicates that the PEQ is empty at this time
//----------------------------------------------------------------------------- 
  while ((transaction_ptr = m_send_end_rsp_PEQ.get_next_transaction()) != NULL)
  {
    tlm::tlm_phase phase  = tlm::END_RESP;          // set the appropriate phase
    sc_time delay         = SC_ZERO_TIME;

    msg.str("");
    msg   << "Initiator: " << m_ID
        << " starting send-end-response method"
        << endl << "      " 
        << "Initiator: " << m_ID               
        << " nb_transport_fw (GP, " 
        << report::print(phase) << ", "
        << delay << ")";
    REPORT_INFO(filename,  __FUNCTION__, msg.str());

    // call begin response and then decode return status
    tlm::tlm_sync_enum 
    return_value = initiator_socket->nb_transport_fw(*transaction_ptr, phase, delay);
    
    msg.str("");
    msg << "Initiator: " << m_ID
      << " " << report::print(return_value) <<  " (GP, "
      << report::print(phase) << ", "
      << delay << ")"; 

    switch (return_value)    
    {
      case tlm::TLM_COMPLETED:                        // transaction complete
      {
        response_out_port->write(transaction_ptr);    // send GP to output rsp fifo
        
        REPORT_INFO (filename, __FUNCTION__, msg.str() );
        break;
      }

      case tlm::TLM_ACCEPTED: 
      case tlm::TLM_UPDATED:   
      default: 
      {
        msg << "      " 
            << "Initiator: " << m_ID
            << report::print(return_value) << " Unknown return value for END_RESP ";
        REPORT_INFO(filename,  __FUNCTION__, msg.str()); 
        break;
      }
    } // end switch 
  } // end while 

    return;
} // end send_end_rsp_method


//=============================================================================
///  @fn select_initiator::invalidate_direct_mem_ptr
//
///  @brief invalidate direct memory pointer Not implemented 
//=============================================================================

void select_initiator::invalidate_direct_mem_ptr  // invalidate_direct_mem_ptr
( sc_dt::uint64 start_range                       // start range
, sc_dt::uint64 end_range                         // end range
) 
{
  std::ostringstream       msg;                     // log message

  msg.str ("");
  msg << m_ID << " invalidate_direct_mem_ptr: not implemented";
  REPORT_INFO(filename, __FUNCTION__, msg.str());
}