X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fadd%2Fpipeline_example.py;h=799caf6d15064b1e80fdb669df537ef9b38baeaf;hb=6bff1a997f3846872cf489c24b5c01426c4dc97c;hp=b84496e71039b04c34646e67021832b1260cc18f;hpb=38dbb484c785f8ef5603750e88e8dc6875e6c944;p=ieee754fpu.git

diff --git a/src/add/pipeline_example.py b/src/add/pipeline_example.py
index b84496e7..799caf6d 100644
--- a/src/add/pipeline_example.py
+++ b/src/add/pipeline_example.py
@@ -52,8 +52,8 @@ class ObjectBasedPipelineExample(SimplePipeline):
     def stage1(self):
         self.n = self.n + self.o.a
         o = ObjectProxy(self._m)
-        o.a = self.n
-        o.b = self.o.b + self.n + Const(5)
+        o.c = self.n
+        o.d = self.o.b + self.n + Const(5)
         self.o = o
 
     def stage2(self):
@@ -61,16 +61,16 @@ class ObjectBasedPipelineExample(SimplePipeline):
         self._m.d.comb += localv.eq(2)
         self.n = self.n << localv
         o = ObjectProxy(self._m)
-        o.b = self.n + self.o.a + self.o.b
+        o.e = self.n + self.o.c + self.o.d
         self.o = o
 
     def stage3(self):
         self.n = ~self.n
         self.o = self.o
-        self.o.b = self.o.b + self.n
+        self.o.e = self.o.e + self.n
 
     def stage4(self):
-        self._m.d.sync += self._loopback.eq(self.n + 3 + self.o.b)
+        self._m.d.sync += self._loopback.eq(self.n + 3 + self.o.e)
 
 
 class PipeModule:
@@ -79,31 +79,32 @@ class PipeModule:
         self.m = Module()
         self.p = ObjectBasedPipelineExample(self.m)
 
-    def get_fragment(self, platform=None):
+    def elaborate(self, platform=None):
         return self.m
 
 
 class PipelineStageExample:
 
     def __init__(self):
-        self._loopback = Signal(4)
+        self._loopback = Signal(4, name="loopback")
 
-    def get_fragment(self, platform=None):
+    def elaborate(self, platform=None):
 
         m = Module()
 
         with PipeManager(m, pipemode=True) as pipe:
 
-            with pipe.Stage("first", ispec=[self._loopback]) as (p, m):
-                p.n = ~self._loopback
+            ispec={'loopback': self._loopback}
+            with pipe.Stage("first", ispec=ispec) as (p, m):
+                p.n = ~p.loopback
             with pipe.Stage("second", p) as (p, m):
                 #p.n = ~self._loopback + 2
-                p.n = p.n + 2
+                p.n = p.n + Const(2)
             with pipe.Stage("third", p) as (p, m):
                 #p.n = ~self._loopback + 5
                 localv = Signal(4)
                 m.d.comb += localv.eq(2)
-                p.n = p.n << localv + 1
+                p.n = p.n << localv + Const(1)
                 #p.m = p.n + 2
 
         print (pipe.stages)
@@ -113,16 +114,16 @@ class PipelineStageExample:
 class PipelineStageObjectExample:
 
     def __init__(self):
-        self._loopback = Signal(4)
+        self.loopback = Signal(4)
 
-    def get_fragment(self, platform=None):
+    def elaborate(self, platform=None):
 
         m = Module()
 
         o = ObjectProxy(None, pipemode=False)
         o.a = Signal(4)
         o.b = Signal(4)
-        self._obj = o
+        self.obj = o
 
         localv2 = Signal(4)
         m.d.sync += localv2.eq(localv2 + 3)
@@ -130,18 +131,20 @@ class PipelineStageObjectExample:
         #m.d.comb += self.obj.a.eq(localv2 + 1)
         #m.d.sync += self._loopback.eq(localv2)
 
+        ispec= {'loopback': self.loopback, 'obj': self.obj}
         with PipeManager(m, pipemode=True) as pipe:
 
-            with pipe.Stage("first",
-                            ispec=[self._loopback, self._obj]) as (p, m):
-                p.n = ~self._loopback
-                p.o = self._obj
+            with pipe.Stage("first", ispec=ispec) as (p, m):
+                p.n = ~p.loopback
+                p.o = p.obj
             with pipe.Stage("second", p) as (p, m):
-                #p.n = ~self._loopback + 2
-                p.n = p.n + Const(2)
+                #p.n = ~self.loopback + 2
+                localn = Signal(4)
+                m.d.comb += localn.eq(p.n)
                 o = ObjectProxy(None, pipemode=False)
-                o.a = p.n
-                o.b = p.o.b + p.n + Const(5)
+                o.c = localn
+                o.d = p.o.b + localn + Const(5)
+                p.n = localn
                 p.o = o
             with pipe.Stage("third", p) as (p, m):
                 #p.n = ~self._loopback + 5
@@ -149,7 +152,31 @@ class PipelineStageObjectExample:
                 m.d.comb += localv.eq(2)
                 p.n = p.n << localv
                 o = ObjectProxy(None, pipemode=False)
-                o.b = p.n + p.o.b + p.o.a
+                o.e = p.n + p.o.c + p.o.d
+                p.o = o
+
+        print ("stages", pipe.stages)
+
+        return m
+
+
+class PipelineStageObjectExample2:
+
+    def __init__(self):
+        self._loopback = Signal(4)
+
+    def elaborate(self, platform=None):
+
+        m = Module()
+
+        ispec= [self._loopback]
+        with PipeManager(m, pipemode=True) as pipe:
+
+            with pipe.Stage("first",
+                            ispec=ispec) as (p, m):
+                p.n = ~self._loopback
+                o = ObjectProxy(None, pipemode=False)
+                o.b = ~self._loopback + Const(5)
                 p.o = o
 
         print ("stages", pipe.stages)
@@ -169,8 +196,9 @@ if __name__ == "__main__":
         f.write(rtlil.convert(example, ports=[
                example._loopback,
              ]))
+    #exit(0)
     example = PipelineStageObjectExample()
     with open("pipe_stage_object_module.il", "w") as f:
         f.write(rtlil.convert(example, ports=[
-               example._loopback,
+               example.loopback,
              ]))