tb/gfx_shader_bind: update testbench

1 files changed, 31 insertions, 16 deletions

diff --git a/tb/gfx_shader_bind/testbench/main.py b/tb/gfx_shader_bind/testbench/main.py
index f31e198..5f607bd 100644
--- a/tb/gfx_shader_bind/testbench/main.py
+++ b/tb/gfx_shader_bind/testbench/main.py
@@ -8,7 +8,7 @@ from cocotb_bus.scoreboard import Scoreboard
 from cocotb_coverage.coverage import coverage_db
 
 from .axi import AXI4Agent
-from .data import FrontWave
+from .data import BAD_PC, FrontWave
 from .common import MAX_GROUPS, MEM_WORDS, log
 from .models import Memory, PcTable
 from .drivers import ClockResetDriver, LoopDriver, PcDriver
@@ -21,15 +21,24 @@ async def test(dut):
     mem_agent = AXI4Agent(dut, 'mem', dut.clk, mem, case_insensitive=False)
 
     out_groups = set()
+    out_groups_done = set()
     out_groups_retry = set()
     out_monitor = FrontWaveMonitor(dut, 'wave', dut.clk, case_insensitive=False)
 
+    lst = set()
     def out_callback(wave):
-        nonlocal out_groups, out_groups_retry
+        nonlocal out_groups, out_groups_done, out_groups_retry
+
+        if wave.insn is not None:
+            lst.add(wave.group)
 
         out_groups.add(wave.group)
         if wave.insn is None:
             out_groups_retry.add(wave.group)
+        else:
+            out_groups_done.add(wave.group)
+            if wave.group in out_groups_retry:
+                out_groups_retry.remove(wave.group)
 
     out_monitor.add_callback(out_callback)
 
@@ -54,35 +63,41 @@ async def test(dut):
     await FallingEdge(dut.front.bind_.icache.in_flush) #FIXME
     await RisingEdge(dut.clk)
 
-    for iteration in range(1000):
+    for iteration in range(50):
         all_groups = list(range(MAX_GROUPS))
         random.shuffle(all_groups)
 
+        for group in range(MAX_GROUPS):
+            pc_table[group] = BAD_PC * 4
+
         for group in all_groups:
-            pc = random.randint(0, MEM_WORDS) * 4
+            pc = random.randint(0, 512) * 4
             pc_table[group] = pc
             mem.randomize_line(pc)
 
-            out_expected.append(FrontWave(group=group, insn=mem.read(pc), soft=True))
+        for group in all_groups:
+            out_expected.append(FrontWave(group=group, insn=mem.read_cached(4 * pc_table[group]), soft=True))
             await loop_driver.put(group)
 
-        #while out_groups_retry or len(out_groups) < MAX_GROUPS:
-        for _ in range(100):
-            if out_groups_retry:
-                group = out_groups_retry.pop()
-                out_groups.remove(group)
+        for _ in range(30):
+            retry = out_groups_retry.copy()
+            retry_len = len(retry)
+            out_groups_retry.clear()
 
-                out_expected.append(FrontWave(group=group, insn=mem.read(pc_table[group] * 4), soft=True))
+            if not retry and len(out_groups_done) == MAX_GROUPS:
+                break
 
+            for group in retry:
+                out_expected.append(FrontWave(group=group, insn=mem.read_cached(pc_table[group] * 4), soft=True))
                 await loop_driver.put(group)
+                await RisingEdge(dut.clk)
 
-            await RisingEdge(dut.clk)
-
-        for _ in range(100):
-            await RisingEdge(dut.clk)
+            await ClockCycles(dut.clk, max(0, 16 - retry_len))
+        else:
+            raise TimeoutError(f'Timed out during iteration {iteration} waiting for all groups to finish: {list(out_groups_retry)}')
 
         out_groups.clear()
-        out_groups_retry.clear()
+        out_groups_done.clear()
 
     coverage_db.report_coverage(log.info, bins=True)
     coverage_db.export_to_xml(filename="coverage.xml")