1 from nmigen
.compat
.sim
import run_simulation
2 from nmigen
.cli
import verilog
, rtlil
3 from nmigen
import Module
, Signal
, Elaboratable
, Array
, Cat
, Const
5 from soc
.scoreboard
.fumem_dep_cell
import FUMemDependenceCell
6 from soc
.scoreboard
.fu_mem_picker_vec
import FUMem_Pick_Vec
10 6600 Function Unit Dependency Table Matrix inputs / outputs
11 -----------------------------------------------------------
15 class FUMemDepMatrix(Elaboratable
):
16 """ implements FU-to-FU Memory Dependency Matrix
18 def __init__(self
, n_fu_row
, n_fu_col
):
19 self
.n_fu_row
= n_fu_row
# Y (FU row#) ^v
20 self
.n_fu_col
= n_fu_col
# X (FU col #) <>
21 self
.st_pend_i
= Signal(n_fu_row
, reset_less
=True) # Rd pending (left)
22 self
.ld_pend_i
= Signal(n_fu_row
, reset_less
=True) # Wr pending (left)
23 self
.issue_i
= Signal(n_fu_col
, reset_less
=True) # Issue in (top)
25 self
.go_ld_i
= Signal(n_fu_row
, reset_less
=True) # Go Write in (left)
26 self
.go_st_i
= Signal(n_fu_row
, reset_less
=True) # Go Read in (left)
27 self
.go_die_i
= Signal(n_fu_row
, reset_less
=True) # Go Die in (left)
29 # for Function Unit Readable/Writable (horizontal)
30 self
.storable_o
= Signal(n_fu_col
, reset_less
=True) # storable (bot)
31 self
.loadable_o
= Signal(n_fu_col
, reset_less
=True) # loadable (bot)
33 def elaborate(self
, platform
):
37 # matrix of dependency cells
39 dm
= Array(FUMemDependenceCell(f
, self
.n_fu_col
) \
40 for f
in range(self
.n_fu_row
))
41 for y
in range(self
.n_fu_row
):
42 setattr(m
.submodules
, "dm%d" % y
, dm
[y
])
45 # array of Function Unit Readable/Writable: row-length, horizontal
47 fur
= Array(FUMem_Pick_Vec(self
.n_fu_row
) for r
in range(self
.n_fu_col
))
48 for x
in range(self
.n_fu_col
):
49 setattr(m
.submodules
, "fur_x%d" % (x
), fur
[x
])
52 # connect FU Readable/Writable vector
56 for y
in range(self
.n_fu_row
):
58 # accumulate Readable/Writable Vector outputs
59 storable
.append(fu
.storable_o
)
60 loadable
.append(fu
.loadable_o
)
62 # ... and output them from this module (horizontal, width=REGs)
63 m
.d
.comb
+= self
.storable_o
.eq(Cat(*storable
))
64 m
.d
.comb
+= self
.loadable_o
.eq(Cat(*loadable
))
69 for y
in range(self
.n_fu_row
):
72 # connect cell reg-select outputs to Reg Vector In
73 m
.d
.comb
+= [fu
.st_pend_i
.eq(dc
.st_wait_o
),
74 fu
.ld_pend_i
.eq(dc
.ld_wait_o
),
78 # connect Dependency Matrix dest/src1/src2/issue to module d/s/s/i
80 for x
in range(self
.n_fu_col
):
82 for y
in range(self
.n_fu_row
):
84 # accumulate cell inputs issue
85 issue_i
.append(dc
.issue_i
[x
])
86 # wire up inputs from module to row cell inputs
87 m
.d
.comb
+= Cat(*issue_i
).eq(self
.issue_i
)
90 # connect Matrix go_st_i/go_ld_i to module storable/loadable
92 for y
in range(self
.n_fu_row
):
94 # wire up inputs from module to row cell inputs
95 m
.d
.comb
+= [dc
.go_st_i
.eq(self
.go_st_i
),
96 dc
.go_ld_i
.eq(self
.go_ld_i
),
97 dc
.go_die_i
.eq(self
.go_die_i
),
101 # connect Matrix pending
103 for y
in range(self
.n_fu_row
):
105 # wire up inputs from module to row cell inputs
106 m
.d
.comb
+= [dc
.st_pend_i
.eq(self
.st_pend_i
),
107 dc
.ld_pend_i
.eq(self
.ld_pend_i
),
118 yield self
.storable_o
119 yield self
.loadable_o
124 def d_matrix_sim(dut
):
128 yield dut
.issue_i
.eq(1)
130 yield dut
.issue_i
.eq(0)
133 yield dut
.issue_i
.eq(1)
135 yield dut
.issue_i
.eq(0)
137 yield dut
.go_st_i
.eq(1)
139 yield dut
.go_st_i
.eq(0)
141 yield dut
.go_ld_i
.eq(1)
143 yield dut
.go_ld_i
.eq(0)
146 def test_fu_fu_matrix():
147 dut
= FUMemDepMatrix(n_fu_row
=3, n_fu_col
=3)
148 vl
= rtlil
.convert(dut
, ports
=dut
.ports())
149 with
open("test_fu_mem_matrix.il", "w") as f
:
152 run_simulation(dut
, d_matrix_sim(dut
), vcd_name
='test_fu_mem_matrix.vcd')
154 if __name__
== '__main__':