PV, PV+T, CA in SystemC

The most abstract level in the SystemC TLM methodology is called PV. It implements the channel communication based on events that determine the beginning and the end of the request phase, mstr_requestStartEvent and
mstr_requestEndEvent, as well as the protocol functionality using three methods, sendRequest, getRequest, and requestInProgress. The first method is used by the traffic generator and the second by the message receiver; the purpose of the third one is to check the status of the transfer:

template <class T> class pv_channel : public sc_module, public pv_masterRequestIF<T>, public pv_slaveRequestIF<T> { public: SC_HAS_PROCESS(pv_channel); pv_channel(sc_module_name name) : sc_module(name), mstr_requestInProgress(false), mstr_requestUnread(false){} virtual >pv_channel(){} bool sendRequest(const T& req) { if (! mstr_requestInProgress) { mstr_requestInProgress = true; mstr_requestUnread = true; mstr_currentRequest = req; mstr_RequestStartEvent.notify(); return true; } return false; } bool getRequest(T& req) { if (mstr_requestInProgress && mstr_requestUnread) { req = mstr_currentRequest; mstr_requestUnread = false; return true; } return false; } bool acceptRequest(void) { if (requestInProgress) { mstr_requestInProgress = false; mstr_requestUnread = false; mstr_RequestEndEvent.notify(); return true; } return false; } bool requestInProgress(void) { return mstr_requestInProgress; } const sc_event& requestStartEvent(void) const { return mstr_requestStartEvent; } const sc_event& requestEndEvent(void) const { return mstr_RequestEndEvent; } protected: bool mstr_requestInProgress; bool mstr_requestUnread; T mstr_currentRequest; sc_event mstr_requestStartEvent; sc_event mstr_requestEndEvent; };

 

Adding more details, such as time and detailed transfer information (data and address), we move to a more concrete level called PV+T. The class constructor now takes an additional parameter: the clock period. New methods extend the bus functionality (e.g., they now consider the reset aspects). In the following, we provide an example of the implementation of the request phase. Although the behavior remains the same, the transfer information has been detailed to include data and address:

 

bool sendRequest(const requestGrp<Tdata,Taddr>& req) { if (! mstr_requestInProgress) { mstr_requestInProgress = true; mstr_requestUnread = true; mstr_currentRequest = req; mstr_RequestStartEvent.notify(); return true; } return false; }

 

Further changes relate to the implementation of the acceptRequest method, which now takes timing information, either in explicit time form:

 

bool acceptRequest(const sc_time& accept_time) { if (m_requestInProgress) { m_ReleaseRequestEvent.notify(accept_time); return true; } return false; }

 

or in a form correlated to clock cycles:

 

bool acceptRequest(int cycles) { if (mstr_requestInProgress) { if (cycles < 0) { int estimatedCycles = getReqDuration(); mstr_releaseRequestEvent.notify( estimatedCycles * mstr_clkPeriod); return true; } else if (cycles == 0) { return acceptRequest(); } else { mstr_releaseRequestEvent.notify(cycles * mstr_clkPeriod); return true; } } return false; }

 

The next version, which is even more concrete, is a cycle-accurate implementation that uses clock cycle timing and bit true variable information. As can be seen from the bus implementation shown here, the detailed data information is packaged in the newRequest structure:

 

bool startRequest(requestGrp<Tdata,Taddr>& newRequest) { if (get_reset()) { return false; } if ( !(mstr_putRequest()) ) { return false; } m_DataCl->MputRequestGroup(newRequest); return true; }

 

The actual timing is implemented on the bus interface, both in the bus master and the slave interface methods, as demonstrated here for the request method of the master interface:

 

template<typename TdataCl> void MasterSysC<TdataCl>::requestThreadProcess() { Ta Addr[4]; bool isWriteCmd; double wait_for = NumWait[Nr][Count]; wait(m_clk->posedge_event()); while (!(ipP->getReset())) { req.Cmd = currentCmd; req.Addr = Addr[Count] + m_ID*0x40; req.ByteEn = 0xf; req.AddrSpace = 0x1; req.Data = my_data + m_ID*0x40; ipPort->startRequest(req); current_time = sc_time_stamp(); double delta_time = (current_time.value()-old_time.value())/1000; if (delta_time >= wait_for) { wait_for = 0; } else { wait_for = wait_for - delta_time; } } }

 

The process is synchronized by a clock, but also offers the opportunity to run with a fixed delay using wait_for. The delay is also used in case of a handshaking mechanism or response check offered by the bus slave.