Context Navigation

Changes between Version 60 and Version 61 of Writing Rules/Tlmt

Timestamp:: Nov 15, 2008, 3:50:06 PM (17 years ago)
Author:: alain
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

Writing Rules/Tlmt

-                      v60
+                      v61
 constrained, but the arguments must respect the following prototype:
 {{{
   tlm::tlm_sync_enum vci_rsp_received                // for resp messages
+  tlm::tlm_sync_enum vci_rsp_received
     ( soclib_vci_types::tlm_payload_type &payload,     // payload
       soclib_vci_types::tlm_phase_type   &phase,      // transaction phase
 …
 In the general case, the actions executed by the call-back function depend on the response transaction type ('''m_command''' field), as well as
 the '''pktid''' and '''trdid''' fields.
+For sake of simplicity, in the proposed example the call-back function does not make any distinction between VCI transaction types :
+For sake of simplicity, the call-back function proposed below does not make any distinction between VCI transaction types.
 == C.3) Initiator Constructor ==
 The constructor of the class '''my_initiator''' must initialize all the member variables, including
+the '''p_vci_init''' port. The '''my_nb_transport_bw()''' call-back function being executed in the context of the thread sending
+the response packet, a link between the '''p_vci_init''' port and the call-back function must be established.
+The TLMT_INFO transaction allows the target to
+get information on the initiator that actually sends VCI packets (the initiator local time, the initiator activity, etc).
+the '''p_vci_init''' port. The '''vci_rsp_received()''' call-back function being executed in the context of the thread sending
+the response packet, a link between the '''p_vci_init''' port and this call-back function must be established.
 The '''my_initiator''' constructor for the '''p_vci_init''' object must be called with the following arguments:
 {{{
+  p_vci_init.register_nb_transport_bw(this, &my_initiator::my_nb_transport_bw);
+}}}
+where '''my_nb_transport_bw''' is the name of the callback function
+  p_vci_init.register_nb_transport_bw(this, &my_initiator::vci_rsp_received);
+}}}
 == C.4) Lookahead parameter ==
 …
 ////////////////////////// my_initiator.h ////////////////////////////////
+#ifndef __MY_INITIATOR_H__
+#define __MY_INITIATOR_H__
+#include "tlm.h"                                // TLM headers
+#include "tlmt_transactions.h"                  // VCI headers
+#include "tlmt_simple_initiator_socket.h"       // VCI socket
+#include "mapping_table.h"
+class my_initiator                              // my_initiator
+:         public sc_core::sc_module             // inherit from SC module base class
+{
+private:
+  //Variables
+  typedef soclib::tlmt::VciParams<uint32_t,uint32_t,4> vci_param;
+  sc_core::sc_event m_rspEvent;
+  sc_core::sc_time m_localTime;
+  bool m_activity;
+  uint32_t m_initid;
+  uint32_t m_counter;
+  uint32_t m_lookahead;
+  /////////////////////////////////////////////////////////////////////////////////////
+  // Fuctions
+  /////////////////////////////////////////////////////////////////////////////////////
+  void execLoop(void);                              // initiator thread
+  void addLocalTime(sc_core::sc_time t);            // add a value to the local time
+  void setLocalTime(sc_core::sc_time& t);           // set the local time
+  sc_core::sc_time getLocalTime(void);              // get the local time
+  void setActivity(bool t);                         // set the activity status (true if the component is active)
+  bool getActivity(void);                           // get the activity state
+  /////////////////////////////////////////////////////////////////////////////////////
+  // Virtual Fuctions  tlm::tlm_bw_transport_if (VCI INITIATOR SOCKET)
+  /////////////////////////////////////////////////////////////////////////////////////
+  /// Receive rsp from target
+  tlm::tlm_sync_enum my_nb_transport_bw                // for resp messages
+    ( soclib_vci_types::vci_payload_type &payload,     // payload
+      soclib_vci_types::tlmt_phase_type   &phase,      // transaction phase
+      sc_core::sc_time                   &time);       // resp time
+protected:
+  SC_HAS_PROCESS(my_initiator);
+public:
+  tlmt_simple_initiator_socket<my_initiator,32,soclib_vci_types> p_vci_init;   // VCI initiator port
+  //constructor
+  my_initiator(                                              // constructor
+               sc_core::sc_module_name name,                 // module name
+               const soclib::common::IntTab &index,          // VCI initiator index
+               const soclib::common::MappingTable &mt,       // mapping table
+               uint32_t lookahead                            // lookahead
+               );
+};
+ #endif /* __MY_INITIATOR_H__ */
 ////////////////////////// my_initiator.cpp ////////////////////////////////
-#include "my_initiator.h"                       // Our header
-#ifndef MY_INITIATOR_DEBUG
-#define MY_INITIATOR_DEBUG 1
-#endif
-#define tmpl(x) x my_initiator
-///Constructor
-tmpl (/**/)::my_initiator
-            ( sc_core::sc_module_name name,           // module name
-              const soclib::common::IntTab &index,    // index of mapping table
-              const soclib::common::MappingTable &mt, // mapping table
-              uint32_t lookahead                      // lookahead
+              )
-            : sc_module(name)                         // init module name
-           , p_vci_init("p_vci_init")                 // vci initiator socket name
+{
-  //register callback function
-  p_vci_init.register_nb_transport_bw(this, &my_initiator::my_nb_transport_bw);
-  // initiator identification
-  m_initid = mt.indexForId(index);
-  //lookahead control
-  m_counter = 0;
-  m_lookahead = lookahead;
-  //initialize the local time
-  m_localTime= 0 * UNIT_TIME;
-  // initialize the activity variable
-  setActivity(true);
-  // register thread process
-  SC_THREAD(execLoop);
+}
-/////////////////////////////////////////////////////////////////////////////////////
-// Fuctions
-/////////////////////////////////////////////////////////////////////////////////////
-tmpl (sc_core::sc_time)::getLocalTime()
+{
-  return m_localTime;
+}
-tmpl (bool)::getActivity()
+{
-  return m_activity;
+}
-tmpl (void)::setLocalTime(sc_core::sc_time &t)
+{
-  m_localTime=t;
+}
-tmpl (void)::addLocalTime(sc_core::sc_time t)
+{
-  m_localTime= m_localTime + t;
+}
-tmpl (void)::setActivity(bool t)
+{
-  m_activity =t;
+}
-tmpl (void)::execLoop(void)   // initiator thread
+{
-  soclib_vci_types::vci_payload_type payload;
-  soclib_vci_types::tlmt_phase_type phase;
-  sc_core::sc_time sendTime;
-  unsigned char data[32];
-  unsigned char byte_enable[32];
-  int pktid = 0;
-  int nbytes = 4; // 1 word of 32 bits
-  uint32_t int_data = 12345678;
-  std::ostringstream name;
-  name << "" << int_data;
-  std::cout << "NAME = " << std::dec << name << std::endl;
-  for(int i=0; i<nbytes; i++)
-    byte_enable[i] = TLMT_BYTE_ENABLED;
-  for(int i=0; i<32; i++)
-    data[i] = 0x0;
-  data[0]='a';
-  data[1]='b';
-  data[2]='c';
-  data[3]='d';
-  data[4]='\0';
-  std ::cout<< "DATA = " << data << std::endl;
-  while ( 1 ){
-    addTime(10 * UNIT_TIME);
-    payload.set_address(0x10000000);//ram 0
-    payload.set_byte_enable_ptr(byte_enable);
-    payload.set_byte_enable_length(nbytes);
-    payload.set_data_ptr(data);
-    payload.set_data_length(nbytes); // 5 words of 32 bits
-    payload.set_write();
-    payload.set_src_id(m_id);
-    payload.set_trd_id(0);
-    payload.set_pkt_id(pktid);
-    phase= soclib::tlmt::TLMT_CMD;
-    sendTime = getLocalTime();
-#if MY_INITIATOR_DEBUG
-    std::cout << "[INITIATOR " << m_id << "] send cmd packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
-#endif
-    p_vci_init->nb_transport_fw(payload, phase, sendTime);
-    wait(m_rspEvent);
-#if MY_INITIATOR_DEBUG
-    std::cout << "[INITIATOR " << m_id << "] receive rsp packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
-#endif
-    pktid++;
-    addTime(10 * UNIT_TIME);
-    payload.set_address(0x10000000);//ram 0
-    payload.set_byte_enable_ptr(byte_enable);
-    payload.set_byte_enable_length(nbytes);
-    payload.set_data_ptr(data);
-    payload.set_data_length(nbytes); // 5 words of 32 bits
-    payload.set_read();
-    payload.set_src_id(m_id);
-    payload.set_trd_id(0);
-    payload.set_pkt_id(pktid);
-    phase= soclib::tlmt::TLMT_CMD;
-    sendTime = getLocalTime();
-#if MY_INITIATOR_DEBUG
-    std::cout << "[INITIATOR " << m_id << "] send cmd packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
-#endif
-    p_vci_init->nb_transport_fw(payload, phase, sendTime);
-    wait(m_rspEvent);
-#if MY_INITIATOR_DEBUG
-    std::cout << "[INITIATOR " << m_id << "] receive rsp packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
-#endif
-    pktid++;
-    // lookahead management
-    m_counter++ ;
-    if (m_counter >= m_lookahead) {
-      m_counter = 0 ;
-      wait(sc_core::SC_ZERO_TIME) ;
+    }
-  } // end while true
-  setActivity(false);
-} // end initiator_thread
-/////////////////////////////////////////////////////////////////////////////////////
-// Virtual Fuctions  tlm::tlm_bw_transport_if (VCI SOCKET)
-/////////////////////////////////////////////////////////////////////////////////////
-/// receive the response packet from target socket
-tmpl (tlm::tlm_sync_enum)::my_nb_transport_bw // inbound nb_transport_bw
-( soclib_vci_types::vci_payload_type &payload,       // VCI payload
-  soclib_vci_types::tlmt_phase_type   &phase,        // tlm phase
-  sc_core::sc_time                   &rspTime        // the response timestamp
+ )
+{
-  switch(phase){
-  case soclib::tlmt::TLMT_RSP :
-    setLocalTime(rspTime);
-    m_rspEvent.notify(0 * UNIT_TIME);
-    break;
-  case soclib::tlmt::TLMT_INFO :
-    payload.set_local_time_ptr(&m_localTime);
-    payload.set_activity_ptr(&m_activity);
-    break;
+  }
-  return tlm::TLM_COMPLETED;
-} // end backward nb transport
 }}}
 …
 = D) VCI target modeling =
 In the proposed example, the target handles all VCI commands in the same way. To simplify the model, there is no real error management.
+In the proposed example, the '''my_target''' component handles all VCI commands in the same way, and there is no error management.
 The class '''my_target''' inherits from the class '''sc_core::sc_module'''. The class '''my_target''' contains a member
 …
 To receive a VCI command packet, a call-back function must be defined as a member function of the class '''my_target'''.
 This call-back function (named '''my_nb_transport_fw()''' in the example), will be executed each time a VCI command packet is received on
+This call-back function (named '''vci_cmd_received()''' in the example), will be executed each time a VCI command packet is received on
 the '''p_vci_target''' port. The function name is not constrained, but the arguments must respect the following prototype:
 {{{
   tlm::tlm_sync_enum my_nb_transport_fw               /// sync status
   ( soclib_vci_types::vci_payload_type &payload,      ///< VCI payload pointer
     soclib_vci_types::tlmt_phase_type   &phase,       ///< transaction phase
     sc_core::sc_time                   &time);        ///< time
+  tlm::tlm_sync_enum vci_cmd_received
+  ( soclib_vci_types::tlm_payload_type &payload,      // VCI payload pointer
+    soclib_vci_types::tlm_phase_type   &phase,       // transaction phase
+    sc_core::sc_time                   &time);        // time
 }}}
 == D.2) Sending a VCI response packet ==
+To send a VCI response packet the '''my_nb_transport_fw()''' function must use the '''nb_transport_bw()''' method, that is a member function of
+the class '''tlmt_simple_target_socket''', and has the following prototype:
+To send a VCI response packet the call-back function '''vci_cmd_received()''' must use the '''nb_transport_bw()''' method, that is a member function of
+the class '''tlmt_simple_target_socket''', and has the same arguments as the '''nb_transport_fw()''' function.
+Respecting the general TLM2.0 policy, the payload argument refers to the same '''tlmt_vci_transaction''' object for both the '''nb_transport_fw()''' and '''nb_transport_bw()''' functions,
+and the associated call-back functions. The set_response_status field must be documented for all transaction types, but only two values are used in this implementation:
+ * TLMT_OK_RESPONSE
+ * TLMT_ERROR_RESPONSE
+For a reactive target, the response packet time is computed as the command packet time plus the target intrinsic latency.
 {{{
         payload.set_response_status(soclib::tlmt::TLMT_OK_RESPONSE);
         phase = soclib::tlmt::TLMT_VCI_RSP;
         time = time + (nwords * UNIT_TIME);
         p_vci_target->nb_transport_bw(payload, phase, time);
 }}}
-For a reactive target, the response packet time is computed as the command packet time plus the target intrinsic latency.
 == D.3) Target Constructor ==
 The constructor of the class '''my_target''' must initialize all the member variables, including
 the '''p_vci_target''' port. The '''my_nb_transport_fw()''' call-back function being executed in the context of the thread sending
+the '''p_vci_target''' port. The '''vci_cmd_received()''' call-back function being executed in the context of the thread sending
 the command packet, a link between the '''p_vci_target''' port and the call-back function must be established.
 The '''my_target''' constructor must be called with the following arguments:
 {{{
+  p_vci_target.register_nb_transport_fw(this, &my_target::my_nb_transport_fw);
+}}}
+where '''my_nb_transport_fw''' is the name of the forward callback function.
+  p_vci_target.register_nb_transport_fw(this, &my_target::vci_cmd_received);
+}}}
 == D.4) VCI target example ==
 …
 ////////////////////////// my_target.h ////////////////////////////////
-#ifndef __MY_TARGET_H__
-#define __MY_TARGET_H__
-#include "tlm.h"                        // TLM headers
-#include "tlmt_transactions.h"          // VCI headers
-#include "tlmt_simple_target_socket.h"  // VCI SOCKET
-#include "mapping_table.h"
-#include "soclib_endian.h"
-class my_target
-  : public sc_core::sc_module
+{
- private:
-  typedef soclib::tlmt::VciParams<uint32_t,uint32_t,4> vci_param;
-  uint32_t m_targetid;
-  soclib::common::MappingTable m_mt;
-  /////////////////////////////////////////////////////////////////////////////////////
-  // Virtual Fuctions  tlm::tlm_fw_transport_if (VCI SOCKET)
-  /////////////////////////////////////////////////////////////////////////////////////
-  // receive command from initiator
-  tlm::tlm_sync_enum my_nb_transport_fw               /// sync status
-  ( soclib_vci_types::vci_payload_type &payload,      ///< VCI payload pointer
-    soclib_vci_types::tlmt_phase_type   &phase,       ///< transaction phase
-    sc_core::sc_time                   &time);        ///< time
- protected:
-  SC_HAS_PROCESS(my_target);
- public:
-  tlmt_simple_target_socket<my_target,32,soclib_vci_types> p_vci_target;        ///<  VCI target socket
-  my_target(sc_core::sc_module_name            name,
-         const soclib::common::IntTab       &index,
-         const soclib::common::MappingTable &mt);
-  ~my_target();
-};
-#endif
 ////////////////////////// my_target.cpp ////////////////////////////////
+#include "my_target.h"
+#ifndef MY_TARGET_DEBUG
+#define MY_TARGET_DEBUG 1
+#endif
+#define tmpl(x) x my_target
+//////////////////////////////////////////////////////////////////////////////////////////
+// CONSTRUCTOR
+//////////////////////////////////////////////////////////////////////////////////////////
+tmpl(/**/)::my_target
+           ( sc_core::sc_module_name name,
+             const soclib::common::IntTab &index,
+             const soclib::common::MappingTable &mt)
+           : sc_module(name),
+           m_mt(mt),
+           p_vci_target("p_vci_target")
+{
+  //register callback fuction
+  p_vci_target.register_nb_transport_fw(this, &my_target::my_nb_transport_fw);
+  m_id = m_mt.indexForId(index);
+}
+tmpl(/**/)::~my_target(){}
+/////////////////////////////////////////////////////////////////////////////////////
+// Virtual Fuctions  tlm::tlm_fw_transport_if VCI SOCKET
+/////////////////////////////////////////////////////////////////////////////////////
+//nb_transport_fw implementation calls from initiators
+tmpl(tlm::tlm_sync_enum)::my_nb_transport_fw                            // non-blocking transport call through Bus
+                         ( soclib_vci_types::vci_payload_type &payload, // VCI payload pointer
+                           soclib_vci_types::tlmt_phase_type   &phase,  // transaction phase
+                           sc_core::sc_time                   &time)    // time
+{
+  int nwords = payload.get_data_length() / vci_param::nbytes;
+  switch(payload.get_command()){
+  case soclib::tlmt::VCI_READ_COMMAND:
+  case soclib::tlmt::VCI_WRITE_COMMAND:
+  case soclib::tlmt::VCI_LOCKED_READ_COMMAND:
+  case soclib::tlmt::VCI_STORE_COND_COMMAND:
+      {
+#if MY_TARGET_DEBUG
+        std::cout << "[RAM " << m_id << "] Receive from source " << payload.get_src_id() <<" a packet "<< payload.get_pkt_id() << " Time = "  << time.value() << std::endl;
+#endif
+        payload.set_response_status(soclib::tlmt::TLMT_OK_RESPONSE);
+        phase = soclib::tlmt::TLMT_VCI_RSP;
+        time = time + (nwords * UNIT_TIME);
+#if MY_TARGET_DEBUG
+        std::cout << "[RAM " << m_id << "] Send to source "<< payload.get_src_id() << " a anwser packet " << payload.get_pkt_id() << " Time = "  << time.value() << std::endl;
+#endif
+        p_vci_target->nb_transport_bw(payload, phase, time);
+        return tlm::TLM_COMPLETED;
+      }
+      break;
+    default:
+      break;
+  }
+  //send error message
+  payload.set_response_status(soclib::tlmt::TLMT_ERROR_RESPONSE);
+  phase = soclib::tlmt::TLMT_VCI_RSP;
+  time = time + nwords * UNIT_TIME;
+#if MY_TARGET_DEBUG
+  std::cout << "[RAM " << m_id << "] Address " << payload.get_address() << " does not match any segment " << std::endl;
+  std::cout << "[RAM " << m_id << "] Send to source "<< payload.get_src_id() << " a error packet with time = "  << time.value() << std::endl;
+#endif
+  p_vci_target->nb_transport_bw(payload, phase, time);
+  return tlm::TLM_COMPLETED;
+}
+}}}
+= E) VCI Interconnect =
+}}}
+= E) VCI Interconnect modelling =
 The VCI interconnect used for the TLM-T simulation is a generic simulation model, named '''!VciVgmn'''.