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”;

specman elite e-language supports creation of Bus Functional Module (BFM)

Specman elite e-language supports the creation of Bus Functional Module , Popularly known as BFM.
In order to construct BFM targeting the DUT (Design Under Test), we need to use e-language Temporal Expressions using the concept of TCM ( Time Consuming Methods).
The TCM is similar to Methods , but supported with the events and other Temporal related expressions like wait, sync...
The Initial TCM needs to be started to execute the defined functionality ( which in turn may call / start other dependent TCM's).
e.g
<'
unit packet_bfm_u {
// definition of fields
// Declaration of TCM
packet_gen() @clk_rise is {
// Apply the packet generation functionality
} ; // end of TCM def

run() is also {
// start the TCM
start packet_gen();
};
'>