Protocol Checkers for DUT state machine

In order to write a Protocol Checker for the DUT state machine we need to do the following
1. Declare an enumerated type having the same propreties as of the DUT enumerated type.
2. Declare an e-port may be of simple port of inout type
3. Declare an e-event for the corresponding DUT state machine value.
4. on the emission of the event check the required condition . If it satisfied continue else come out with DUT ERROR.

Ex :
type state_t : [ IDLE, SHIFT, SAMPLE];

unit monitor_u {
state_sig_port : inout simple_port of uint is instance;
keep bind ( state_sig_port, external );
keep state_sig_port.hdl_path() == "/top/state_s";

event state_sig_port_shift_e is true ( state_sig_port.as_a(state_t) == SHIFT) @clk_rise;
event en_sig_e is rise (en_sig$) @clk_rise;
expect @state_sig_port_shift_e =>{ @en_sig_e } @clk_rise else dut_error ("......");

Temporal checker using e language

Temporal Checker mainly depends on the Temporal Expressions ( TE's) and these are directed statments ( one line statement) with major reference to Reference clocks.
For ex :
I have shown a small example which expects certain event to be emitter based on the following conditions.
<'
unit bus_u {
event bus_clk is change('clk') @sim;
event transmit_start is rise('transcation_done') @bus_clk;
event transmit_end is rise('transmit_done') @bus_clk;
event bus_cycle_length;
on transmit_start {
out ("found the transmit_start event...", sys.time);
};
expect bus_cycle_length is @transmit_start => {[0..9];@transmit_end} @bus_clk
else dut_error("Bus cycle did not end in 10 cycles");
};
extend sys {
bus : bus_u is instance; keep bus.hdl_path() == "top";
};
'>

combination between Method & TCM in Specman Environment

Currently we can see the Combination exists between the Methods & TCM in Specman Environment.

TCM :
TCM can Start another TCM ( Using start keyword )
TCM can call another Method .

Methods :
Methods can start TCM.
Methods can call another Method.
Methods cannot call a TCM.

Time Consuming Method (TCM) in specman e-language

TCM's are defined as the methods that have the notion of time, as designated by their sampling event.
· TCM's can be executed over several simulation cycles.
Syntax:
tcm_name([arg: type,...]) [:return-type] @sampling-event is {
---- Required action parameters;
};
TCM’s are attached with sampling_event. The sampling_event fills two functions.
· Implicit sync action at beginning of TCM( must occur before TCM execution begins)
· Default sampling event for TEs in the TCM

Ex: <'
unit port_u {
reset_value: bit;
reset_delay: uint;
reset () @clk is {
---- This indicates the TCM is @sync with clk
reset_value = 0b1;
wait [reset_delay] * cycle;
reset_value = 0b0;
wait [1] * cycle;
};
run() is also {
start reset();
}; };
'>

Declaration of Specman e-language Basic Temporal Expressions

Cadence Specman Elite e-language TE (Temporal Expression), is always associated with a sampling event indicating when the Temporal Expression needs to be evaluated by Specman elite e-language.
1) true(Boolean-exp)@sample-event
The above expression indicates for every Sample-event that the Boolean Expression is true.
2) rise/fall/change (exp)@sample-event
The above expression indicates for every Sample-event that the Expression is rising (falling/change).
3) Cycle @sample-event
The above Expression indicates for every sampling event.
4) [Number] * TE
The above expression indicates the TE’s is repeated for number of times.

Importance Of Using Sampling Events in specman elite e-language

In order to drive / sample signals correctly, there is a need to synchronize with the simulator.
To achieve the above task there is a need to make use of the Specman elite Temporal Language Expression.
The Temporal language of the e-language is the basis for capturing behavior over time for below purpose:
-> To synchronizing with the DUT.
-> In order to develop protocol checkers for automation.
-> In order to develop a Functional coverage for better understanding of the scenarios.

The Temporal Language is mainly built using the below concept:

-> Temporal expressions (TEs)
-> Temporal operators, for defining complex expressions.
-> Event struct members, for defining occurrences of events during the run.
-> Expect struct members, for checking temporal behavior

Accessing / Sampling the DUT signals using specman elite e-language

Specman elite e-language supports in driving or sampling
-> VHDL signals at any hierarchy level
-> Verilog registers and wires at any hierarchy level.
In order to access the DUT we need to use single quotes with '~' to denote top-level module name.
'~/instance HDL path /signal name‘
Ex:
‘~/top_tb/data_in’
Here the top_tb refers to the Top HDL module name and data_in refers to the signal name present in the top_tb module.
-> To Drive a Value from Specman elite e-language to DUT, apply the following mechanism.
‘~/top_tb/reset’ = 1;
-> To Sample a DUT value to Specman elite Variables ( Struct / Unit) , apply the following mechanism.
Packet_u.data_out = ‘~/top_tb/data_out”;