1 """ Example 5: Making use of PyRTL and Introspection. """
3 from nmigen
import Module
, Signal
, Const
4 from nmigen
.cli
import main
, verilog
, rtlil
7 from pipeline
import SimplePipeline
, ObjectProxy
, PipeManager
10 class SimplePipelineExample(SimplePipeline
):
11 """ A very simple pipeline to show how registers are inferred. """
13 def __init__(self
, pipe
):
14 SimplePipeline
.__init
__(self
, pipe
)
15 self
._loopback
= Signal(4)
19 self
.n
= ~self
._loopback
26 self
._pipe
.comb
+= localv
.eq(2)
27 self
.n
= self
.n
<< localv
33 self
._pipe
.sync
+= self
._loopback
.eq(self
.n
+ 3)
36 class ObjectBasedPipelineExample(SimplePipeline
):
37 """ A very simple pipeline to show how registers are inferred. """
39 def __init__(self
, m
):
40 SimplePipeline
.__init
__(self
, m
)
41 self
._loopback
= Signal(4)
49 self
.n
= ~self
._loopback
53 self
.n
= self
.n
+ self
.o
.a
54 o
= ObjectProxy(self
._m
)
56 o
.d
= self
.o
.b
+ self
.n
+ Const(5)
61 self
._m
.d
.comb
+= localv
.eq(2)
62 self
.n
= self
.n
<< localv
63 o
= ObjectProxy(self
._m
)
64 o
.e
= self
.n
+ self
.o
.c
+ self
.o
.d
70 self
.o
.e
= self
.o
.e
+ self
.n
73 self
._m
.d
.sync
+= self
._loopback
.eq(self
.n
+ 3 + self
.o
.e
)
80 self
.p
= ObjectBasedPipelineExample(self
.m
)
82 def get_fragment(self
, platform
=None):
86 class PipelineStageExample
:
89 self
._loopback
= Signal(4, name
="loopback")
91 def get_fragment(self
, platform
=None):
95 with
PipeManager(m
, pipemode
=True) as pipe
:
97 ispec
={'loopback': self
._loopback
}
98 with pipe
.Stage("first", ispec
=ispec
) as (p
, m
):
100 with pipe
.Stage("second", p
) as (p
, m
):
101 #p.n = ~self._loopback + 2
103 with pipe
.Stage("third", p
) as (p
, m
):
104 #p.n = ~self._loopback + 5
106 m
.d
.comb
+= localv
.eq(2)
107 p
.n
= p
.n
<< localv
+ Const(1)
114 class PipelineStageObjectExample
:
117 self
.loopback
= Signal(4)
119 def get_fragment(self
, platform
=None):
123 o
= ObjectProxy(None, pipemode
=False)
129 m
.d
.sync
+= localv2
.eq(localv2
+ 3)
131 #m.d.comb += self.obj.a.eq(localv2 + 1)
132 #m.d.sync += self._loopback.eq(localv2)
134 ispec
= {'loopback': self
.loopback
, 'obj': self
.obj
}
135 with
PipeManager(m
, pipemode
=True) as pipe
:
137 with pipe
.Stage("first", ispec
=ispec
) as (p
, m
):
140 with pipe
.Stage("second", p
) as (p
, m
):
141 #p.n = ~self.loopback + 2
143 m
.d
.comb
+= localn
.eq(p
.n
)
144 o
= ObjectProxy(None, pipemode
=False)
146 o
.d
= p
.o
.b
+ localn
+ Const(5)
149 with pipe
.Stage("third", p
) as (p
, m
):
150 #p.n = ~self._loopback + 5
152 m
.d
.comb
+= localv
.eq(2)
154 o
= ObjectProxy(None, pipemode
=False)
155 o
.e
= p
.n
+ p
.o
.c
+ p
.o
.d
158 print ("stages", pipe
.stages
)
163 class PipelineStageObjectExample2
:
166 self
._loopback
= Signal(4)
168 def get_fragment(self
, platform
=None):
172 ispec
= [self
._loopback
]
173 with
PipeManager(m
, pipemode
=True) as pipe
:
175 with pipe
.Stage("first",
176 ispec
=ispec
) as (p
, m
):
177 p
.n
= ~self
._loopback
178 o
= ObjectProxy(None, pipemode
=False)
179 o
.b
= ~self
._loopback
+ Const(5)
182 print ("stages", pipe
.stages
)
188 if __name__
== "__main__":
189 example
= PipeModule()
190 with
open("pipe_module.il", "w") as f
:
191 f
.write(rtlil
.convert(example
, ports
=[
194 example
= PipelineStageExample()
195 with
open("pipe_stage_module.il", "w") as f
:
196 f
.write(rtlil
.convert(example
, ports
=[
200 example
= PipelineStageObjectExample()
201 with
open("pipe_stage_object_module.il", "w") as f
:
202 f
.write(rtlil
.convert(example
, ports
=[