Simulation Libraries

Several simulation libraries are available for use in your testbenches, in the form of SystemVerilog packages, classes, and interfaces. The bus functional models (BFM) are implemented as SystemVerilog classes and use SystemVerilog interfaces to connect to your device under test (DUT). These classes provide member functions and tasks for communicating with the BFMs.

A few commonly used SystemVerilog packages are described below. See each package file for additional documentation.

PktTestExec

PktTestExec.sv contains utilities for testbench reporting, assertions, and simulation timeouts. The associated header file, test_exec.svh, contains macros for use with PkgTestExec. These macros are used to implement SystemVerilog assertions. The header also defines timeunit and timeprecision.

Note: The timeunit must be 1ns in order for PkgTestExec to use and report times correctly.

PkgTestExec Tasks and Functions

Below are some of the methods available in PkgTestExec. See PkgTestExec.sv for additional documentation.

start_tb(string tb_name, realtime time_limit = 10ms)
Called at the start of the testbench. A time limit can be specified to prevent the testbench from never ending.
end_tb(bit finish = 1)
Called at the end of the testbench. Displays final results and optionally calls $finish.
start_test(string test_name, realtime time_limit = 0)
Called at the start of a test. A time limit can be given to cause an error if the test takes longer than expected or never ends.
end_test(int test_result = 1)
Called at the end of a test. A pass (1) or fail (0) can be passed to indicate if the test passed or failed. Any failed assertion, using the test_exec.svh macros, will also be considered when deciding if the test passed or failed. If any fatal or error assertions failed during the test then it will be considered to have failed.
start_timeout(
    output timeout_t  handle,
    input  realtime   timeout_delay,
    input  string     message = "Timeout",
    input  severity_t severity = SEV_ERROR)
Called to start a timeout countdown. If the timeout is not ended before the indicated simulation time elapses then an assertion of the given severity will be thrown. This is very useful for ensuring that tests complete in a timely manner and to report which timeout was exceeded.
end_timeout(timeout_t handle)
Called to end a timeout countdown when it is no longer needed.

Macros

The following macros are defined in test_exec.svh. These update internal variables to track the state of the testbench and to report the final results.

ASSERT_FATAL(EXPR, MESSAGE)
Encapsulates a SystemVerilog $assert with a $fatal severity.
ASSERT_ERROR(EXPR, MESSAGE)
Encapsulates a SystemVerilog $assert with a $error severity.
ASSERT_WARNING(EXPR, MESSAGE)
Encapsulates a SystemVerilog $assert with a $warning severity.
ASSERT_INFO(EXPR, MESSAGE)
Encapsulates a SystemVerilog $assert with an $info severity.

Where:

EXPR is the condition for the assertion (what you expect to be true)
MESSAGE is the message string to report if the assertion fails

PkgChdrUtils

The PkgChdrUtils package includes various definitions and functions for interacting with the RFNoC network protocol, called the Condensed Hierarchical Datagram for RFNoC (CHDR). See PkgChdrUtils.sv for additional documentation.

PkgChdrData

The PkgChdrData package contains the CHDR and item data types, as well as utilities, that are useful for interacting with RFNoC data. An item refers to an RF data sample or whatever unit of data an RFNoC block expects.

For example, the CHDR protocol data word type (chdr_word_t) and the RF sample data type (item_t) can be defined using the following example:

localparam CHDR_W = 64;    // CHDR bus width
localparam ITEM_W = 32;    // RF data sample size (sc16)
typedef ChdrData #(CHDR_W, ITEM_W)::chdr_word_t chdr_word_t;
typedef ChdrData #(CHDR_W, ITEM_W)::item_t      item_t;

SystemVerilog queues are used to store CHDR words and data samples. A queue of CHDR words or data samples can be reorganized into queues of different data widths using the following example:

chdr_word_t chdr_words[$];  // Queue of CHDR packet words
item_t      samples[$];     // Queue of RF data samples
logic [7:0] bytes[$];       // Queue of bytes

// Convert the CHDR words to samples
samples = ChdrData#(CHDR_W, ITEM_W)::chdr_to_item(chdr_words);

// Convert the samples to CHDR words
chdr_words = ChdrData#(CHDR_W, ITEM_W)::item_to_chdr(samples);

// Convert the samples to a queue of bytes
bytes = ChdrData#(ITEM_W, 8)::chdr_to_item(samples);

// Convert the bytes to a queue of samples
bytes = ChdrData#(ITEM_W, 8)::item_to_chdr(samples);

PkgRfnocBlockCtrlBfm

The PkgRfnocBlockCtrlBfm package contains the RfnocBlockCtrlBfm bus functional model (BFM) used to emulate a software block controller for an RFNoC block. This is the BFM used to interact with an RFNoC block in simulation. See the \ref md_usrp3_sim_writing_sim_top "testbench example" for an example of how to instantiate and connect the BFM to your DUT.

To be used, the BFM must be connected to the RFNoC block using an RfnocBackendIf interface for the RFNoC backend interface and AxiStreamIf interfaces for the AXIS-CHDR ports.

Once connected, several member functions are available through the BFM. A few examples are shown below, but many more are available. Refer to PkgRfnocBlockCtrlBfm.sv for additional documentation.

RfnocBlockCtrlBfm::run()
Start the BFMs running. This should be called at the start of the testbench after start_tb() and before the BFM is used.
RfnocBlockCtrlBfm::reg_read(input ctrl_address_t addr, output ctrl_word_t word)
Read a register from the RFNoC block.
RfnocBlockCtrlBfm::reg_write(ctrl_address_t addr, ctrl_word_t word)
Write to a register on the RFNoC block.
send_items(int port, item_t items[$], chdr_word_t metadata[$] = {}, packet_info_t pkt_info = 0)
Enqueue a packet of samples (or other data items) to be sent by the BFM to the RFNoC block on the indicated block port.
recv(int port, output chdr_word_t data[$], output int data_bytes)
Recv a packet of samples (or other data items) from the indicated port on the RFNoC block.
set_master_stall_prob(int stall_probability = DEF_STALL_PROB)
Set the probability, as value from 0-100, of the BFM's AXI-Stream master stalling (deasserting TVALID) between transfers.
set_slave_stall_prob(int stall_probability = DEF_STALL_PROB)
Set the probability, as value from 0-100, of the BFM's AXI-Stream slave stalling (deasserting TREADY) on a given clock cycle.

The level of push-back on the flow control used by the AXI-Stream interfaces of the BFM are controlled by setting a probability. This allows you to easily test underflow and overflow tolerance in your testbenches.

Low-level tasks and functions are also available for inputting raw packets directly.

sim_clock_gen

The sim_clock_gen module makes it easy create clocks and synchronous resets, and to interact with them. See sim_clock_gen.sv for additional documentation.

Some features include:

Start and stop the clock
Change the frequency
Change the duty cycle
Kill the clock (prevent any new simulation events)
Wait for \em n rising/falling clock edges

PkgAxiStream

The PkgAxiStreamBfm package contains the AxistreamPacket and AxiStreamBfm classes which are used to model AXI4-Stream interfaces in the testbenches. AxiStreamIf is the interface used for AXI-Stream. The RFNoC CHDR BFMs inherit from AxiStreamBfm in order to implement the AXI-Stream interfaces used by RFNoC.

The AXI-Stream BFMs provide typical SystemVerilog put(), get(), try_put(), and try_get() tasks and functions for interacting with the models. Many other useful functions are also available. See the package file for details.

8.1 KiB Raw Permalink Blame History