add FPPackData and return as ospec

[ieee754fpu.git] / src / add / nmigen_add_experiment.py

diff --git a/src/add/nmigen_add_experiment.py b/src/add/nmigen_add_experiment.py
index 6f92d68edeb1d614f0ef4454990622397d6bf927..72ac841bf2bbb3b00fa8e55e610e30512caafe5f 100644 (file)
--- a/src/add/nmigen_add_experiment.py
+++ b/src/add/nmigen_add_experiment.py
@@ -247,12 +247,13 @@ class FPGet2Op(FPState):
 
 class FPNumBase2Ops:
 
-    def __init__(self, width, m_extra=True):
+    def __init__(self, width, id_wid, m_extra=True):
         self.a = FPNumBase(width, m_extra)
         self.b = FPNumBase(width, m_extra)
+        self.mid = Signal(id_wid, reset_less=True)
 
     def eq(self, i):
-        return [self.a.eq(i.a), self.b.eq(i.b)]
+        return [self.a.eq(i.a), self.b.eq(i.b), self.mid.eq(i.mid)]
 
 
 class FPAddSpecialCasesMod:
@@ -261,14 +262,15 @@ class FPAddSpecialCasesMod:
         https://steve.hollasch.net/cgindex/coding/ieeefloat.html
     """
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.out_z = self.ospec()
         self.out_do_z = Signal(reset_less=True)
 
     def ispec(self):
-        return FPNumBase2Ops(self.width)
+        return FPNumBase2Ops(self.width, self.id_wid)
 
     def ospec(self):
         return FPNumOut(self.width, False)
@@ -419,11 +421,11 @@ class FPAddSpecialCasesDeNorm(FPState, FPID):
     def __init__(self, width, id_wid):
         FPState.__init__(self, "special_cases")
         FPID.__init__(self, id_wid)
-        self.smod = FPAddSpecialCasesMod(width)
+        self.smod = FPAddSpecialCasesMod(width, id_wid)
         self.out_z = self.smod.ospec()
         self.out_do_z = Signal(reset_less=True)
 
-        self.dmod = FPAddDeNormMod(width)
+        self.dmod = FPAddDeNormMod(width, id_wid)
         self.o = self.dmod.ospec()
 
     def setup(self, m, in_a, in_b, in_mid):
@@ -447,16 +449,17 @@ class FPAddSpecialCasesDeNorm(FPState, FPID):
 
 class FPAddDeNormMod(FPState):
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.o = self.ospec()
 
     def ispec(self):
-        return FPNumBase2Ops(self.width)
+        return FPNumBase2Ops(self.width, self.id_wid)
 
     def ospec(self):
-        return FPNumBase2Ops(self.width)
+        return FPNumBase2Ops(self.width, self.id_wid)
 
     def setup(self, m, in_a, in_b):
         """ links module to inputs and outputs
@@ -585,26 +588,28 @@ class FPAddAlignMulti(FPState, FPID):
 
 class FPNumIn2Ops:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.a = FPNumIn(None, width)
         self.b = FPNumIn(None, width)
+        self.mid = Signal(id_wid, reset_less=True)
 
     def eq(self, i):
-        return [self.a.eq(i.a), self.b.eq(i.b)]
+        return [self.a.eq(i.a), self.b.eq(i.b), self.mid.eq(i.mid)]
 
 
 class FPAddAlignSingleMod:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.o = self.ospec()
 
     def ispec(self):
-        return FPNumBase2Ops(self.width)
+        return FPNumBase2Ops(self.width, self.id_wid)
 
     def ospec(self):
-        return FPNumIn2Ops(self.width)
+        return FPNumIn2Ops(self.width, self.id_wid)
 
     def setup(self, m, in_a, in_b):
         """ links module to inputs and outputs
@@ -683,7 +688,7 @@ class FPAddAlignSingle(FPState, FPID):
     def __init__(self, width, id_wid):
         FPState.__init__(self, "align")
         FPID.__init__(self, id_wid)
-        self.mod = FPAddAlignSingleMod(width)
+        self.mod = FPAddAlignSingleMod(width, id_wid)
         self.out_a = FPNumIn(None, width)
         self.out_b = FPNumIn(None, width)
 
@@ -707,13 +712,13 @@ class FPAddAlignSingleAdd(FPState, FPID):
     def __init__(self, width, id_wid):
         FPState.__init__(self, "align")
         FPID.__init__(self, id_wid)
-        self.mod = FPAddAlignSingleMod(width)
+        self.mod = FPAddAlignSingleMod(width, id_wid)
         self.o = self.mod.ospec()
 
-        self.a0mod = FPAddStage0Mod(width)
+        self.a0mod = FPAddStage0Mod(width, id_wid)
         self.a0o = self.a0mod.ospec()
 
-        self.a1mod = FPAddStage1Mod(width)
+        self.a1mod = FPAddStage1Mod(width, id_wid)
         self.a1o = self.a1mod.ospec()
 
     def setup(self, m, in_a, in_b, in_mid):
@@ -738,26 +743,28 @@ class FPAddAlignSingleAdd(FPState, FPID):
 
 class FPAddStage0Data:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.z = FPNumBase(width, False)
         self.tot = Signal(self.z.m_width + 4, reset_less=True)
+        self.mid = Signal(id_wid, reset_less=True)
 
     def eq(self, i):
-        return [self.z.eq(i.z), self.tot.eq(i.tot)]
+        return [self.z.eq(i.z), self.tot.eq(i.tot), self.mid.eq(i.mid)]
 
 
 class FPAddStage0Mod:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.o = self.ospec()
 
     def ispec(self):
-        return FPNumBase2Ops(self.width)
+        return FPNumBase2Ops(self.width, self.id_wid)
 
     def ospec(self):
-        return FPAddStage0Data(self.width)
+        return FPAddStage0Data(self.width, self.id_wid)
 
     def setup(self, m, in_a, in_b):
         """ links module to inputs and outputs
@@ -833,12 +840,13 @@ class FPAddStage0(FPState, FPID):
 
 class FPAddStage1Data:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.z = FPNumBase(width, False)
         self.of = Overflow()
+        self.mid = Signal(id_wid, reset_less=True)
 
     def eq(self, i):
-        return [self.z.eq(i.z), self.of.eq(i.of)]
+        return [self.z.eq(i.z), self.of.eq(i.of), self.mid.eq(i.mid)]
 
 
 
@@ -847,16 +855,17 @@ class FPAddStage1Mod(FPState):
         detects when tot sum is too big (tot[27] is kinda a carry bit)
     """
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.o = self.ospec()
 
     def ispec(self):
-        return FPAddStage0Data(self.width)
+        return FPAddStage0Data(self.width, self.id_wid)
 
     def ospec(self):
-        return FPAddStage1Data(self.width)
+        return FPAddStage1Data(self.width, self.id_wid)
 
     def setup(self, m, in_tot, in_z):
         """ links module to inputs and outputs
@@ -937,7 +946,7 @@ class FPNormaliseModSingle:
     def ospec(self):
         return FPNumBase(self.width, False)
 
-    def setup(self, m, in_z, out_z, modname):
+    def setup(self, m, in_z, out_z):
         """ links module to inputs and outputs
         """
         m.submodules.normalise = self
@@ -994,27 +1003,28 @@ class FPNormaliseModSingle:
 
 class FPNorm1Data:
 
-    def __init__(self, width):
-
+    def __init__(self, width, id_wid):
         self.roundz = Signal(reset_less=True)
         self.z = FPNumBase(width, False)
+        self.mid = Signal(id_wid, reset_less=True)
 
     def eq(self, i):
-        return [self.z.eq(i.z), self.roundz.eq(i.roundz)]
+        return [self.z.eq(i.z), self.roundz.eq(i.roundz), self.mid.eq(i.mid)]
 
 
 class FPNorm1ModSingle:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
-        self.o = self.ispec()
+        self.o = self.ospec()
 
     def ispec(self):
-        return FPAddStage1Data(self.width)
+        return FPAddStage1Data(self.width, self.id_wid)
 
     def ospec(self):
-        return FPAddStage1Data(self.width) # XXX TODO: FPNorm1Data
+        return FPNorm1Data(self.width, self.id_wid)
 
     def setup(self, m, in_z, in_of, out_z):
         """ links module to inputs and outputs
@@ -1033,8 +1043,11 @@ class FPNorm1ModSingle:
         pe = PriorityEncoder(mwid)
         m.submodules.norm_pe = pe
 
+        of = Overflow()
+        m.d.comb += self.o.roundz.eq(of.roundz)
+
         m.submodules.norm1_out_z = self.o.z
-        m.submodules.norm1_out_overflow = self.o.of
+        m.submodules.norm1_out_overflow = of
         m.submodules.norm1_in_z = self.i.z
         m.submodules.norm1_in_overflow = self.i.of
 
@@ -1049,7 +1062,8 @@ class FPNorm1ModSingle:
 
         m.d.comb += i.eq(self.i)
         # initialise out from in (overridden below)
-        m.d.comb += self.o.eq(i)
+        m.d.comb += self.o.z.eq(i.z)
+        m.d.comb += of.eq(i.of)
         # normalisation increase/decrease conditions
         decrease = Signal(reset_less=True)
         increase = Signal(reset_less=True)
@@ -1075,10 +1089,10 @@ class FPNorm1ModSingle:
                 temp_s.eq(temp_m << clz),       # shift mantissa UP
                 self.o.z.e.eq(i.z.e - clz),  # DECREASE exponent
                 self.o.z.m.eq(temp_s[2:]),    # exclude bits 0&1
-                self.o.of.m0.eq(temp_s[2]),   # copy of mantissa[0]
+                of.m0.eq(temp_s[2]),          # copy of mantissa[0]
                 # overflow in bits 0..1: got shifted too (leave sticky)
-                self.o.of.guard.eq(temp_s[1]),     # guard
-                self.o.of.round_bit.eq(temp_s[0]), # round
+                of.guard.eq(temp_s[1]),       # guard
+                of.round_bit.eq(temp_s[0]),   # round
             ]
         # increase exponent
         with m.Elif(increase):
@@ -1091,11 +1105,11 @@ class FPNorm1ModSingle:
                 msr.inp.eq(temp_m),
                 msr.diff.eq(ediff_n126),
                 self.o.z.m.eq(msr.m[3:]),
-                self.o.of.m0.eq(temp_s[3]),   # copy of mantissa[0]
+                of.m0.eq(temp_s[3]),   # copy of mantissa[0]
                 # overflow in bits 0..1: got shifted too (leave sticky)
-                self.o.of.guard.eq(temp_s[2]),     # guard
-                self.o.of.round_bit.eq(temp_s[1]), # round
-                self.o.of.sticky.eq(temp_s[0]), # sticky
+                of.guard.eq(temp_s[2]),     # guard
+                of.round_bit.eq(temp_s[1]), # round
+                of.sticky.eq(temp_s[0]),    # sticky
                 self.o.z.e.eq(i.z.e + ediff_n126),
             ]
 
@@ -1251,27 +1265,26 @@ class FPNormToPack(FPState, FPID):
         """
 
         # Normalisation (chained to input in_z+in_of)
-        nmod = FPNorm1ModSingle(self.width)
-        n_out_z = FPNumBase(self.width)
-        n_out_roundz = Signal(reset_less=True)
-        nmod.setup(m, in_z, in_of, n_out_z)
+        nmod = FPNorm1ModSingle(self.width, self.id_wid)
+        n_out = nmod.ospec()
+        nmod.setup(m, in_z, in_of, n_out.z)
+        m.d.comb += n_out.roundz.eq(nmod.o.roundz)
 
         # Rounding (chained to normalisation)
-        rmod = FPRoundMod(self.width)
-        r_out_z = FPNumBase(self.width)
-        rmod.setup(m, n_out_z, n_out_roundz)
-        m.d.comb += n_out_roundz.eq(nmod.o.of.roundz)
+        rmod = FPRoundMod(self.width, self.id_wid)
+        r_out_z = rmod.ospec()
+        rmod.setup(m, n_out.z, n_out.roundz)
         m.d.comb += r_out_z.eq(rmod.out_z)
 
         # Corrections (chained to rounding)
-        cmod = FPCorrectionsMod(self.width)
-        c_out_z = FPNumBase(self.width)
+        cmod = FPCorrectionsMod(self.width, self.id_wid)
+        c_out_z = cmod.ospec()
         cmod.setup(m, r_out_z)
         m.d.comb += c_out_z.eq(cmod.out_z)
 
         # Pack (chained to corrections)
-        self.pmod = FPPackMod(self.width)
-        self.out_z = FPNumBase(self.width)
+        self.pmod = FPPackMod(self.width, self.id_wid)
+        self.out_z = self.pmod.ospec()
         self.pmod.setup(m, c_out_z)
 
         # Multiplex ID
@@ -1280,22 +1293,33 @@ class FPNormToPack(FPState, FPID):
 
     def action(self, m):
         self.idsync(m) # copies incoming ID to outgoing
-        m.d.sync += self.out_z.v.eq(self.pmod.out_z.v) # outputs packed result
+        m.d.sync += self.out_z.z.v.eq(self.pmod.o.z.v) # outputs packed result
         m.next = "pack_put_z"
 
 
+class FPRoundData:
+
+    def __init__(self, width, id_wid):
+        self.z = FPNumBase(width, False)
+        self.mid = Signal(id_wid, reset_less=True)
+
+    def eq(self, i):
+        return [self.z.eq(i.z), self.mid.eq(i.mid)]
+
+
 class FPRoundMod:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.i = self.ispec()
         self.out_z = self.ospec()
 
     def ispec(self):
-        return FPNorm1Data(self.width)
+        return FPNorm1Data(self.width, self.id_wid)
 
     def ospec(self):
-        return FPNumBase(self.width, False)
+        return FPRoundData(self.width, self.id_wid)
 
     def setup(self, m, in_z, roundz):
         m.submodules.roundz = self
@@ -1305,11 +1329,11 @@ class FPRoundMod:
 
     def elaborate(self, platform):
         m = Module()
-        m.d.comb += self.out_z.eq(self.i.z)
+        m.d.comb += self.out_z.eq(self.i)
         with m.If(self.i.roundz):
-            m.d.comb += self.out_z.m.eq(self.i.z.m + 1) # mantissa rounds up
+            m.d.comb += self.out_z.z.m.eq(self.i.z.m + 1) # mantissa rounds up
             with m.If(self.i.z.m == self.i.z.m1s): # all 1s
-                m.d.comb += self.out_z.e.eq(self.i.z.e + 1) # exponent up
+                m.d.comb += self.out_z.z.e.eq(self.i.z.e + 1) # exponent up
         return m
 
 
@@ -1337,16 +1361,17 @@ class FPRound(FPState, FPID):
 
 class FPCorrectionsMod:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
+        self.id_wid = id_wid
         self.in_z = self.ispec()
         self.out_z = self.ospec()
 
     def ispec(self):
-        return FPNumOut(self.width, False)
+        return FPRoundData(self.width, self.id_wid)
 
     def ospec(self):
-        return FPNumOut(self.width, False)
+        return FPRoundData(self.width, self.id_wid)
 
     def setup(self, m, in_z):
         """ links module to inputs and outputs
@@ -1356,11 +1381,11 @@ class FPCorrectionsMod:
 
     def elaborate(self, platform):
         m = Module()
-        m.submodules.corr_in_z = self.in_z
-        m.submodules.corr_out_z = self.out_z
+        m.submodules.corr_in_z = self.in_z.z
+        m.submodules.corr_out_z = self.out_z.z
         m.d.comb += self.out_z.eq(self.in_z)
-        with m.If(self.in_z.is_denormalised):
-            m.d.comb += self.out_z.e.eq(self.in_z.N127)
+        with m.If(self.in_z.z.is_denormalised):
+            m.d.comb += self.out_z.z.e.eq(self.in_z.z.N127)
         return m
 
 
@@ -1385,42 +1410,68 @@ class FPCorrections(FPState, FPID):
         m.next = "pack"
 
 
+class FPPackData:
+
+    def __init__(self, width, id_wid):
+        self.z = FPNumOut(width, False)
+        self.mid = Signal(id_wid, reset_less=True)
+
+    def eq(self, i):
+        return [self.z.eq(i.z), self.mid.eq(i.mid)]
+
+
 class FPPackMod:
 
-    def __init__(self, width):
+    def __init__(self, width, id_wid):
         self.width = width
-        self.in_z = self.ispec()
-        self.out_z = self.ospec()
+        self.id_wid = id_wid
+        self.i = self.ispec()
+        self.o = self.ospec()
 
     def ispec(self):
-        return FPNumOut(self.width, False)
+        return FPRoundData(self.width, self.id_wid)
 
     def ospec(self):
-        return FPNumOut(self.width, False)
+        return FPPackData(self.width, self.id_wid)
 
     def setup(self, m, in_z):
         """ links module to inputs and outputs
         """
         m.submodules.pack = self
-        m.d.comb += self.in_z.eq(in_z)
+        m.d.comb += self.i.eq(in_z)
 
     def elaborate(self, platform):
         m = Module()
-        m.submodules.pack_in_z = self.in_z
-        with m.If(self.in_z.is_overflowed):
-            m.d.comb += self.out_z.inf(self.in_z.s)
+        m.submodules.pack_in_z = self.i.z
+        with m.If(self.i.z.is_overflowed):
+            m.d.comb += self.o.z.inf(self.i.z.s)
         with m.Else():
-            m.d.comb += self.out_z.create(self.in_z.s, self.in_z.e, self.in_z.m)
+            m.d.comb += self.o.z.create(self.i.z.s, self.i.z.e, self.i.z.m)
         return m
 
 
+class FPPackData:
+    def __init__(self, width, id_wid):
+        self.z = FPNumOut(width, False)
+        self.mid = Signal(id_wid, reset_less=True)
+
+    def eq(self, i):
+        return [self.z.eq(i.z), self.mid.eq(i.mid)]
+
+
 class FPPack(FPState, FPID):
 
     def __init__(self, width, id_wid):
         FPState.__init__(self, "pack")
         FPID.__init__(self, id_wid)
         self.mod = FPPackMod(width)
-        self.out_z = self.mod.ospec()
+        self.out_z = self.ospec()
+
+    def ispec(self):
+        return self.mod.ispec()
+
+    def ospec(self):
+        return self.mod.ospec()
 
     def setup(self, m, in_z, in_mid):
         """ links module to inputs and outputs
@@ -1598,7 +1649,7 @@ class FPADDBaseMod(FPID):
         n1 = self.add_state(FPNormToPack(self.width, self.id_wid))
         n1.setup(m, alm.a1o.z, alm.a1o.of, alm.in_mid)
 
-        ppz = self.add_state(FPPutZ("pack_put_z", n1.out_z, self.out_z,
+        ppz = self.add_state(FPPutZ("pack_put_z", n1.out_z.z, self.out_z,
                                     n1.in_mid, self.out_mid))
 
         pz = self.add_state(FPPutZ("put_z", sc.out_z, self.out_z,