1 from nmigen
.compat
.sim
import run_simulation
2 from nmigen
.cli
import verilog
, rtlil
3 from nmigen
import Module
, Signal
, Elaboratable
, Array
, Cat
5 #from nmutil.latch import SRLatch
6 from scoreboard
.dependence_cell
import DependencyRow
7 from scoreboard
.fu_wr_pending
import FU_RW_Pend
8 from scoreboard
.reg_select
import Reg_Rsv
9 from scoreboard
.global_pending
import GlobalPending
13 6600 Dependency Table Matrix inputs / outputs
14 ---------------------------------------------
16 d s1 s2 i d s1 s2 i d s1 s2 i d s1 s2 i
17 | | | | | | | | | | | | | | | |
18 v v v v v v v v v v v v v v v v
19 go_rd/go_wr -> dm-r0-fu0 dm-r1-fu0 dm-r2-fu0 dm-r3-fu0 -> wr/rd-pend
20 go_rd/go_wr -> dm-r0-fu1 dm-r1-fu1 dm-r2-fu1 dm-r3-fu1 -> wr/rd-pend
21 go_rd/go_wr -> dm-r0-fu2 dm-r1-fu2 dm-r2-fu2 dm-r3-fu2 -> wr/rd-pend
22 | | | | | | | | | | | |
23 v v v v v v v v v v v v
24 d s1 s2 d s1 s2 d s1 s2 d s1 s2
25 reg sel reg sel reg sel reg sel
29 class FURegDepMatrix(Elaboratable
):
30 """ implements 11.4.7 mitch alsup FU-to-Reg Dependency Matrix, p26
32 def __init__(self
, n_fu_row
, n_reg_col
):
33 self
.n_fu_row
= n_fu_row
# Y (FUs) ^v
34 self
.n_reg_col
= n_reg_col
# X (Regs) <>
35 self
.dest_i
= Signal(n_reg_col
, reset_less
=True) # Dest in (top)
36 self
.src1_i
= Signal(n_reg_col
, reset_less
=True) # oper1 in (top)
37 self
.src2_i
= Signal(n_reg_col
, reset_less
=True) # oper2 in (top)
39 # Register "Global" vectors for determining RaW and WaR hazards
40 self
.wr_pend_i
= Signal(n_reg_col
, reset_less
=True) # wr pending (top)
41 self
.rd_pend_i
= Signal(n_reg_col
, reset_less
=True) # rd pending (top)
42 self
.wr_rsel_o
= Signal(n_reg_col
, reset_less
=True) # wr pending (bot)
43 self
.rd_rsel_o
= Signal(n_reg_col
, reset_less
=True) # rd pending (bot)
45 self
.issue_i
= Signal(n_fu_row
, reset_less
=True) # Issue in (top)
46 self
.go_wr_i
= Signal(n_fu_row
, reset_less
=True) # Go Write in (left)
47 self
.go_rd_i
= Signal(n_fu_row
, reset_less
=True) # Go Read in (left)
48 self
.go_die_i
= Signal(n_fu_row
, reset_less
=True) # Go Die in (left)
50 # for Register File Select Lines (horizontal), per-reg
51 self
.dest_rsel_o
= Signal(n_reg_col
, reset_less
=True) # dest reg (bot)
52 self
.src1_rsel_o
= Signal(n_reg_col
, reset_less
=True) # src1 reg (bot)
53 self
.src2_rsel_o
= Signal(n_reg_col
, reset_less
=True) # src2 reg (bot)
55 # for Function Unit "forward progress" (vertical), per-FU
56 self
.wr_pend_o
= Signal(n_fu_row
, reset_less
=True) # wr pending (right)
57 self
.rd_pend_o
= Signal(n_fu_row
, reset_less
=True) # rd pending (right)
58 self
.rd_src1_pend_o
= Signal(n_fu_row
, reset_less
=True) # src1 pending
59 self
.rd_src2_pend_o
= Signal(n_fu_row
, reset_less
=True) # src2 pending
61 def elaborate(self
, platform
):
65 # matrix of dependency cells
67 dm
= Array(DependencyRow(self
.n_reg_col
) for r
in range(self
.n_fu_row
))
68 for fu
in range(self
.n_fu_row
):
69 setattr(m
.submodules
, "dr_fu%d" % fu
, dm
[fu
])
72 # array of Function Unit Pending vectors
74 fupend
= Array(FU_RW_Pend(self
.n_reg_col
) for f
in range(self
.n_fu_row
))
75 for fu
in range(self
.n_fu_row
):
76 setattr(m
.submodules
, "fu_fu%d" % (fu
), fupend
[fu
])
79 # array of Register Reservation vectors
81 regrsv
= Array(Reg_Rsv(self
.n_fu_row
) for r
in range(self
.n_reg_col
))
82 for rn
in range(self
.n_reg_col
):
83 setattr(m
.submodules
, "rr_r%d" % (rn
), regrsv
[rn
])
86 # connect Function Unit vector
92 for fu
in range(self
.n_fu_row
):
98 for rn
in range(self
.n_reg_col
):
99 # accumulate cell fwd outputs for dest/src1/src2
100 dest_fwd_o
.append(dc
.dest_fwd_o
[rn
])
101 src1_fwd_o
.append(dc
.src1_fwd_o
[rn
])
102 src2_fwd_o
.append(dc
.src2_fwd_o
[rn
])
103 # connect cell fwd outputs to FU Vector in [Cat is gooood]
104 m
.d
.comb
+= [fup
.dest_fwd_i
.eq(Cat(*dest_fwd_o
)),
105 fup
.src1_fwd_i
.eq(Cat(*src1_fwd_o
)),
106 fup
.src2_fwd_i
.eq(Cat(*src2_fwd_o
))
108 # accumulate FU Vector outputs
109 wr_pend
.append(fup
.reg_wr_pend_o
)
110 rd_pend
.append(fup
.reg_rd_pend_o
)
111 rd_src1_pend
.append(fup
.reg_rd_src1_pend_o
)
112 rd_src2_pend
.append(fup
.reg_rd_src2_pend_o
)
114 # ... and output them from this module (vertical, width=FUs)
115 m
.d
.comb
+= self
.wr_pend_o
.eq(Cat(*wr_pend
))
116 m
.d
.comb
+= self
.rd_pend_o
.eq(Cat(*rd_pend
))
117 m
.d
.comb
+= self
.rd_src1_pend_o
.eq(Cat(*rd_src1_pend
))
118 m
.d
.comb
+= self
.rd_src2_pend_o
.eq(Cat(*rd_src2_pend
))
121 # connect Reg Selection vector
126 for rn
in range(self
.n_reg_col
):
131 for fu
in range(self
.n_fu_row
):
133 # accumulate cell reg-select outputs dest/src1/src2
134 dest_rsel_o
.append(dc
.dest_rsel_o
[rn
])
135 src1_rsel_o
.append(dc
.src1_rsel_o
[rn
])
136 src2_rsel_o
.append(dc
.src2_rsel_o
[rn
])
137 # connect cell reg-select outputs to Reg Vector In
138 m
.d
.comb
+= [rsv
.dest_rsel_i
.eq(Cat(*dest_rsel_o
)),
139 rsv
.src1_rsel_i
.eq(Cat(*src1_rsel_o
)),
140 rsv
.src2_rsel_i
.eq(Cat(*src2_rsel_o
)),
142 # accumulate Reg-Sel Vector outputs
143 dest_rsel
.append(rsv
.dest_rsel_o
)
144 src1_rsel
.append(rsv
.src1_rsel_o
)
145 src2_rsel
.append(rsv
.src2_rsel_o
)
147 # ... and output them from this module (horizontal, width=REGs)
148 m
.d
.comb
+= self
.dest_rsel_o
.eq(Cat(*dest_rsel
))
149 m
.d
.comb
+= self
.src1_rsel_o
.eq(Cat(*src1_rsel
))
150 m
.d
.comb
+= self
.src2_rsel_o
.eq(Cat(*src2_rsel
))
153 # connect Dependency Matrix dest/src1/src2/issue to module d/s/s/i
155 for fu
in range(self
.n_fu_row
):
157 # wire up inputs from module to row cell inputs (Cat is gooood)
158 m
.d
.comb
+= [dc
.dest_i
.eq(self
.dest_i
),
159 dc
.src1_i
.eq(self
.src1_i
),
160 dc
.src2_i
.eq(self
.src2_i
),
161 dc
.rd_pend_i
.eq(self
.rd_pend_i
),
162 dc
.wr_pend_i
.eq(self
.wr_pend_i
),
165 # accumulate rsel bits into read/write pending vectors.
168 for fu
in range(self
.n_fu_row
):
170 rd_pend_v
.append(dc
.rd_rsel_o
)
171 wr_pend_v
.append(dc
.wr_rsel_o
)
172 rd_v
= GlobalPending(self
.n_reg_col
, rd_pend_v
)
173 wr_v
= GlobalPending(self
.n_reg_col
, wr_pend_v
)
174 m
.submodules
.rd_v
= rd_v
175 m
.submodules
.wr_v
= wr_v
177 m
.d
.comb
+= self
.rd_rsel_o
.eq(rd_v
.g_pend_o
)
178 m
.d
.comb
+= self
.wr_rsel_o
.eq(wr_v
.g_pend_o
)
181 # connect Dep issue_i/go_rd_i/go_wr_i to module issue_i/go_rd/go_wr
187 for fu
in range(self
.n_fu_row
):
189 # accumulate cell fwd outputs for dest/src1/src2
190 go_rd_i
.append(dc
.go_rd_i
)
191 go_wr_i
.append(dc
.go_wr_i
)
192 go_die_i
.append(dc
.go_die_i
)
193 issue_i
.append(dc
.issue_i
)
194 # wire up inputs from module to row cell inputs (Cat is gooood)
195 m
.d
.comb
+= [Cat(*go_rd_i
).eq(self
.go_rd_i
),
196 Cat(*go_wr_i
).eq(self
.go_wr_i
),
197 Cat(*go_die_i
).eq(self
.go_die_i
),
198 Cat(*issue_i
).eq(self
.issue_i
),
211 yield self
.dest_rsel_o
212 yield self
.src1_rsel_o
213 yield self
.src2_rsel_o
220 yield self
.rd_src1_pend_o
221 yield self
.rd_src2_pend_o
226 def d_matrix_sim(dut
):
229 yield dut
.dest_i
.eq(1)
230 yield dut
.issue_i
.eq(1)
232 yield dut
.issue_i
.eq(0)
234 yield dut
.src1_i
.eq(1)
235 yield dut
.issue_i
.eq(1)
237 yield dut
.issue_i
.eq(0)
239 yield dut
.go_rd_i
.eq(1)
241 yield dut
.go_rd_i
.eq(0)
243 yield dut
.go_wr_i
.eq(1)
245 yield dut
.go_wr_i
.eq(0)
249 dut
= FURegDepMatrix(n_fu_row
=3, n_reg_col
=4)
250 vl
= rtlil
.convert(dut
, ports
=dut
.ports())
251 with
open("test_fu_reg_matrix.il", "w") as f
:
254 run_simulation(dut
, d_matrix_sim(dut
), vcd_name
='test_fu_reg_matrix.vcd')
256 if __name__
== '__main__':