1 """ Example 5: Making use of PyRTL and Introspection. """
3 from collections
.abc
import Sequence
5 from nmigen
import Signal
6 from nmigen
.hdl
.rec
import Record
7 from nmigen
import tracer
8 from nmigen
.compat
.fhdl
.bitcontainer
import value_bits_sign
9 from contextlib
import contextmanager
11 from singlepipe
import eq
, StageCls
, ControlBase
, BufferedPipeline
12 from singlepipe
import UnbufferedPipeline
15 # The following example shows how pyrtl can be used to make some interesting
16 # hardware structures using python introspection. In particular, this example
17 # makes a N-stage pipeline structure. Any specific pipeline is then a derived
18 # class of SimplePipeline where methods with names starting with "stage" are
19 # stages, and new members with names not starting with "_" are to be registered
22 def like(value
, rname
, pipe
, pipemode
=False):
23 if isinstance(value
, ObjectProxy
):
24 return ObjectProxy
.like(pipe
, value
, pipemode
=pipemode
,
25 name
=rname
, reset_less
=True)
27 return Signal(value_bits_sign(value
), name
=rname
,
29 return Signal
.like(value
, name
=rname
, reset_less
=True)
31 def get_assigns(_assigns
):
34 if isinstance(e
, ObjectProxy
):
35 assigns
+= get_assigns(e
._assigns
)
44 if isinstance(e
, ObjectProxy
):
45 eqs
+= get_eqs(e
._eqs
)
52 def __init__(self
, m
, name
=None, pipemode
=False, syncmode
=True):
55 name
= tracer
.get_var_name(default
=None)
57 self
._pipemode
= pipemode
58 self
._syncmode
= syncmode
64 def like(cls
, m
, value
, pipemode
=False, name
=None, src_loc_at
=0, **kwargs
):
65 name
= name
or tracer
.get_var_name(depth
=2 + src_loc_at
,
68 src_loc_at_1
= 1 + src_loc_at
69 r
= ObjectProxy(m
, value
.name
, pipemode
)
70 #for a, aname in value._preg_map.items():
71 # r._preg_map[aname] = like(a, aname, m, pipemode)
72 for a
in value
.ports():
74 r
._preg
_map
[aname
] = like(a
, aname
, m
, pipemode
)
79 for a
in self
.ports():
81 ai
= self
._preg
_map
[aname
]
82 subobjs
.append(repr(ai
))
83 return "<OP %s>" % subobjs
85 def get_specs(self
, liked
=False):
87 for k
, v
in self
._preg
_map
.items():
88 #v = like(v, k, stage._m)
90 if isinstance(v
, ObjectProxy
):
95 print ("ObjectProxy eq", self
, i
)
97 for a
in self
.ports():
99 ai
= i
._preg
_map
[aname
]
105 for aname
, a
in self
._preg
_map
.items():
106 if isinstance(a
, Signal
) or isinstance(a
, ObjectProxy
) or \
107 isinstance(a
, Record
):
109 #print ("ObjectPorts", res)
112 def __getattr__(self
, name
):
114 v
= self
._preg
_map
[name
]
116 #return like(v, name, self._m)
118 raise AttributeError(
119 'error, no pipeline register "%s" defined for OP %s'
122 def __setattr__(self
, name
, value
):
123 if name
.startswith('_') or name
in ['name', 'ports', 'eq', 'like']:
124 # do not do anything tricky with variables starting with '_'
125 object.__setattr
__(self
, name
, value
)
127 #rname = "%s_%s" % (self.name, name)
129 new_pipereg
= like(value
, rname
, self
._m
, self
._pipemode
)
130 self
._preg
_map
[name
] = new_pipereg
131 #object.__setattr__(self, name, new_pipereg)
133 print ("OP pipemode", new_pipereg
, value
)
134 assign
= eq(new_pipereg
, value
)
136 self
._m
.d
.sync
+= assign
138 self
._m
.d
.comb
+= assign
140 print ("OP !pipemode assign", new_pipereg
, value
, type(value
))
141 self
._m
.d
.comb
+= eq(new_pipereg
, value
)
143 print ("OP !pipemode !m", new_pipereg
, value
, type(value
))
144 self
._assigns
+= eq(new_pipereg
, value
)
145 if isinstance(value
, ObjectProxy
):
146 print ("OP, defer assigns:", value
._assigns
)
147 self
._assigns
+= value
._assigns
148 self
._eqs
.append(value
._eqs
)
152 """ Pipeline builder stage with auto generation of pipeline registers.
155 def __init__(self
, name
, m
, prev
=None, pipemode
=False, ispec
=None):
157 self
._stagename
= name
158 self
._preg
_map
= {'__nextstage__': {}}
159 self
._prev
_stage
= prev
162 self
._preg
_map
[self
._stagename
] = ispec
164 print ("prev", prev
._stagename
, prev
._preg
_map
)
165 #if prev._stagename in prev._preg_map:
166 # m = prev._preg_map[prev._stagename]
167 # self._preg_map[prev._stagename] = m
168 if '__nextstage__' in prev
._preg
_map
:
169 m
= prev
._preg
_map
['__nextstage__']
171 self
._preg
_map
[self
._stagename
] = m
172 #for k, v in m.items():
173 #m[k] = like(v, k, self._m)
174 print ("make current", self
._stagename
, m
)
175 self
._pipemode
= pipemode
179 def __getattribute__(self
, name
):
180 if name
.startswith('_'):
181 return object.__getattribute
__(self
, name
)
182 #if name in self._preg_map['__nextstage__']:
183 # return self._preg_map['__nextstage__'][name]
185 print ("getattr", name
, object.__getattribute
__(self
, '_preg_map'))
186 v
= self
._preg
_map
[self
._stagename
][name
]
188 #return like(v, name, self._m)
190 raise AttributeError(
191 'error, no pipeline register "%s" defined for stage %s'
192 % (name
, self
._stagename
))
194 def __setattr__(self
, name
, value
):
195 if name
.startswith('_'):
196 # do not do anything tricky with variables starting with '_'
197 object.__setattr
__(self
, name
, value
)
199 pipereg_id
= self
._stagename
200 rname
= 'pipereg_' + pipereg_id
+ '_' + name
201 new_pipereg
= like(value
, rname
, self
._m
, self
._pipemode
)
202 next_stage
= '__nextstage__'
203 if next_stage
not in self
._preg
_map
:
204 self
._preg
_map
[next_stage
] = {}
205 self
._preg
_map
[next_stage
][name
] = new_pipereg
206 print ("setattr", name
, value
, self
._preg
_map
)
208 self
._eqs
[name
] = new_pipereg
209 assign
= eq(new_pipereg
, value
)
210 print ("pipemode: append", new_pipereg
, value
, assign
)
211 if isinstance(value
, ObjectProxy
):
212 print ("OP, assigns:", value
._assigns
)
213 self
._assigns
+= value
._assigns
214 self
._eqs
[name
]._eqs
= value
._eqs
215 #self._m.d.comb += assign
216 self
._assigns
+= assign
218 print ("!pipemode: assign", new_pipereg
, value
)
219 assign
= eq(new_pipereg
, value
)
220 self
._m
.d
.sync
+= assign
222 print ("!pipemode !m: defer assign", new_pipereg
, value
)
223 assign
= eq(new_pipereg
, value
)
224 self
._eqs
[name
] = new_pipereg
225 self
._assigns
+= assign
226 if isinstance(value
, ObjectProxy
):
227 print ("OP, defer assigns:", value
._assigns
)
228 self
._assigns
+= value
._assigns
229 self
._eqs
[name
]._eqs
= value
._eqs
234 res
.append(like(v
, v
.name
, None, pipemode
=True))
238 if not isinstance(specs
, dict):
239 return like(specs
, specs
.name
, None, pipemode
=True)
241 for k
, v
in specs
.items():
246 class AutoStage(StageCls
):
247 def __init__(self
, inspecs
, outspecs
, eqs
, assigns
):
248 self
.inspecs
, self
.outspecs
= inspecs
, outspecs
249 self
.eqs
, self
.assigns
= eqs
, assigns
250 #self.o = self.ospec()
251 def ispec(self
): return likedict(self
.inspecs
)
252 def ospec(self
): return likedict(self
.outspecs
)
254 def process(self
, i
):
255 print ("stage process", i
)
258 def setup(self
, m
, i
):
259 print ("stage setup i", i
, m
)
260 print ("stage setup inspecs", self
.inspecs
)
261 print ("stage setup outspecs", self
.outspecs
)
262 print ("stage setup eqs", self
.eqs
)
263 #self.o = self.ospec()
264 m
.d
.comb
+= eq(self
.inspecs
, i
)
265 #m.d.comb += eq(self.outspecs, self.eqs)
266 #m.d.comb += eq(self.o, i)
269 class AutoPipe(UnbufferedPipeline
):
270 def __init__(self
, stage
, assigns
):
271 UnbufferedPipeline
.__init
__(self
, stage
)
272 self
.assigns
= assigns
274 def elaborate(self
, platform
):
275 m
= UnbufferedPipeline
.elaborate(self
, platform
)
276 m
.d
.comb
+= self
.assigns
277 print ("assigns", self
.assigns
, m
)
282 def __init__(self
, m
, pipemode
=False, pipetype
=None):
284 self
.pipemode
= pipemode
285 self
.pipetype
= pipetype
288 def Stage(self
, name
, prev
=None, ispec
=None):
290 ispec
= likedict(ispec
)
291 print ("start stage", name
, ispec
)
292 stage
= PipelineStage(name
, None, prev
, self
.pipemode
, ispec
=ispec
)
294 yield stage
, self
.m
#stage._m
299 print ("use ispec", stage
._ispec
)
300 inspecs
= stage
._ispec
302 inspecs
= self
.get_specs(stage
, name
)
303 #inspecs = likedict(inspecs)
304 outspecs
= self
.get_specs(stage
, '__nextstage__', liked
=True)
305 print ("stage inspecs", name
, inspecs
)
306 print ("stage outspecs", name
, outspecs
)
307 eqs
= stage
._eqs
# get_eqs(stage._eqs)
308 assigns
= get_assigns(stage
._assigns
)
309 print ("stage eqs", name
, eqs
)
310 print ("stage assigns", name
, assigns
)
311 s
= AutoStage(inspecs
, outspecs
, eqs
, assigns
)
312 self
.stages
.append(s
)
313 print ("end stage", name
, self
.pipemode
, "\n")
315 def get_specs(self
, stage
, name
, liked
=False):
316 return stage
._preg
_map
[name
]
317 if name
in stage
._preg
_map
:
319 for k
, v
in stage
._preg
_map
[name
].items():
320 #v = like(v, k, stage._m)
322 #if isinstance(v, ObjectProxy):
323 # res += v.get_specs()
331 def __exit__(self
, *args
):
332 print ("exit stage", args
)
335 for s
in self
.stages
:
336 print ("stage specs", s
, s
.inspecs
, s
.outspecs
)
337 if self
.pipetype
== 'buffered':
338 p
= BufferedPipeline(s
)
340 p
= AutoPipe(s
, s
.assigns
)
342 self
.m
.submodules
+= p
344 self
.m
.d
.comb
+= cb
.connect(pipes
)
347 class SimplePipeline
:
348 """ Pipeline builder with auto generation of pipeline registers.
351 def __init__(self
, m
):
353 self
._pipeline
_register
_map
= {}
354 self
._current
_stage
_num
= 0
358 for method
in dir(self
):
359 if method
.startswith('stage'):
360 stage_list
.append(method
)
361 for stage
in sorted(stage_list
):
362 stage_method
= getattr(self
, stage
)
364 self
._current
_stage
_num
+= 1
366 def __getattr__(self
, name
):
368 return self
._pipeline
_register
_map
[self
._current
_stage
_num
][name
]
370 raise AttributeError(
371 'error, no pipeline register "%s" defined for stage %d'
372 % (name
, self
._current
_stage
_num
))
374 def __setattr__(self
, name
, value
):
375 if name
.startswith('_'):
376 # do not do anything tricky with variables starting with '_'
377 object.__setattr
__(self
, name
, value
)
379 next_stage
= self
._current
_stage
_num
+ 1
380 pipereg_id
= str(self
._current
_stage
_num
) + 'to' + str(next_stage
)
381 rname
= 'pipereg_' + pipereg_id
+ '_' + name
382 #new_pipereg = Signal(value_bits_sign(value), name=rname,
384 if isinstance(value
, ObjectProxy
):
385 new_pipereg
= ObjectProxy
.like(self
._m
, value
,
386 name
=rname
, reset_less
= True)
388 new_pipereg
= Signal
.like(value
, name
=rname
, reset_less
= True)
389 if next_stage
not in self
._pipeline
_register
_map
:
390 self
._pipeline
_register
_map
[next_stage
] = {}
391 self
._pipeline
_register
_map
[next_stage
][name
] = new_pipereg
392 self
._m
.d
.sync
+= eq(new_pipereg
, value
)