Special cares of fixed-point in AddN and Madd.

Author: shtaxxx

veriloggen/stream/stypes.py

@@ -1625,12 +1625,107 @@ def _implement(self, m, seq, svalid=None, senable=None):
         m.Instance(inst, self.name('lut'), ports=ports)
 
 
-class TimesPlus(_SpecialOperator):
+class _Delay(_UnaryOperator):
+
+    def __init__(self, right):
+        _UnaryOperator.__init__(self, right)
+        # parent value for delayed_value and previous_value
+        self.parent_value = None
+
+    def _set_parent_value(self, value):
+        self.parent_value = value
+
+    def _get_parent_value(self):
+        return self.parent_value
+
+    def eval(self):
+        return self
+
+    def _implement(self, m, seq, svalid=None, senable=None):
+        if self.latency != 1:
+            raise ValueError("Latency mismatch '%d' vs '%s'" %
+                             (self.latency, 1))
+
+        width = self.bit_length()
+        signed = self.get_signed()
+        rdata = self.right.sig_data
+
+        data = m.Reg(self.name('data'), width, initval=0, signed=signed)
+        self.sig_data = data
+
+        seq(data(rdata), cond=senable)
+
+
+class _Prev(_UnaryOperator):
+    latency = 0
+
+    def __init__(self, right):
+        _UnaryOperator.__init__(self, right)
+        # parent value for delayed_value and previous_value
+        self.parent_value = None
+
+    def _set_parent_value(self, value):
+        self.parent_value = value
+
+    def _get_parent_value(self):
+        return self.parent_value
+
+    def eval(self):
+        return self
+
+    def _implement(self, m, seq, svalid=None, senable=None):
+        if self.latency != 0:
+            raise ValueError("Latency mismatch '%d' vs '%s'" %
+                             (self.latency, 0))
+
+        width = self.bit_length()
+        signed = self.get_signed()
+        rdata = self.right.sig_data
+
+        data = m.Reg(self.name('data'), width, initval=0, signed=signed)
+        self.sig_data = data
+
+        seq(data(rdata), cond=senable)
+
+
+class _PlusN(_SpecialOperator):
+    latency = 1
+
+    def __init__(self, *vars):
+        _SpecialOperator.__init__(self, *vars)
+
+        for arg in self.args:
+            if arg.point != 0:
+                raise ValueError('Fixed point is not supported.')
+
+        def func(*args):
+            ret = args[0]
+            for arg in args[1:]:
+                ret += arg
+            return ret
+
+        self.op = func
+
+    def eval(self):
+        vars = [var.eval() for var in self.vars]
+        for var in vars:
+            if not isinstance(var, int):
+                return PlusN(*vars)
+        ret = 0
+        for var in vars:
+            ret += var
+        return ret
+
+
+class _MulAdd(_SpecialOperator):
     latency = 6 + 1
 
     def __init__(self, a, b, c):
         _SpecialOperator.__init__(self, a, b, c)
 
+        if self.a.point + self.b.point != self.c.point:
+            raise ValueError('Unsupported fixed point combination')
+
     @property
     def a(self):
         return self.args[0]
@@ -1686,9 +1781,6 @@ def _implement(self, m, seq, svalid=None, senable=None):
         bdata = self.b.sig_data
         cdata = self.c.sig_data
 
-        if apoint + bpoint != cpoint:
-            raise ValueError('apoint + bpoint == cpoint')
-
         odata = m.Wire(self.name('madd_odata'),
                        max(awidth + bwidth, cwidth), signed=signed)
         odata_reg = m.Reg(self.name('madd_odata_reg'),
@@ -1729,131 +1821,62 @@ def eval(self):
 
 
 def MulAdd(a, b, c):
-    return TimesPlus(a, b, c)
+    a_point = a.point if isinstance(a, _Numeric) else 0
+    b_point = b.point if isinstance(b, _Numeric) else 0
+    c_point = c.point if isinstance(c, _Numeric) else 0
+    if a_point + b_point != c_point:
+        return Plus(Times(a, b), c)
+
+    return _MulAdd(a, b, c)
 
 
 def Madd(a, b, c):
-    return TimesPlus(a, b, c)
+    return MulAdd(a, b, c)
 
 
-class PlusN(_SpecialOperator):
-    latency = 1
+def op_tree(op, initval=0, latency=None, *args):
+    if len(args) == 1:
+        return args[0]
+    if len(args) == 0:
+        return initval
+    half_len = len(args) // 2
+    ret = op(op_tree(op, initval, latency, *args[:half_len]),
+             op_tree(op, initval, latency, *args[half_len:]))
+    if latency is not None:
+        ret.latency = latency
+    return ret
 
-    def __init__(self, *vars):
-        _SpecialOperator.__init__(self, *vars)
 
-        def func(*args):
-            ret = args[0]
-            for arg in args[1:]:
-                ret += arg
+def PlusN(*args):
+    for arg in args:
+        if isinstance(arg, _Numeric) and arg.point != 0:
+            ret = op_tree(Plus, 0, 0, *args)
+            ret.latency = 1
             return ret
 
-        self.op = func
-
-    def eval(self):
-        vars = [var.eval() for var in self.vars]
-        for var in vars:
-            if not isinstance(var, int):
-                return PlusN(*vars)
-        ret = 0
-        for var in vars:
-            ret += var
-        return ret
-
+    return _PlusN(*args)
 
-def AddN(*vars):
-    return PlusN(*vars)
 
-
-class _Delay(_UnaryOperator):
-
-    def __init__(self, right):
-        _UnaryOperator.__init__(self, right)
-        # parent value for delayed_value and previous_value
-        self.parent_value = None
-
-    def _set_parent_value(self, value):
-        self.parent_value = value
-
-    def _get_parent_value(self):
-        return self.parent_value
-
-    def eval(self):
-        return self
-
-    def _implement(self, m, seq, svalid=None, senable=None):
-        if self.latency != 1:
-            raise ValueError("Latency mismatch '%d' vs '%s'" %
-                             (self.latency, 1))
-
-        width = self.bit_length()
-        signed = self.get_signed()
-        rdata = self.right.sig_data
-
-        data = m.Reg(self.name('data'), width, initval=0, signed=signed)
-        self.sig_data = data
-
-        seq(data(rdata), cond=senable)
-
-
-class _Prev(_UnaryOperator):
-    latency = 0
-
-    def __init__(self, right):
-        _UnaryOperator.__init__(self, right)
-        # parent value for delayed_value and previous_value
-        self.parent_value = None
-
-    def _set_parent_value(self, value):
-        self.parent_value = value
-
-    def _get_parent_value(self):
-        return self.parent_value
-
-    def eval(self):
-        return self
-
-    def _implement(self, m, seq, svalid=None, senable=None):
-        if self.latency != 0:
-            raise ValueError("Latency mismatch '%d' vs '%s'" %
-                             (self.latency, 0))
-
-        width = self.bit_length()
-        signed = self.get_signed()
-        rdata = self.right.sig_data
-
-        data = m.Reg(self.name('data'), width, initval=0, signed=signed)
-        self.sig_data = data
-
-        seq(data(rdata), cond=senable)
-
-
-def op_tree(op, initval=0, *args):
-    if len(args) == 1:
-        return args[0]
-    if len(args) == 0:
-        return initval
-    half_len = len(args) // 2
-    return op(op_tree(op, initval, *args[:half_len]),
-              op_tree(op, initval, *args[half_len:]))
+def AddN(*args):
+    return PlusN(*args)
 
 
 def AddTree(*args):
-    return op_tree(Plus, 0, *args)
+    return op_tree(Plus, 0, None, *args)
 
 
 def Max(*args):
     if len(args) == 1:
         return args[0]
     initval = args[0]
-    return op_tree(lambda x, y: Mux(x > y, x, y), initval, *args)
+    return op_tree(lambda x, y: Mux(x > y, x, y), initval, None, *args)
 
 
 def Min(*args):
     if len(args) == 1:
         return args[0]
     initval = args[0]
-    return op_tree(lambda x, y: Mux(x < y, x, y), initval, *args)
+    return op_tree(lambda x, y: Mux(x < y, x, y), initval, None, *args)
 
 
 def Average(*args):