bslathi19/taxi
1
0
Fork 0
mirror of https://github.com/fpganinja/taxi.git synced 2026-08-29 08:05:00 -07:00
Code Issues Packages Projects Releases Wiki Activity

axi: Update testbenches to use cocotb.parametrize

Browse Source 
Signed-off-by: Alex Forencich <alex@alexforencich.com>
This commit is contained in:
Alex Forencich
2026-08-14 22:35:12 -07:00
parent 0769fcfce6
commit c9c5ef1995
20 changed files with 603 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
src/axi/tb/taxi_axi_adapter/test_taxi_axi_adapter.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -65,7 +64,25 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -167,30 +195,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

58
src/axi/tb/taxi_axi_axil_adapter/test_taxi_axi_axil_adapter.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiLiteBus, AxiMaster, AxiLiteRam
@@ -65,7 +64,25 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -167,30 +195,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

72
src/axi/tb/taxi_axi_crossbar/test_taxi_axi_crossbar.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -75,7 +74,32 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
s_count = 1
m_count = 1
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axi)
m_count = len(cocotb.top.m_axi)
data_width = len(cocotb.top.s_axi[0].wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
tb = TB(dut)
@@ -111,7 +135,15 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
tb = TB(dut)
@@ -143,6 +175,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -180,35 +217,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axi)
m_count = len(cocotb.top.m_axi)
data_w = len(cocotb.top.s_axi[0].wdata)
byte_lanes = data_w // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("s", range(min(s_count, 2)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

66
src/axi/tb/taxi_axi_crossbar_1s/test_taxi_axi_crossbar_1s.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -73,7 +72,29 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
m_count = 1
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axi)
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
tb = TB(dut)
@@ -109,7 +130,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
tb = TB(dut)
@@ -141,6 +169,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -178,33 +211,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axi)
data_w = len(cocotb.top.s_axi.wdata)
byte_lanes = data_w // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

73
src/axi/tb/taxi_axi_dp_ram/test_taxi_axi_dp_ram.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster
@@ -69,7 +68,26 @@ class TB(object):
await RisingEdge(self.dut.a_clk)
async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi_a.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("port", [0, 1]),
)
async def run_test_write(dut, port=0, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -103,7 +121,14 @@ async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpres
await RisingEdge(dut.a_clk)
async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("port", [0, 1]),
)
async def run_test_read(dut, port=0, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -135,7 +160,12 @@ async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpress
await RisingEdge(dut.a_clk)
async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_arb(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -164,6 +194,11 @@ async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inser
await RisingEdge(dut.a_clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -200,36 +235,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.a_clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi_a.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("port", [0, 1])
factory.generate_tests()
factory = TestFactory(run_test_arb)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

58
src/axi/tb/taxi_axi_fifo/test_taxi_axi_fifo.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -65,7 +64,25 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -168,30 +196,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

72
src/axi/tb/taxi_axi_interconnect/test_taxi_axi_interconnect.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -69,7 +68,32 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
s_count = 1
m_count = 1
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axi)
m_count = len(cocotb.top.m_axi)
data_width = len(cocotb.top.s_axi[0].wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
tb = TB(dut)
@@ -105,7 +129,15 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0):
tb = TB(dut)
@@ -137,6 +169,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -174,35 +211,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axi)
m_count = len(cocotb.top.m_axi)
data_w = len(cocotb.top.s_axi[0].wdata)
byte_lanes = data_w // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("s", range(min(s_count, 2)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

66
src/axi/tb/taxi_axi_interconnect_1s/test_taxi_axi_interconnect_1s.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -67,7 +66,29 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
m_count = 1
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axi)
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
tb = TB(dut)
@@ -103,7 +124,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0):
tb = TB(dut)
@@ -135,6 +163,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -172,33 +205,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axi)
data_w = len(cocotb.top.s_axi.wdata)
byte_lanes = data_w // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

58
src/axi/tb/taxi_axi_ram/test_taxi_axi_ram.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster
@@ -59,7 +58,25 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -92,7 +109,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -123,6 +146,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -159,30 +187,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

60
src/axi/tb/taxi_axi_register/test_taxi_axi_register.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiMaster, AxiRam
@@ -65,7 +64,25 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
max_burst_size = 0
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("size", [None]+list(range(max_burst_size))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None):
tb = TB(dut)
@@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -161,36 +189,12 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
workers.append(cocotb.start_soon(worker(tb.axi_master, k*0x1000, 0x1000, count=16)))
while workers:
await workers.pop(0)
await workers.pop(0).join()
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
data_width = len(cocotb.top.s_axi.wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

38
src/axi/tb/taxi_axil_adapter/test_taxi_axil_adapter.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -65,7 +64,16 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -159,20 +177,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read, run_stress_test]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

38
src/axi/tb/taxi_axil_apb_adapter/test_taxi_axil_apb_adapter.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, ApbBus, ApbRam
@@ -61,7 +60,16 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -92,7 +100,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -119,6 +132,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -155,20 +173,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read, run_stress_test]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

38
src/axi/tb/taxi_axil_axi_adapter/test_taxi_axil_axi_adapter.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiBus, AxiLiteBus, AxiLiteMaster, AxiRam
@@ -65,7 +64,16 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -159,20 +177,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read, run_stress_test]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

60
src/axi/tb/taxi_axil_crossbar/test_taxi_axil_crossbar.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -69,7 +68,26 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
s_count = 1
m_count = 1
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axil)
m_count = len(cocotb.top.m_axil)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
tb = TB(dut)
@@ -101,7 +119,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
tb = TB(dut)
@@ -129,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -166,30 +196,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axil)
m_count = len(cocotb.top.m_axil)
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("s", range(min(s_count, 2)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

54
src/axi/tb/taxi_axil_crossbar_1s/test_taxi_axil_crossbar_1s.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -67,7 +66,23 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0):
m_count = 1
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axil)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, m=0):
tb = TB(dut)
@@ -99,7 +114,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, m=0):
tb = TB(dut)
@@ -127,6 +148,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -164,28 +190,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axil)
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

58
src/axi/tb/taxi_axil_dp_ram/test_taxi_axil_dp_ram.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster
@@ -69,7 +68,17 @@ class TB(object):
await RisingEdge(self.dut.a_clk)
async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("port", [0, 1]),
)
async def run_test_write(dut, port=0, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -99,7 +108,13 @@ async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpres
await RisingEdge(dut.a_clk)
async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("port", [0, 1]),
)
async def run_test_read(dut, port=0, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -127,7 +142,12 @@ async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpress
await RisingEdge(dut.a_clk)
async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_arb(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -156,6 +176,11 @@ async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inser
await RisingEdge(dut.a_clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -192,31 +217,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.a_clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("port", [0, 1])
factory.generate_tests()
factory = TestFactory(run_test_arb)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

60
src/axi/tb/taxi_axil_interconnect/test_taxi_axil_interconnect.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -69,7 +68,26 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
s_count = 1
m_count = 1
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axil)
m_count = len(cocotb.top.m_axil)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
tb = TB(dut)
@@ -101,7 +119,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("s", range(min(s_count, 2))),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0):
tb = TB(dut)
@@ -129,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -166,30 +196,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
s_count = len(cocotb.top.s_axil)
m_count = len(cocotb.top.m_axil)
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("s", range(min(s_count, 2)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

50
src/axi/tb/taxi_axil_interconnect_1s/test_taxi_axil_interconnect_1s.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -67,6 +66,22 @@ class TB(object):
await RisingEdge(self.dut.clk)
m_count = 1
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axil)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("m", range(min(m_count, 2))),
)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0):
tb = TB(dut)
@@ -99,6 +114,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
("m", range(min(m_count, 2))),
)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0):
tb = TB(dut)
@@ -127,6 +148,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -164,28 +190,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
m_count = len(cocotb.top.m_axil)
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

38
src/axi/tb/taxi_axil_ram/test_taxi_axil_ram.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster
@@ -59,7 +58,16 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -88,7 +96,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -115,6 +128,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -151,20 +169,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read, run_stress_test]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))

38
src/axi/tb/taxi_axil_register/test_taxi_axil_register.py
View File

@@ -20,7 +20,6 @@ import pytest
import cocotb
from cocotb.clock import Clock
from cocotb.triggers import RisingEdge, Timer
from cocotb.regression import TestFactory
from cocotbext.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam
@@ -65,7 +64,16 @@ class TB(object):
await RisingEdge(self.dut.clk)
async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
await RisingEdge(dut.clk)
async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None):
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
await RisingEdge(dut.clk)
@cocotb.test()
@cocotb.parametrize(
("idle_inserter", [None, cycle_pause]),
("backpressure_inserter", [None, cycle_pause]),
)
async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
tb = TB(dut)
@@ -159,20 +177,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None):
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if getattr(cocotb, 'top', None) is not None:
for test in [run_test_write, run_test_read, run_stress_test]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))