src/add/pipeline.py

   1 """ Example 5: Making use of PyRTL and Introspection. """
   2
   3 from collections.abc import Sequence
   4
   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
  10
  11 from singlepipe import eq, StageCls, ControlBase, BufferedPipeline
  12 from singlepipe import UnbufferedPipeline
  13
  14
  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
  20 # for the next stage.
  21
  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)
  26     else:
  27         return Signal(value_bits_sign(value), name=rname,
  28                              reset_less=True)
  29         return Signal.like(value, name=rname, reset_less=True)
  30
  31 def get_assigns(_assigns):
  32     assigns = []
  33     for e in _assigns:
  34         if isinstance(e, ObjectProxy):
  35             assigns += get_assigns(e._assigns)
  36         else:
  37             assigns.append(e)
  38     return assigns
  39
  40
  41 def get_eqs(_eqs):
  42     eqs = []
  43     for e in _eqs:
  44         if isinstance(e, ObjectProxy):
  45             eqs += get_eqs(e._eqs)
  46         else:
  47             eqs.append(e)
  48     return eqs
  49
  50
  51 class ObjectProxy:
  52     def __init__(self, m, name=None, pipemode=False):
  53         self._m = m
  54         if name is None:
  55             name = tracer.get_var_name(default=None)
  56         self.name = name
  57         self._pipemode = pipemode
  58         self._eqs = []
  59         self._assigns = []
  60         self._preg_map = {}
  61
  62     @classmethod
  63     def like(cls, m, value, pipemode=False, name=None, src_loc_at=0, **kwargs):
  64         name = name or tracer.get_var_name(depth=2 + src_loc_at,
  65                                             default="$like")
  66
  67         src_loc_at_1 = 1 + src_loc_at
  68         r = ObjectProxy(m, value.name, pipemode)
  69         #for a, aname in value._preg_map.items():
  70         #    r._preg_map[aname] = like(a, aname, m, pipemode)
  71         for a in value.ports():
  72             aname = a.name
  73             r._preg_map[aname] = like(a, aname, m, pipemode)
  74         return r
  75
  76     def __repr__(self):
  77         subobjs = []
  78         for a in self.ports():
  79             aname = a.name
  80             ai = self._preg_map[aname]
  81             subobjs.append(repr(ai))
  82         return "<OP %s>" % subobjs
  83
  84     def get_specs(self, liked=False):
  85         res = []
  86         for k, v in self._preg_map.items():
  87             #v = like(v, k, stage._m)
  88             res.append(v)
  89             if isinstance(v, ObjectProxy):
  90                 res += v.get_specs()
  91         return res
  92
  93     def eq(self, i):
  94         print ("ObjectProxy eq", self, i)
  95         res = []
  96         for a in self.ports():
  97             aname = a.name
  98             ai = i._preg_map[aname]
  99             res.append(a.eq(ai))
 100         return res
 101
 102     def ports(self):
 103         res = []
 104         for aname, a in self._preg_map.items():
 105             if isinstance(a, Signal) or isinstance(a, ObjectProxy) or \
 106                isinstance(a, Record):
 107                 res.append(a)
 108         #print ("ObjectPorts", res)
 109         return res
 110
 111     def __getattr__(self, name):
 112         try:
 113             v = self._preg_map[name]
 114             return v
 115             #return like(v, name, self._m)
 116         except KeyError:
 117             raise AttributeError(
 118                 'error, no pipeline register "%s" defined for OP %s'
 119                 % (name, self.name))
 120
 121     def __setattr__(self, name, value):
 122         if name.startswith('_') or name in ['name', 'ports', 'eq', 'like']:
 123             # do not do anything tricky with variables starting with '_'
 124             object.__setattr__(self, name, value)
 125             return
 126         #rname = "%s_%s" % (self.name, name)
 127         rname = name
 128         new_pipereg = like(value, rname, self._m, self._pipemode)
 129         self._preg_map[name] = new_pipereg
 130         #object.__setattr__(self, name, new_pipereg)
 131         if self._pipemode:
 132             print ("OP pipemode", new_pipereg, value)
 133             #self._m.d.comb += eq(new_pipereg, value)
 134             pass
 135         elif self._m:
 136             print ("OP !pipemode assign", new_pipereg, value, type(value))
 137             self._m.d.comb += eq(new_pipereg, value)
 138         else:
 139             print ("OP !pipemode !m", new_pipereg, value, type(value))
 140             self._assigns += eq(new_pipereg, value)
 141             #self._eqs.append(new_pipereg)
 142             if isinstance(value, ObjectProxy):
 143                 print ("OP, defer assigns:", value._assigns)
 144                 self._assigns += value._assigns
 145                 self._eqs.append(value._eqs)
 146
 147
 148 class PipelineStage:
 149     """ Pipeline builder stage with auto generation of pipeline registers.
 150     """
 151
 152     def __init__(self, name, m, prev=None, pipemode=False, ispec=None):
 153         self._m = m
 154         self._stagename = name
 155         self._preg_map = {}
 156         self._prev_stage = prev
 157         self._ispec = ispec
 158         if prev:
 159             print ("prev", prev._stagename, prev._preg_map)
 160             if prev._stagename in prev._preg_map:
 161                 m = prev._preg_map[prev._stagename]
 162                 self._preg_map[prev._stagename] = m
 163                 #for k, v in m.items():
 164                     #m[k] = like(v, k, self._m)
 165             if '__nextstage__' in prev._preg_map:
 166                 m = prev._preg_map['__nextstage__']
 167                 self._preg_map[self._stagename] = m
 168                 #for k, v in m.items():
 169                     #m[k] = like(v, k, self._m)
 170                 print ("make current", self._stagename, m)
 171         self._pipemode = pipemode
 172         self._eqs = []
 173         self._assigns = []
 174
 175     def __getattr__(self, name):
 176         try:
 177             v = self._preg_map[self._stagename][name]
 178             return v
 179             #return like(v, name, self._m)
 180         except KeyError:
 181             raise AttributeError(
 182                 'error, no pipeline register "%s" defined for stage %s'
 183                 % (name, self._stagename))
 184
 185     def __setattr__(self, name, value):
 186         if name.startswith('_'):
 187             # do not do anything tricky with variables starting with '_'
 188             object.__setattr__(self, name, value)
 189             return
 190         pipereg_id = self._stagename
 191         rname = 'pipereg_' + pipereg_id + '_' + name
 192         new_pipereg = like(value, rname, self._m, self._pipemode)
 193         next_stage = '__nextstage__'
 194         if next_stage not in self._preg_map:
 195             self._preg_map[next_stage] = {}
 196         self._preg_map[next_stage][name] = new_pipereg
 197         if self._pipemode:
 198             self._eqs.append(new_pipereg)
 199             assign = eq(new_pipereg, value)
 200             print ("pipemode: append", new_pipereg, value, assign)
 201             if isinstance(value, ObjectProxy):
 202                 print ("OP, assigns:", value._assigns)
 203                 self._assigns += value._assigns
 204                 self._eqs += value._eqs
 205             #self._m.d.comb += assign
 206             self._assigns += assign
 207         elif self._m:
 208             print ("!pipemode: assign", new_pipereg, value)
 209             assign = eq(new_pipereg, value)
 210             self._m.d.sync += assign
 211         else:
 212             print ("!pipemode !m: defer assign", new_pipereg, value)
 213             assign = eq(new_pipereg, value)
 214             self._assigns += assign
 215             if isinstance(value, ObjectProxy):
 216                 print ("OP, defer assigns:", value._assigns)
 217                 self._assigns += value._assigns
 218
 219 def likelist(specs):
 220     res = []
 221     for v in specs:
 222         res.append(like(v, v.name, None, pipemode=True))
 223     return res
 224
 225
 226 class AutoStage(StageCls):
 227     def __init__(self, inspecs, outspecs, eqs, assigns):
 228         self.inspecs, self.outspecs = inspecs, outspecs
 229         self.eqs, self.assigns = eqs, assigns
 230         #self.o = self.ospec()
 231     def ispec(self): return likelist(self.inspecs)
 232     def ospec(self): return likelist(self.outspecs)
 233
 234     def process(self, i):
 235         print ("stage process", i)
 236         return self.outspecs
 237
 238     def setup(self, m, i):
 239         print ("stage setup i", i)
 240         print ("stage setup inspecs", self.inspecs)
 241         print ("stage setup outspecs", self.outspecs)
 242         print ("stage setup eqs", self.eqs)
 243         #self.o = self.ospec()
 244         m.d.comb += eq(self.eqs, i)
 245         #m.d.comb += eq(self.outspecs, self.eqs)
 246         #m.d.comb += eq(self.o, i)
 247
 248
 249 class AutoPipe(UnbufferedPipeline):
 250     def __init__(self, stage, assigns):
 251         UnbufferedPipeline.__init__(self, stage)
 252         self.assigns = assigns
 253
 254     def elaborate(self, platform):
 255         m = UnbufferedPipeline.elaborate(self, platform)
 256         m.d.comb += self.assigns
 257         print ("assigns", self.assigns)
 258         return m
 259
 260
 261 class PipeManager:
 262     def __init__(self, m, pipemode=False, pipetype=None):
 263         self.m = m
 264         self.pipemode = pipemode
 265         self.pipetype = pipetype
 266
 267     @contextmanager
 268     def Stage(self, name, prev=None, ispec=None):
 269         print ("start stage", name)
 270         if ispec:
 271             ispec = likelist(ispec)
 272         stage = PipelineStage(name, None, prev, self.pipemode, ispec=ispec)
 273         try:
 274             yield stage, self.m #stage._m
 275         finally:
 276             pass
 277         if self.pipemode:
 278             if stage._ispec:
 279                 print ("use ispec", stage._ispec)
 280                 inspecs = stage._ispec
 281             else:
 282                 inspecs = self.get_specs(stage, name)
 283                 inspecs = likelist(inspecs)
 284             outspecs = self.get_specs(stage, '__nextstage__', liked=True)
 285             eqs = get_eqs(stage._eqs)
 286             assigns = get_assigns(stage._assigns)
 287             print ("stage eqs", name, eqs)
 288             print ("stage assigns", name, assigns)
 289             s = AutoStage(inspecs, outspecs, eqs, assigns)
 290             self.stages.append(s)
 291         print ("end stage", name, self.pipemode, "\n")
 292
 293     def get_specs(self, stage, name, liked=False):
 294         if name in stage._preg_map:
 295             res = []
 296             for k, v in stage._preg_map[name].items():
 297                 #v = like(v, k, stage._m)
 298                 res.append(v)
 299                 #if isinstance(v, ObjectProxy):
 300                 #    res += v.get_specs()
 301             return res
 302         return []
 303
 304     def __enter__(self):
 305         self.stages = []
 306         return self
 307
 308     def __exit__(self, *args):
 309         print ("exit stage", args)
 310         pipes = []
 311         cb = ControlBase()
 312         for s in self.stages:
 313             print ("stage specs", s, s.inspecs, s.outspecs)
 314             if self.pipetype == 'buffered':
 315                 p = BufferedPipeline(s)
 316             else:
 317                 p = AutoPipe(s, s.assigns)
 318             pipes.append(p)
 319             self.m.submodules += p
 320
 321         self.m.d.comb += cb.connect(pipes)
 322
 323
 324 class SimplePipeline:
 325     """ Pipeline builder with auto generation of pipeline registers.
 326     """
 327
 328     def __init__(self, m):
 329         self._m = m
 330         self._pipeline_register_map = {}
 331         self._current_stage_num = 0
 332
 333     def _setup(self):
 334         stage_list = []
 335         for method in dir(self):
 336             if method.startswith('stage'):
 337                 stage_list.append(method)
 338         for stage in sorted(stage_list):
 339             stage_method = getattr(self, stage)
 340             stage_method()
 341             self._current_stage_num += 1
 342
 343     def __getattr__(self, name):
 344         try:
 345             return self._pipeline_register_map[self._current_stage_num][name]
 346         except KeyError:
 347             raise AttributeError(
 348                 'error, no pipeline register "%s" defined for stage %d'
 349                 % (name, self._current_stage_num))
 350
 351     def __setattr__(self, name, value):
 352         if name.startswith('_'):
 353             # do not do anything tricky with variables starting with '_'
 354             object.__setattr__(self, name, value)
 355             return
 356         next_stage = self._current_stage_num + 1
 357         pipereg_id = str(self._current_stage_num) + 'to' + str(next_stage)
 358         rname = 'pipereg_' + pipereg_id + '_' + name
 359         #new_pipereg = Signal(value_bits_sign(value), name=rname,
 360         #                     reset_less=True)
 361         if isinstance(value, ObjectProxy):
 362             new_pipereg = ObjectProxy.like(self._m, value,
 363                                            name=rname, reset_less = True)
 364         else:
 365             new_pipereg = Signal.like(value, name=rname, reset_less = True)
 366         if next_stage not in self._pipeline_register_map:
 367             self._pipeline_register_map[next_stage] = {}
 368         self._pipeline_register_map[next_stage][name] = new_pipereg
 369         self._m.d.sync += eq(new_pipereg, value)
 370