class DFF_TB(object):
def __init__(self, dut, init_val):
"""
Setup the testbench.
*init_val* signifies the ``BinaryValue`` which must be captured by the
output monitor with the first rising clock edge.
This must match the initial state of the D flip-flop in RTL.
"""
# Some internal state
self.dut = dut
self.stopped = False
# Create input driver and output monitor
self.input_drv = BitDriver(signal=dut.d,
clk=dut.c,
generator=input_gen())
self.output_mon = BitMonitor(name="output", signal=dut.q, clk=dut.c)
# Create a scoreboard on the outputs
self.expected_output = [init_val
] # a list with init_val as the first element
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
# Use the input monitor to reconstruct the transactions from the pins
# and send them to our 'model' of the design.
self.input_mon = BitMonitor(name="input",
signal=dut.d,
clk=dut.c,
callback=self.model)
def model(self, transaction):
"""Model the DUT based on the input *transaction*.
For a D flip-flop, what goes in at ``d`` comes out on ``q``,
so the value on ``d`` (put into *transaction* by our ``input_mon``)
can be used as expected output without change.
Thus we can directly append *transaction* to the ``expected_output`` list,
except for the very last clock cycle of the simulation
(that is, after ``stop()`` has been called).
"""
if not self.stopped:
self.expected_output.append(transaction)
def start(self):
"""Start generating input data."""
self.input_drv.start()
def stop(self):
"""Stop generating input data.
Also stop generation of expected output transactions.
One more clock cycle must be executed afterwards so that the output of
the D flip-flop can be checked.
"""
self.input_drv.stop()
self.stopped = True
class Thing:
def __init__(self, dut):
self.dut = dut
self.st_in = AvalonSTDriver(dut, 'st_in', dut.clk)
self.st_out = AvalonSTMonitor(dut, 'st_out', dut.clk)
self.csr = AvalonMaster(dut, 'csr', dut.clk)
self.st_in_recovered = AvalonSTMonitor(dut,
'st_in',
dut.clk,
callback=self.model)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.st_out, self.expected_output)
def model(self, transaction):
"""Model the DUT based on the input transaction."""
self.expected_output.append(transaction)
self.st_in_recovered.log.info(hexdump(transaction))
async def reset(self):
self.dut.reset <= 1
await Timer(50, units='us')
self.dut.reset <= 0
self.dut.st_out_ready <= 1
self.dut.reset._log.debug('Reset complete')
def __init__(self, dut):
"""
Setup testbench.
"""
# Some internal state
self.dut = dut
self.stopped = False
# Create input driver and output monitor
self.input_drv = BitDriver(dut.enable, dut.clk, input_gen())
dut.enable <= 0
self.output_mon = BitMonitor("output", dut.impulse, dut.clk)
# Create a scoreboard on the outputs
self.expected_output = [BinaryValue(0, 1)]
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.input_mon = BitMonitor("input",
dut.enable,
dut.clk,
callback=self.model)
# Model variables
self.triggered = False
self.counter = 0
class Thing:
"""Commmon test logic for all tests."""
def __init__(self, dut):
self.dut = dut
self.st_in = AvalonSTDriver(dut, 'st_in', dut.clk)
self.st_out = AvalonSTMonitor(dut, 'st_out', dut.clk)
self.csr = AvalonMaster(dut, 'csr', dut.clk)
self.st_in_recovered = AvalonSTMonitor(dut,
'st_in',
dut.clk,
callback=self.model)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.st_out, self.expected_output)
@staticmethod
async def new(dut):
# Ensure the bus is in a known and quiet state before starting the monitors
await Thing.reset(dut)
return Thing(dut)
@staticmethod
async def reset(dut):
dut.reset <= 1
await Timer(50, units='us')
dut.reset <= 0
dut.st_out_ready <= 1
dut.reset._log.debug('Reset complete')
def model(self, transaction):
"""Model the DUT based on the input transaction."""
self.expected_output.append(transaction)
self.st_in_recovered.log.info(hexdump(transaction))
def __init__(self, dut):
self.dut = dut
self.output_rx_mon = UartRxOMonitor(dut,
"o",
dut.clk,
int(self.dut.BAUD),
reset_n=dut.rstn)
self.input_rx_mon = UartRxMonitor(dut.i_rx,
dut.clk,
int(self.dut.BAUD),
reset_n=dut.rstn,
callback=self.rx_model)
self.output_expected = [{
"rx_data_valid": 0,
"rx_data": 0
}] # necessary because order of calls
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_rx_mon, self.output_expected)
self.output_rx_mon.log.setLevel(logging.INFO)
self.input_rx_mon.log.setLevel(logging.INFO)
self.dut._log.setLevel(logging.INFO)
self.scoreboard.log.setLevel(logging.INFO)
self.dut.i_rx <= 1
self.bits = 0
self.shift = 0
self.last_reset = False
def __init__(self, dut, init_val):
"""
Setup the testbench.
*init_val* signifies the ``BinaryValue`` which must be captured by the
output monitor with the first rising clock edge.
This must match the initial state of the D flip-flop in RTL.
"""
# Some internal state
self.dut = dut
self.stopped = False
# Create input driver and output monitor
self.input_drv = BitDriver(signal=dut.d,
clk=dut.c,
generator=input_gen())
self.output_mon = BitMonitor(name="output", signal=dut.q, clk=dut.c)
# Create a scoreboard on the outputs
self.expected_output = [init_val
] # a list with init_val as the first element
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
# Use the input monitor to reconstruct the transactions from the pins
# and send them to our 'model' of the design.
self.input_mon = BitMonitor(name="input",
signal=dut.d,
clk=dut.c,
callback=self.model)
async def test_tdata(dut, packets_num=5, packet_size=(10, 100), delay=-1, consecutive_transfers=0):
"""Test TDATA"""
tdata_width = dut.C_S_AXIS_TDATA_WIDTH.value.integer
axis_m = Axi4StreamMaster(dut, "s_axis", dut.aclk)
axis_s = Axi4StreamSlave(dut, "m_axis", dut.aclk, delay, consecutive_transfers)
axis_monitor = Axi4Stream(dut, "m_axis", dut.aclk, data_type="integer", packets=True)
await setup_dut(dut)
input = []
output = []
# Build the input and output packets
for i in range(packets_num):
input.append([randint(0, 2**tdata_width - 1) for i in range(randint(*packet_size))])
output.append([word ^ 2**tdata_width - 1 for word in input[-1]])
scoreboard = Scoreboard(dut)
scoreboard.add_interface(axis_monitor, output)
# Write the input packets
for packet in input:
await axis_m.write(packet)
# Wait until output is empty (so, all the packets have been received)
while output:
await RisingEdge(dut.aclk)
await RisingEdge(dut.aclk)
class AvalonSTTB(object):
"""Testbench for avalon basic stream"""
def __init__(self, dut):
self.dut = dut
self.clkedge = RisingEdge(dut.clk)
self.stream_in = AvalonSTDriver(self.dut, "asi", dut.clk)
self.stream_out = AvalonSTMonitor(self.dut, "aso", dut.clk)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(self.dut, fail_immediately=True)
self.expected_output = []
self.scoreboard.add_interface(self.stream_out, self.expected_output)
self.backpressure = BitDriver(self.dut.aso_ready, self.dut.clk)
@cocotb.coroutine
def initialise(self):
self.dut.reset <= 0
cocotb.fork(Clock(self.dut.clk, 10).start())
for _ in range(3):
yield self.clkedge
self.dut.reset <= 1
yield self.clkedge
@cocotb.coroutine
def send_data(self, data):
exp_data = struct.pack("B", data)
self.expected_output.append(exp_data)
yield self.stream_in.send(data)
def __init__(self, dut, codec, debug=False):
dut._log.info("Preparing tb for padder, codec={codec}")
self.dut = dut
self.codec = codec # sha_type_actual
self.sha = Sha.get_method(codec=codec)
self.s_axis = AXIS_Driver(dut, "s_axis", dut.axis_aclk)
self.backpressure = BitDriver(dut.m_axis_tready, dut.axis_aclk)
self.m_axis = AXIS_Monitor(dut, "m_axis", dut.axis_aclk)
self.expected_output = []
# Create a scoreboard on the m_axis bus
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.m_axis, self.expected_output)
# Reconstrut the input transactions
self.s_axis_recovered = AXIS_Monitor(dut,
"s_axis",
dut.axis_aclk,
callback=self.model)
level = logging.DEBUG if debug else logging.WARNING
self.s_axis.log.setLevel(level)
self.s_axis_recovered.log.setLevel(level)
class TB(object):
def __init__(self, dut):
# Some internal state
self.dut = dut
self.stopped = False
# Use the input monitor to reconstruct the transactions from the pins
# and send them to our 'model' of the design.
self.input_mon = BitMonitor(name="input", signal=dut.Zybo_Example_sw_in, clk=dut.clk,
callback=self.model)
# Create input driver and output monitor
self.input_drv = BitDriver(signal=dut.Zybo_Example_sw_in, clk=dut.clk, generator=input_gen())
self.output_mon = BitMonitor(name="output", signal=dut.Zybo_Example_leds_out, clk=dut.clk)
# Create a scoreboard on the outputs
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
def model(self, transaction):
if not self.stopped:
self.expected_output.append(transaction)
def start(self):
self.input_drv.start()
def stop(self):
self.input_drv.stop()
self.stopped = True
class Thing:
"""Commmon test logic for all tests."""
def __init__(self, dut):
self.dut = dut
# TODO: See https://github.com/cocotb/cocotb/issues/2051 for Verilator freeze bug
self.userrx = AvalonSTMonitor(dut, 'userrx', dut.rx_clk)
self.tx_csr = AvalonMaster(dut, 'tx_mm', dut.tx_clk)
self.rx_csr = AvalonMaster(dut, 'rx_mm', dut.rx_clk)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.userrx, self.expected_output)
@staticmethod
async def new(dut):
rx_clock = Clock(dut.rx_clk, 10, units='us')
tx_clock = Clock(dut.tx_clk, 10, units='us')
cocotb.fork(rx_clock.start())
cocotb.fork(tx_clock.start())
# Ensure the bus is in a known and quiet state before starting the monitors
await Thing.reset(dut)
return Thing(dut)
@staticmethod
async def reset(dut):
dut.reset <= 1
await Timer(30, units='us')
dut.reset <= 0
dut.avtx_ready <= 1
dut.reset._log.info('Reset complete')
def __init__(self, dut, debug=False):
self.dut = dut
self.stream_in = AvalonSTDriver(dut, "stream_in", dut.clk)
self.backpressure = BitDriver(self.dut.stream_out_ready, self.dut.clk)
self.stream_out = AvalonSTMonitor(
dut,
"stream_out",
dut.clk,
config={'firstSymbolInHighOrderBits': True})
self.csr = AvalonMaster(dut, "csr", dut.clk)
cocotb.fork(
stream_out_config_setter(dut, self.stream_out, self.stream_in))
# Create a scoreboard on the stream_out bus
self.pkts_sent = 0
self.expected_output = []
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.stream_in_recovered = AvalonSTMonitor(dut,
"stream_in",
dut.clk,
callback=self.model)
# Set verbosity on our various interfaces
level = logging.DEBUG if debug else logging.WARNING
self.stream_in.log.setLevel(level)
self.stream_in_recovered.log.setLevel(level)
def __init__(self, dut, init_val):
"""
Setup testbench.
init_val signifies the BinaryValue which must be captured by the
output monitor with the first risign edge. This is actually the initial
state of the flip-flop.
"""
# Some internal state
self.dut = dut
self.stopped = False
# Create input driver and output monitor
self.input_drv = BitDriver(dut.d, dut.c, input_gen())
self.output_mon = BitMonitor("output", dut.q, dut.c)
# Create a scoreboard on the outputs
self.expected_output = [ init_val ]
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.input_mon = BitMonitor("input", dut.d, dut.c,
callback=self.model)
def __init__(self, dut):
self.dut = dut
self.output_mon = UartTxOMonitor(dut,
"o",
dut.clk,
int(self.dut.BAUD),
reset_n=dut.rstn)
self.input_mon = UartTxIMonitor(dut,
"i",
dut.clk,
int(self.dut.BAUD),
reset_n=dut.rstn,
callback=self.tx_model)
self.input_drv = UartTxDriver(dut, "i", dut.clk) #initializer only
self.etx = BinaryValue(1)
self.eready = BinaryValue(0)
self.output_expected = [{
'tx': self.etx,
'ready': self.eready
}] #i don't think this should be necessary...
self.scoreboard = Scoreboard(dut)
#self.output_mon.log.setLevel(logging.DEBUG)
#scoreboard is where results are checked. On each transaction of the output_mon, it'll compare against the
#next transaction in the list output_expected. Output_expected gets updated by the tx_model. tx_model is the
#callback function of the input monitor. So the expected output gets appended to when the input changes.
# its not obvious if on the same simulation cycle you can force the tx_model to get called before the
# scoreboard gets called on
self.scoreboard.add_interface(self.output_mon, self.output_expected)
self.baud_rate = int(self.dut.BAUD) - 1
self.baud_count = 0
self.shifter = 0
def mean_mdv_test(dut):
""" Test using functional coverage measurements and
Constrained-Random mechanisms. Generates random transactions
until coverage defined in Driver reaches 100% """
dut_out = StreamBusMonitor(dut, "o", dut.clk)
dut_in = StreamBusDriver(dut, "i", dut.clk)
exp_out = []
scoreboard = Scoreboard(dut)
scoreboard.add_interface(dut_out, exp_out)
data_width = int(dut.DATA_WIDTH.value)
bus_width = int(dut.BUS_WIDTH.value)
dut._log.info('Detected DATA_WIDTH = %d, BUS_WIDTH = %d' %
(data_width, bus_width))
cocotb.fork(clock_gen(dut.clk, period=clock_period))
dut.rst <= 1
for i in range(bus_width):
dut.i_data[i] = 0
dut.i_valid <= 0
yield RisingEdge(dut.clk)
yield RisingEdge(dut.clk)
dut.rst <= 0
coverage1_hits = []
coverageN_hits = []
#define a constraint function, which prevents from picking already covered data
def data_constraint(data):
return (not data[0] in coverage1_hits) & (not data[bus_width - 1]
in coverageN_hits)
coverage = 0
xaction = StreamTransaction(bus_width, data_width)
while coverage < 100:
#randomize without constraint
#xaction.randomize()
#randomize with constraint
if not "top.data1" in cocotb.coverage.coverage_db:
xaction.randomize()
else:
coverage1_new_bins = cocotb.coverage.coverage_db[
"top.data1"].new_hits
coverageN_new_bins = cocotb.coverage.coverage_db[
"top.dataN"].new_hits
coverage1_hits.extend(coverage1_new_bins)
coverageN_hits.extend(coverageN_new_bins)
xaction.randomize_with(data_constraint)
yield dut_in.send(xaction)
exp_out.append(xaction.mean_value())
coverage = cocotb.coverage.coverage_db[
"top"].coverage * 100 / cocotb.coverage.coverage_db["top"].size
dut._log.info("Current Coverage = %d %%", coverage)
class HashEngineTB(object):
def __init__(self, dut, codec, debug=False):
dut._log.info(
f"Preparing tb for hashing-engine, codec={Sha.resolve_name(codec)}"
)
self.dut = dut
self.codec = codec # sha_type_actual
self.sha = Sha.get_method(codec)
self.s_axis = AXIS_Driver(dut, "s_axis", dut.axis_aclk)
self.backpressure = BitDriver(dut.m_axis_tready, dut.axis_aclk)
self.m_axis = AXIS_Monitor(dut, "m_axis", dut.axis_aclk)
self.expected_output = []
# Create a scoreboard on the m_axis bus
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.m_axis, self.expected_output)
# Reconstrut the input transactions
self.s_axis_recovered = AXIS_Monitor(dut,
"s_axis",
dut.axis_aclk,
callback=self.model)
level = logging.DEBUG if debug else logging.WARNING
self.s_axis.log.setLevel(level)
self.s_axis_recovered.log.setLevel(level)
async def reset(self, duration=2):
self.dut._log.debug("Resetting DUT")
self.dut.axis_resetn <= 0
await Timer(duration, units='ns')
await RisingEdge(self.dut.axis_aclk)
self.dut.axis_resetn <= 1
self.dut._log.debug("Out of reset")
def model(self, transaction):
message = transaction['data']
self.dut._log.debug(f'Incoming message={message}')
self.dut._log.debug(f'Length={len(message)}')
# sha = hashlib.sha256()
# sha.update(message)
# digest = sha.digest()
self.sha.init()
self.sha.padder(message)
self.sha.wt_transaction()
digest = self.sha.digest()
self.expected_output.append({
'data':
digest,
'user':
80 * '0' + little_endian_codec(self.codec) + 32 * '0'
})
class DspBlockTB(object):
def __init__(self, dut, debug=False):
self.dut = dut
self.stream_in = STDriver(dut,
"ValNamein_0",
dut.clock,
name_map=axi4stream_chisel_name_map)
self.backpressure = BitDriver(self.dut.out_0_ready, self.dut.clock)
self.stream_out = STMonitor(dut,
"out_0",
dut.clock,
name_map=axi4stream_chisel_name_map)
self.csr = MemMaster(dut,
"ValNameioMem_0",
dut.clock,
name_map=axi4_chisel_name_map)
self.set_rotation(0)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.stream_in_recovered = STMonitor(
dut,
"ValNamein_0",
dut.clock,
callback=self.model,
name_map=axi4stream_chisel_name_map)
# Create a scoreboard on the stream_out bus
self.pkts_sent = 0
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
# Set verbosity on our various interfaces
level = logging.DEBUG if debug else logging.WARNING
self.stream_in.log.setLevel(level)
self.stream_in_recovered.log.setLevel(level)
def set_rotation(self, rotation):
self.rotation = rotation
return self.csr.write(0, self.rotation)
def model(self, transaction):
"""Model the DUT based on the input transaction"""
## TODO apply rotation
self.expected_output.append(transaction)
self.pkts_sent += 1
@cocotb.coroutine
def reset(self, duration=10):
self.dut._log.debug("Resetting DUT")
self.dut.reset <= 1
self.stream_in.bus.TVALID <= 0
yield Timer(duration, units='ns')
yield RisingEdge(self.dut.clock)
self.dut.reset <= 0
self.dut._log.debug("Out of reset")
def __init__(self, dut):
self.dut = dut
self.tlp_tx_st = AvalonSTMonitor(dut, 'tlp_tx_multiplexer_out', dut.clk)
self.tlp_tx_recovered = AvalonSTMonitor(dut, 'tlp_tx_multiplexer_out', dut.clk,
callback=self.tx_model)
self.csr = AvalonMaster(dut, 'csr', dut.clk)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.tlp_tx_st, self.expected_output)
def __init__(self, dut, debug: bool = False):
self._dut = dut
self._fft_in = DecoupledDriver(self._dut, "in", self._dut.clock)
self._fft_mon = FFTMonitor(self._dut, self._dut.clock)
self._backpressure = BitDriver(self._dut.out_ready, self._dut.clock)
self._scoreboard = Scoreboard(self._dut)
self._scoreboard.add_interface(self._fft_mon._mon_out,
self._fft_mon._expected_output)
def __init__(self, dut):
self.dut = dut
# TODO: See https://github.com/cocotb/cocotb/issues/2051 for Verilator freeze bug
self.userrx = AvalonSTMonitor(dut, 'userrx', dut.rx_clk)
self.tx_csr = AvalonMaster(dut, 'tx_mm', dut.tx_clk)
self.rx_csr = AvalonMaster(dut, 'rx_mm', dut.rx_clk)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.userrx, self.expected_output)
class axistream_fifo_TB(object):
def __init__(self, dut):
self.dut = dut
self.stream_in = AXI4ST_driver(dut, "stream_in", dut.clk)
#self.stream_in.log.setLevel(logging.DEBUG)
self.stream_out = AXI4STMonitor(dut,
"stream_out",
dut.clk,
callback=self.print_trans)
self.expected_output = []
self.overrideModel = False # temp help to differentiate scapy to other send
self.scoreboard = Scoreboard(dut, fail_immediately=False)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
self.stream_in_recovered = AXI4STMonitor(dut,
"stream_in",
dut.clk,
callback=self.model)
def print_trans(self, transaction):
# pkt = BinaryValue_to_scapy(transaction)
print("received transaction {}".format(transaction))
# pkt_buf = scapy_to_BinaryValue(pkt)
# print("from packet {}".format(pkt_buf))
# pkt.display()
def model(self, transaction):
""" Model the expected output based on input
"""
if not self.overrideModel:
self.expected_output.append(transaction)
def send(self, pkt):
if isinstance(pkt, scapy_pkt):
self.overrideModel = True
self.expected_output.append(scapy_to_BinaryValue(pkt))
self.stream_in.append(pkt)
self.overrideModel = False
@cocotb.coroutine
def async_rst(self):
""" This function execute the reset_n for 40ns
it also set all input signals to default value
"""
self.dut._log.info("begin Rst")
self.dut.reset_n <= 0
self.dut.stream_in_tdata <= 0
self.dut.stream_in_tlast <= 0
self.dut.stream_in_tvalid <= 0
self.dut.stream_out_tready <= 0
yield Timer(40, 'ns')
self.dut.reset_n <= 1
yield Timer(15, 'ns')
self.dut._log.info("end Rst")
class PadderTB(object):
def __init__(self, dut, codec, debug=False):
dut._log.info("Preparing tb for padder, codec={codec}")
self.dut = dut
self.codec = codec # sha_type_actual
self.sha = Sha.get_method(codec=codec)
self.s_axis = AXIS_Driver(dut, "s_axis", dut.axis_aclk)
self.backpressure = BitDriver(dut.m_axis_tready, dut.axis_aclk)
self.m_axis = AXIS_Monitor(dut, "m_axis", dut.axis_aclk)
self.expected_output = []
# Create a scoreboard on the m_axis bus
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.m_axis, self.expected_output)
# Reconstrut the input transactions
self.s_axis_recovered = AXIS_Monitor(dut,
"s_axis",
dut.axis_aclk,
callback=self.model)
level = logging.DEBUG if debug else logging.WARNING
self.s_axis.log.setLevel(level)
self.s_axis_recovered.log.setLevel(level)
async def reset(self, duration=2):
self.dut._log.debug("Resetting DUT")
self.dut.axis_resetn <= 0
await Timer(duration, units='ns')
await RisingEdge(self.dut.axis_aclk)
self.dut.axis_resetn <= 1
self.dut._log.debug("Out of reset")
def model(self, transaction):
message = transaction['data']
self.dut._log.debug(f'Incoming message={message}')
self.dut._log.debug(f'Length={len(message)}')
self.sha.init()
message = self.sha.padder(message)
self.expected_output.append({
'data':
message,
'user':
80 * '0' + little_endian_codec(self.codec) + 32 * '0'
})
while message:
self.dut._log.debug("Message block to be received: {}".format(
message[0:DATA_BYTE_WIDTH]))
message = message[DATA_BYTE_WIDTH:]
class DigestTB(object):
def __init__(self, dut, codec, debug=False):
self.dut = dut
self.codec = codec
self.sha = Sha.get_method(codec)
self.dut._log.info("Configure driver, monitors and scoreboard")
self.s_axis = AXIS_Driver(dut,
"s_axis",
dut.axis_aclk,
lsb_first=False)
self.backpressure = BitDriver(dut.m_axis_tready, dut.axis_aclk)
self.m_axis = AXIS_Monitor(dut, "m_axis", dut.axis_aclk)
self.expected_output = []
# Create a scoreboard on the m_axis bus
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.m_axis, self.expected_output)
# Reconstrut the input transactions
self.s_axis_recovered = AXIS_Monitor(dut,
"s_axis",
dut.axis_aclk,
callback=self.model,
lsb_first=False)
level = logging.DEBUG if debug else logging.WARNING
self.s_axis.log.setLevel(level)
self.s_axis_recovered.log.setLevel(level)
async def reset(self, duration=2):
self.dut._log.debug("Resetting DUT")
self.dut.axis_resetn <= 0
await Timer(duration, units='ns')
await RisingEdge(self.dut.axis_aclk)
self.dut.axis_resetn <= 1
self.dut._log.debug("Out of reset")
def model(self, transaction):
message = transaction['data']
#print(f'Transaction = {transaction}')
print(message)
self.sha.init()
digest = self.sha.digest(message)
self.expected_output.append({
'data':
digest,
'user':
80 * '0' + little_endian_codec(self.codec) + 32 * '0'
})
def __init__(self, dut):
self.dut = dut
self.st_in = AvalonSTDriver(dut, 'st_in', dut.clk)
self.st_out = AvalonSTMonitor(dut, 'st_out', dut.clk)
self.csr = AvalonMaster(dut, 'csr', dut.clk)
self.st_in_recovered = AvalonSTMonitor(dut,
'st_in',
dut.clk,
callback=self.model)
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.st_out, self.expected_output)
def __init__(self, dut):
self.dut = dut
self.stream_in = AXI4ST(dut, "stream_in", dut.clk)
self.stream_out = AXI4STMonitor(dut, "stream_out", dut.clk,
callback=self.print_trans)
self.expected_output = []
self.scoreboard = Scoreboard(dut, fail_immediately=True)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
self.stream_in_recovered = AXI4STMonitor(dut, "stream_in", dut.clk,
callback=self.model)
self.stream_in_recovered.log.setLevel(30)
self.stream_out.log.setLevel(30)
def __init__(self, dut):
self.dut = dut
self.clkedge = RisingEdge(dut.clk)
self.stream_in = AvalonSTDriver(self.dut, "asi", dut.clk)
self.stream_out = AvalonSTMonitor(self.dut, "aso", dut.clk)
self.scoreboard = Scoreboard(self.dut, fail_immediately=True)
self.expected_output = []
self.scoreboard.add_interface(self.stream_out, self.expected_output)
self.backpressure = BitDriver(self.dut.aso_ready, self.dut.clk)
class EndianSwapperTB(object):
def __init__(self, dut, debug=False):
self.dut = dut
self.stream_in = AvalonSTDriver(dut, "stream_in", dut.clk)
self.backpressure = BitDriver(self.dut.stream_out_ready, self.dut.clk)
self.stream_out = AvalonSTMonitor(
dut,
"stream_out",
dut.clk,
config={'firstSymbolInHighOrderBits': True})
self.csr = AvalonMaster(dut, "csr", dut.clk)
cocotb.fork(
stream_out_config_setter(dut, self.stream_out, self.stream_in))
# Create a scoreboard on the stream_out bus
self.pkts_sent = 0
self.expected_output = []
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.stream_in_recovered = AvalonSTMonitor(dut,
"stream_in",
dut.clk,
callback=self.model)
# Set verbosity on our various interfaces
level = logging.DEBUG if debug else logging.WARNING
self.stream_in.log.setLevel(level)
self.stream_in_recovered.log.setLevel(level)
def model(self, transaction):
"""Model the DUT based on the input transaction"""
self.expected_output.append(transaction)
self.pkts_sent += 1
async def reset(self, duration=20):
self.dut._log.debug("Resetting DUT")
self.dut.reset_n <= 0
self.stream_in.bus.valid <= 0
await Timer(duration, units='ns')
await RisingEdge(self.dut.clk)
self.dut.reset_n <= 1
self.dut._log.debug("Out of reset")
class HcuTb(object):
def __init__(self, dut, codec, debug=False):
dut._log.info(f"Setting up test bench object with codec={codec}")
self.dut = dut
self.codec = codec
self.sha = Sha.get_method(codec=codec)
self.dut._log.info(f"Configure driver, monitors and scoreboard for {self.sha.sha_name}")
self.s_axis = AXIS_Driver(dut, "s_axis", dut.axis_aclk, lsb_first=False)
self.m_axis = AXIS_Monitor(dut, "m_axis", dut.axis_aclk, lsb_first=False)
self.expected_output = []
# Create a scoreboard on the m_axis bus
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.m_axis, self.expected_output)
# Reconstrut the input transactions
self.s_axis_recovered = AXIS_Monitor(dut, "s_axis", dut.axis_aclk, callback=self.model, lsb_first=False)
level = logging.DEBUG if debug else logging.WARNING
self.s_axis.log.setLevel(level)
self.s_axis_recovered.log.setLevel(level)
async def reset(self,duration = 2):
self.dut._log.debug("Resetting DUT")
self.dut.axis_resetn <= 0
await Timer(duration, units='ns')
await RisingEdge(self.dut.axis_aclk)
self.dut.axis_resetn <= 1
self.dut._log.debug("Out of reset")
def model(self, transaction):
self.dut._log.debug(f'Transaction = {transaction}')
message = transaction['data']
# print(f'Length or received tansaction = {len(message)}')
self.sha.init()
words_block = self.sha.wt_iters
while(message):
for i in range(words_block):
# print(f'Word to unpack: {message[i*BYTE_WIDTH_WORDS:(i+1)*BYTE_WIDTH_WORDS]}')
w_temp, = struct.unpack('!Q', message[i*BYTE_WIDTH_WORDS:(i+1)*BYTE_WIDTH_WORDS])
self.sha.update(w_temp)
message = message[BYTE_WIDTH_WORDS*words_block:]
self.dut._log.debug(f'Hash Computed = {[hex(reg) for reg in self.sha.get_hash()]}')
self.expected_output.append({'data': self.sha.get_bytes_hash(), 'user':80*'0'+little_endian_codec(self.codec)+32*'0'})
def __init__(self, dut, clkperiod=6.4):
self.dut = dut
dut._discover_all() # scan all signals on the design
dut._log.setLevel(30)
fork(Clock(dut.clk, clkperiod, 'ns').start())
self.payload_in = AXI4STPKts(dut, "payload_in", dut.clk)
self.stream_out = AXI4STMonitor(dut,
"packet_out",
dut.clk,
callback=self.print_trans)
self.scoreboard = Scoreboard(dut, fail_immediately=False)
self.expected_output = []
self.scoreboard.add_interface(self.stream_out, self.expected_output)
self.nb_frame = 0
self.packet = BinaryValue()
def __init__(self, dut):
self.dut = dut
# Reconstruct the input transactions from the pins
# and send them to our 'model'
input_mon = InputMonitor("input",
dut.A,
dut.B,
dut.clk,
callback=self.adder_modelD)
# Output monitor
self.output_mon = OutMonitor("output", dut.X, dut.clk)
# Create a scoreboard on the outputs
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
class Testbench(object): def __init__(self, dut): self.dut = dut self.stopped = False elements = dut.ELEMENTS.value; self.lru = LeastRecentlyUsedDict(size_limit=elements) # initial state of LRU list for keyin in range(elements-1, -1, -1): self.lru[keyin] = 1 init_val = elements-1 self.input_drv = InputDriver(dut) self.output_mon = OutputMonitor(dut) # Create a scoreboard on the outputs self.expected_output = [ init_val ] self.scoreboard = Scoreboard(dut) self.scoreboard.add_interface(self.output_mon, self.expected_output) # Reconstruct the input transactions from the pins # and send them to our 'model' self.input_mon = InputMonitor(dut, callback=self.model) def model(self, transaction): '''Model the DUT based on the input transaction.''' insert, free, keyin = transaction #print "=== model called with stopped=%r, Insert=%d, Free=%d, KeyIn=%d" % (self.stopped, insert, free, keyin) if not self.stopped: if insert == 1: self.lru[keyin] = 1 elif free == 1: self.lru.moveLRU(keyin) #print "=== model: lru=%s" % self.lru.items() keyout = self.lru.iterkeys().next() #print "=== model: KeyOut=%d" % keyout self.expected_output.append(keyout) def stop(self): """ Stop generation of expected output transactions. One more clock cycle must be executed afterwards, so that, output of D-FF can be checked. """ self.stopped = True
class DFF_TB(object):
def __init__(self, dut, init_val):
"""
Setup testbench.
init_val signifies the BinaryValue which must be captured by the
output monitor with the first risign edge. This is actually the initial
state of the flip-flop.
"""
# Some internal state
self.dut = dut
self.stopped = False
# Create input driver and output monitor
self.input_drv = BitDriver(dut.d, dut.c, input_gen())
self.output_mon = BitMonitor("output", dut.q, dut.c)
# Create a scoreboard on the outputs
self.expected_output = [ init_val ]
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.output_mon, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.input_mon = BitMonitor("input", dut.d, dut.c,
callback=self.model)
def model(self, transaction):
"""Model the DUT based on the input transaction."""
# Do not append an output transaction for the last clock cycle of the
# simulation, that is, after stop() has been called.
if not self.stopped:
self.expected_output.append(transaction)
def start(self):
"""Start generation of input data."""
self.input_drv.start()
def stop(self):
"""
Stop generation of input data.
Also stop generation of expected output transactions.
One more clock cycle must be executed afterwards, so that, output of
D-FF can be checked.
"""
self.input_drv.stop()
self.stopped = True
class EndianSwapperTB(object):
def __init__(self, dut, debug=False):
self.dut = dut
self.stream_in = AvalonSTDriver(dut, "stream_in", dut.clk)
self.backpressure = BitDriver(self.dut.stream_out_ready, self.dut.clk)
self.stream_out = AvalonSTMonitor(dut, "stream_out", dut.clk,
config={'firstSymbolInHighOrderBits':
True})
self.csr = AvalonMaster(dut, "csr", dut.clk)
cocotb.fork(stream_out_config_setter(dut, self.stream_out,
self.stream_in))
# Create a scoreboard on the stream_out bus
self.pkts_sent = 0
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.stream_in_recovered = AvalonSTMonitor(dut, "stream_in", dut.clk,
callback=self.model)
# Set verbosity on our various interfaces
level = logging.DEBUG if debug else logging.WARNING
self.stream_in.log.setLevel(level)
self.stream_in_recovered.log.setLevel(level)
def model(self, transaction):
"""Model the DUT based on the input transaction"""
self.expected_output.append(transaction)
self.pkts_sent += 1
@cocotb.coroutine
def reset(self, duration=10000):
self.dut._log.debug("Resetting DUT")
self.dut.reset_n <= 0
self.stream_in.bus.valid <= 0
yield Timer(duration)
yield RisingEdge(self.dut.clk)
self.dut.reset_n <= 1
self.dut._log.debug("Out of reset")
def mean_randomised_test(dut):
""" Test mean of random numbers multiple times """
# dut_in = StreamBusMonitor(dut, "i", dut.clk) # this doesn't work:
# VPI Error vpi_get_value():
# ERROR - Cannot get a value for an object of type vpiArrayVar.
dut_out = StreamBusMonitor(dut, "o", dut.clk)
exp_out = []
scoreboard = Scoreboard(dut)
scoreboard.add_interface(dut_out, exp_out)
data_width = int(dut.DATA_WIDTH.value)
bus_width = int(dut.BUS_WIDTH.value)
dut._log.info('Detected DATA_WIDTH = %d, BUS_WIDTH = %d' %
(data_width, bus_width))
cocotb.fork(clock_gen(dut.clk, period=clock_period))
dut.rst <= 1
for i in range(bus_width):
dut.i_data[i] = 0
dut.i_valid <= 0
yield RisingEdge(dut.clk)
yield RisingEdge(dut.clk)
dut.rst <= 0
for j in range(10):
nums = []
for i in range(bus_width):
x = random.randint(0, 2**data_width - 1)
dut.i_data[i] = x
nums.append(x)
dut.i_valid <= 1
nums_mean = sum(nums) // bus_width
exp_out.append(nums_mean)
yield RisingEdge(dut.clk)
dut.i_valid <= 0
def __init__(self, dut): self.dut = dut self.stopped = False elements = dut.ELEMENTS.value; self.lru = LeastRecentlyUsedDict(size_limit=elements) # initial state of LRU list for keyin in range(elements-1, -1, -1): self.lru[keyin] = 1 init_val = elements-1 self.input_drv = InputDriver(dut) self.output_mon = OutputMonitor(dut) # Create a scoreboard on the outputs self.expected_output = [ init_val ] self.scoreboard = Scoreboard(dut) self.scoreboard.add_interface(self.output_mon, self.expected_output) # Reconstruct the input transactions from the pins # and send them to our 'model' self.input_mon = InputMonitor(dut, callback=self.model)
def __init__(self, dut, debug=False):
self.dut = dut
self.stream_in = AvalonSTDriver(dut, "stream_in", dut.clk)
self.backpressure = BitDriver(self.dut.stream_out_ready, self.dut.clk)
self.stream_out = AvalonSTMonitor(dut, "stream_out", dut.clk,
config={'firstSymbolInHighOrderBits':
True})
self.csr = AvalonMaster(dut, "csr", dut.clk)
cocotb.fork(stream_out_config_setter(dut, self.stream_out,
self.stream_in))
# Create a scoreboard on the stream_out bus
self.pkts_sent = 0
self.expected_output = []
self.scoreboard = Scoreboard(dut)
self.scoreboard.add_interface(self.stream_out, self.expected_output)
# Reconstruct the input transactions from the pins
# and send them to our 'model'
self.stream_in_recovered = AvalonSTMonitor(dut, "stream_in", dut.clk,
callback=self.model)
# Set verbosity on our various interfaces
level = logging.DEBUG if debug else logging.WARNING
self.stream_in.log.setLevel(level)
self.stream_in_recovered.log.setLevel(level)
