Context Navigation

Changes between Version 84 and Version 85 of Writing Rules/Tlmt

Timestamp:: Nov 17, 2008, 12:06:04 PM (17 years ago)
Author:: alain
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

Writing Rules/Tlmt

-                      v84
+                      v85
 Dedicated VCI accessors are used to define the VCI transaction type, that can either be '''set_read()''' (for VCI read command),
 '''set_write()''' (for VCI write command),'''set_locked_read()''' (for VCI atomic locked read),
 and '''set_store_cond()''' (for VCI atomic store conditional). The '''set_src_id()''', '''set_trd_id()''' and '''set_pkt_id()''' functions
+and '''set_store_cond()''' (for VCI atomic store conditional). The '''set_srcid()''', '''set_trdid()''' and '''set_pktid()''' functions
 respectively set the VCI source, thread and packet identifiers.
 …
 This class inherits from the standard SystemC '''sc_core::sc_module''' class, that acts as the root class for all TLM-T modules.
 The initiator local time is contained in a member variable named '''m_localTime''', of type '''sc_core::sc_time'''. The
+The initiator local time is contained in a member variable named '''m_local_time''', of type '''sc_core::sc_time'''. The
 local time can be accessed with the following accessors: '''addLocalTime()''', '''setLocalTime()'''
 and '''getLocalTime()'''.
 …
 ////////////////////////// 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
+#include "tlmt_transactions.h"                  // TLM-T headers
+#include "tlmt_simple_initiator_socket.h"       // TLM-T initiator socket
+#include "mapping_table.h"            // mapping Table
+class my_initiator                              // my_initiator
+:         public sc_core::sc_module             // inherit from SC module base clase
+{
 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;
+  /////////////////////////////////////////////////////////////////////////////////////
+  // Functions
+  /////////////////////////////////////////////////////////////////////////////////////
+//////////////////////
+// Member Variables
+//////////////////////
+  uint32_t                           m_srcid;
+  soclib::common::MappingTable       m_mt;
+  uint32_t                           m_counter;
+  uint32_t                           m_lookahead;
+  sc_core::sc_time                   m_local_time;
+  bool                               m_activity_status;
+  sc_core::sc_event                  m_rsp_event;
+  soclib_vci_types::tlm_payload_type m_payload;
+  soclib_vci_types::tlm_phase_type   m_phase;
+  ///////////////////////
+  // Member Functions
+  ///////////////////////
   void execLoop(void);                              // initiator thread
+  bool getActivity(void);                           // get the activity state
+  void setActivity(bool t);                         // set the activity status (true if the component is active)
+  sc_core::sc_time getLocalTime(void);              // get the local time
+  void setLocalTime(sc_core::sc_time& t);           // set the local time
   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 vci_rsp_received                // for resp messages
+    ( soclib_vci_types::tlm_payload_type &payload,   // payload
+      soclib_vci_types::tlm_phase_type   &phase,     // transaction phase
+      sc_core::sc_time                   &time);     // resp time
+  tlm::tlm_sync_enum vci_rsp_received  // interface function to receive VCI response
+    ( soclib_vci_types::tlm_payload_type &payload,     // payload
+      soclib_vci_types::tlm_phase_type   &phase,       // phase
+      sc_core::sc_time                   &time);       // time
 protected:
   SC_HAS_PROCESS(my_initiator);
 public:
+  tlmt_simple_initiator_socket<my_initiator,32,soclib_vci_types> p_vci_init;   // VCI initiator port
+  /////////////////
+  //  ports
+  /////////////////
+  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__ */
+               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
+};
 ////////////////////////// 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
+/////////////////
+// Constructor
+/////////////////
+my_initiator::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
+            m_mt(mt),                                 // mapping table
+            p_vci_init("socket")                 // vci initiator socket name
+{
+  // link the interface function the TLM-T INITIATOR SOCKET
   p_vci_init.register_nb_transport_bw(this, &my_initiator::vci_rsp_received);
   // initiator identification
   m_initid = mt.indexForId(index);
+  m_srcid = mt.indexForId(index);
   //lookahead control
 …
   //initialize the local time
   m_localTime= 0 * UNIT_TIME;
+  m_local_time = 0 * UNIT_TIME;
   // initialize the activity variable
   setActivity(true);
   // register thread process
   SC_THREAD(execLoop);
+  SC_THREAD(execLoop);
+}
+/////////////////////////////////////////////////////////////////////////////////////
+// Functions
+/////////////////////////////////////////////////////////////////////////////////////
+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::tlm_payload_type payload;
+  soclib_vci_types::tlm_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 ){
+//////////////////////
+//  Access Functions
+//////////////////////
+bool my_initiator::getActivity() { return m_activity; }
+my_initiator::setActivity(bool t) { m_activity = t; }
+sc_core::sc_time my_initiator::getLocalTime() { return m_local_time; }
+my_initiator::setLocalTime(sc_core::sc_time t) { m_local_time = t; }
+my_initiator::addLocalTime(sc_core::sc_time t) { m_local_time += t; }
+///////////////////////
+//  thread
+///////////////////////
+my_initiator::execLoop(void)
+{
+  uint32_t address =  0x10000000;
+  uint32_t data_int = 0xAABBCCDD;
+  unsigned char data[4];
+  unsigned char byte_enable[4];
+  int nbytes = 4;
+  for(int i=0; i<nbytes; i++) byte_enable[i] = TLM_BYTE_ENABLED;
+  while ( true ) {
+    // increase local time
     addLocalTime(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_initid);
+    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_initid << "] 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_initid << "] receive rsp packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
+#endif
+    pktid++;
+    addLocalTime(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_initid);
+    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_initid << "] 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_initid << "] receive rsp packet id = " << payload.get_pkt_id() << " time = " << getLocalTime().value() << std::endl;
+#endif
+    pktid++;
+    // prepare payload (including int to char translation)
+    m_payload.itoa(data_int, data, 0);
+    m_payload.set_write();
+    m_payload.set_address(address);
+    m_payload.set_byte_enable_ptr(byte_enable);
+    m_payload.set_data_ptr(data);
+    m_payload.set_data_length(nbytes);
+    m_payload.set_srcid(m_srcid);
+    m_payload.set_trdid(0);
+    m_payload.set_pktid(0);
+    // set the phase
+    m_phase= soclib::tlmt::TLMT_CMD;
+    // send the VCI command packet...
+    p_vci_initiator->nb_transport_fw(m_payload, m_phase, m_local_time);
+    // thread is descheduled, waiting for the response
+    wait(m_rsp_event);
     // lookahead management
     m_counter++ ;
 …
       wait(sc_core::SC_ZERO_TIME) ;
+    }
+  } // end while true
+  setActivity(false);
+} // end initiator_thread
+/////////////////////////////////////////////////////////////////////////////////////
+// Virtual Functions  tlm::tlm_bw_transport_if (VCI SOCKET)
+/////////////////////////////////////////////////////////////////////////////////////
+/// receive the response packet from target socket
+tmpl (tlm::tlm_sync_enum)::vci_rsp_received          //
+( soclib_vci_types::tlm_payload_type &payload,       // VCI payload
+  soclib_vci_types::tlm_phase_type   &phase,         // tlm phase
+  sc_core::sc_time                   &rspTime        // time
+  } // end while
+} // end execLoop()
+///////////////////////////////////////////////////////////////
+// Interface Function to  receive the response packet
+///////////////////////////////////////////////////////////////
+ tlm::tlm_sync_enum my_initiator::vci_rsp_received
+( soclib_vci_types::tlm_payload_type &payload, // payload
+  soclib_vci_types::tlm_phase_type   &phase,   // phase
+  sc_core::sc_time                   &time     // time
+ )
+{
   switch(phase){
   case soclib::tlmt::TLMT_RSP :
     setLocalTime(rspTime);
     m_rspEvent.notify(0 * UNIT_TIME);
+    setLocalTime(time);
+    m_rsp_event.notify(0 * UNIT_TIME);
     break;
   case soclib::tlmt::TLMT_INFO :
+  case soclib::tlmt::TLMT_INFO :
     payload.set_local_time_ptr(&m_localTime);
     payload.set_activity_ptr(&m_activity);
 …
+  }
   return tlm::TLM_COMPLETED;
+} // end backward nb transport
+} // end vci_rsp_received()
 }}}
 …
 #include "tlm.h"                        // TLM headers
 #include "tlmt_transactions.h"          // VCI headers
 #include "tlmt_simple_target_socket.h"  // VCI SOCKET
+#include "tlmt_transactions.h"          // TLM-T headers
+#include "tlmt_simple_target_socket.h"  // TLM-T SOCKET
 #include "mapping_table.h"
 #include "soclib_endian.h"
 …
   /////////////////////////////////////////////////////////////////////////////////////
   // Virtual Fuctions  tlm::tlm_fw_transport_if (VCI SOCKET)
+  // Interface Fuction  tlm::tlm_fw_transport_if (VCI SOCKET)
   /////////////////////////////////////////////////////////////////////////////////////
 …
+}
+////////////////////////// my_target.h ////////////////////////////////
+////////////////////////// my_target.cpp ////////////////////////////////
 }}}
 …
 provides an utility function '''fill_time_activity_arrays()''' that must be called in the SystemC top-cell, before starting the simulation.