Merge branch 'develop' into feature_axi_stream

Author: shtaxxx

veriloggen/stream/graph.py

@@ -212,6 +212,10 @@ def visit__Accumulator(self, node):
                             peripheries=peripheries)
 
         right = self.visit(node.right)
+        if node.size is not None:
+            size = self.visit(node.size)
+        if node.interval is not None:
+            interval = self.visit(node.interval)
         initval = self.visit(node.initval)
         if node.dependency is not None:
             dependency = self.visit(node.dependency)
@@ -220,6 +224,10 @@ def visit__Accumulator(self, node):
         if node.reset is not None:
             reset = self.visit(node.reset)
         self.graph.add_edge(right, node, label='data')
+        if node.size is not None:
+            self.graph.add_edge(size, node, label='size')
+        if node.interval is not None:
+            self.graph.add_edge(interval, node, label='interval')
         self.graph.add_edge(initval, node, label='initval')
         if node.dependency is not None:
             self.graph.add_edge(dependency, node, label='dependency')

veriloggen/stream/scheduler.py

@@ -121,13 +121,20 @@ def visit__Accumulator(self, node):
         if node._has_start_stage():
             return node._get_end_stage()
         right = self.visit(node.right)
+        size = self.visit(node.size) if node.size is not None else None
+        interval = (self.visit(node.interval)
+                    if node.interval is not None else None)
         initval = self.visit(node.initval)
         dependency = (self.visit(node.dependency)
                       if node.dependency is not None else None)
         enable = self.visit(node.enable) if node.enable is not None else None
         reset = self.visit(node.reset) if node.reset is not None else None
-        mine = self.max_stage(right, initval, dependency, enable, reset)
+        mine = self.max_stage(right, size, interval, initval, dependency, enable, reset)
         node.right = self.fill_gap(node.right, mine)
+        if node.size is not None:
+            node.size = self.fill_gap(node.size, mine)
+        if node.interval is not None:
+            node.interval = self.fill_gap(node.interval, mine)
         node.initval = self.fill_gap(node.initval, mine)
         if node.enable is not None:
             node.enable = self.fill_gap(node.enable, mine)

veriloggen/stream/stypes.py

@@ -2465,13 +2465,13 @@ class _Accumulator(_UnaryOperator):
     latency = 1
     ops = (vtypes.Plus, )
 
-    def __init__(self, right, size=None, initval=None, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=None,
                  dependency=None, enable=None, reset=None, width=32, signed=True):
 
         self.size = _to_constant(size) if size is not None else None
+        self.interval = _to_constant(interval) if interval is not None else None
         self.initval = (_to_constant(initval)
                         if initval is not None else _to_constant(0))
-        self.interval = _to_constant(interval) if interval is not None else None
 
         if not isinstance(self.initval, _Constant):
             raise TypeError("initval must be Constant, not '%s'" %
@@ -2662,21 +2662,21 @@ def _implement(self, m, seq, svalid=None, senable=None):
 class ReduceAdd(_Accumulator):
     ops = (vtypes.Plus, )
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceAdd'
 
 
 class ReduceSub(_Accumulator):
     ops = (vtypes.Minus, )
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceSub'
 
@@ -2685,10 +2685,10 @@ class ReduceMul(_Accumulator):
     latency = 1
     ops = (vtypes.Times, )
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceMul'
 
@@ -2697,43 +2697,43 @@ class ReduceDiv(_Accumulator):
     latency = 32
     ops = ()
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         raise NotImplementedError()
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceDiv'
 
 
 class ReduceMax(_Accumulator):
     ops = (lambda x, y: vtypes.Mux(x < y, y, x), )
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceMax'
 
 
 class ReduceMin(_Accumulator):
     ops = (lambda x, y: vtypes.Mux(x > y, y, x), )
 
-    def __init__(self, right, size=None, initval=0, interval=None,
+    def __init__(self, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'ReduceMin'
 
 
 class ReduceCustom(_Accumulator):
 
-    def __init__(self, ops, right, size=None, initval=0, interval=None,
+    def __init__(self, ops, right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True, label=None):
         dependency = None
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         if not isinstance(ops, (tuple, list)):
             ops = tuple([ops])
@@ -2743,10 +2743,10 @@ def __init__(self, ops, right, size=None, initval=0, interval=None,
 
 class Counter(_Accumulator):
 
-    def __init__(self, size=None, step=1, initval=0, interval=None,
+    def __init__(self, size=None, step=1, interval=None, initval=0,
                  dependency=None, enable=None, reset=None, width=32, signed=False):
 
-        _Accumulator.__init__(self, step, size, initval, interval,
+        _Accumulator.__init__(self, step, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'Counter'
 
@@ -2827,7 +2827,8 @@ def _implement(self, m, seq, svalid=None, senable=None):
 class Pulse(_Accumulator):
     ops = ()
 
-    def __init__(self, size, dependency=None, enable=None, reset=None, interval=None):
+    def __init__(self, size, interval=None,
+                 dependency=None, enable=None, reset=None):
 
         right = 0
         if dependency is not None:
@@ -2837,85 +2838,85 @@ def __init__(self, size, dependency=None, enable=None, reset=None, interval=None
         width = 1
         signed = False
 
-        _Accumulator.__init__(self, right, size, initval, interval,
+        _Accumulator.__init__(self, right, size, interval, initval,
                               dependency, enable, reset, width, signed)
         self.graph_label = 'Pulse'
 
 
-def _ReduceValid(cls, right, size, initval=0, interval=None,
+def _ReduceValid(cls, right, size, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
 
-    data = cls(right, size, initval, interval,
+    data = cls(right, size, interval, initval,
                enable, reset, width, signed)
-    valid = Pulse(size, right, enable, reset)
+    valid = Pulse(size, dependency=right, enable=enable, reset=reset)
 
     return data, valid
 
 
-def ReduceAddValid(right, size, initval=0, interval=None,
+def ReduceAddValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceAdd
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceSubValid(right, size, initval=0, interval=None,
+def ReduceSubValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceSub
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceMulValid(right, size, initval=0, interval=None,
+def ReduceMulValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceMul
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceDivValid(right, size, initval=0, interval=None,
+def ReduceDivValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceDiv
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceMaxValid(right, size, initval=0, interval=None,
+def ReduceMaxValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceMax
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceMinValid(right, size, initval=0, interval=None,
+def ReduceMinValid(right, size, interval=None, initval=0,
                    enable=None, reset=None, width=32, signed=True):
 
     cls = ReduceMin
-    return _ReduceValid(cls, right, size, initval, interval,
+    return _ReduceValid(cls, right, size, interval, initval,
                         enable, reset, width, signed)
 
 
-def ReduceCustomValid(ops, right, size, initval=0, interval=None,
+def ReduceCustomValid(ops, right, size, interval=None, initval=0,
                       enable=None, reset=None, width=32, signed=True):
 
-    data = ReduceCustom(ops, right, size, initval, interval,
+    data = ReduceCustom(ops, right, size, interval, initval,
                         enable, reset, width, signed)
-    valid = Pulse(size, right, enable, reset)
+    valid = Pulse(size, dependency=right, enable=enable, reset=reset)
 
     return data, valid
 
 
-def CounterValid(size, step=1, initval=0, interval=None,
+def CounterValid(size, step=1, interval=None, initval=0,
                  dependency=None, enable=None, reset=None, width=32, signed=False):
 
-    data = Counter(size, step, initval, interval,
+    data = Counter(size, step, interval, initval,
                    dependency, enable, reset, width, signed)
-    valid = Pulse(size, dependency, enable, reset)
+    valid = Pulse(size, dependency=dependency, enable=enable, reset=reset)
 
     return data, valid
 
@@ -3576,10 +3577,10 @@ def enable(self):
         return _and_vars(vtypes.Not(self.args[2].sig_data), when_cond)
 
 
-def ReduceArgMax(right, size=None, initval=0, interval=None,
+def ReduceArgMax(right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
 
-    _max = ReduceMax(right, size, initval, interval,
+    _max = ReduceMax(right, size, interval, initval,
                      enable, reset, width, signed)
     counter = Counter(size, dependency=right, enable=enable, reset=reset)
     update = NotEq(_max, _max.prev(1))
@@ -3588,10 +3589,10 @@ def ReduceArgMax(right, size=None, initval=0, interval=None,
     return index, _max
 
 
-def ReduceArgMin(right, size=None, initval=0, interval=None,
+def ReduceArgMin(right, size=None, interval=None, initval=0,
                  enable=None, reset=None, width=32, signed=True):
 
-    _min = ReduceMin(right, size, initval, interval,
+    _min = ReduceMin(right, size, interval, initval,
                      enable, reset, width, signed)
     counter = Counter(size, dependency=right, enable=enable, reset=reset)
     update = NotEq(_min, reduce_min.prev(1))
@@ -3600,10 +3601,10 @@ def ReduceArgMin(right, size=None, initval=0, interval=None,
     return index, _min
 
 
-def ReduceArgMaxValid(right, size=None, initval=0, interval=None,
+def ReduceArgMaxValid(right, size=None, interval=None, initval=0,
                       enable=None, reset=None, width=32, signed=True):
 
-    _max, valid = ReduceMaxValid(right, size, initval, interval,
+    _max, valid = ReduceMaxValid(right, size, interval, initval,
                                  enable, reset, width, signed)
     counter = Counter(size, dependency=right, enable=enable, reset=reset)
     update = NotEq(_max, _max.prev(1))
@@ -3612,10 +3613,10 @@ def ReduceArgMaxValid(right, size=None, initval=0, interval=None,
     return index, _max, valid
 
 
-def ReduceArgMinValid(right, size=None, initval=0, interval=None,
+def ReduceArgMinValid(right, size=None, interval=None, initval=0,
                       enable=None, reset=None, width=32, signed=True):
 
-    _min, valid = ReduceMinValid(right, size, initval, interval,
+    _min, valid = ReduceMinValid(right, size, interval, initval,
                                  enable, reset, width, signed)
     counter = Counter(size, dependency=right, enable=enable, reset=reset)
     update = NotEq(_min, _min.prev(1))

veriloggen/stream/visitor.py

@@ -125,13 +125,15 @@ def visit__SpecialOperator(self, node):
     def visit__Accumulator(self, node):
         right = self.visit(node.right)
         size = self.visit(node.size) if node.size is not None else set()
+        interval = (self.visit(node.interval)
+                    if node.interval is not None else set())
         initval = (self.visit(node.initval)
                    if node.initval is not None else set())
         dependency = (self.visit(node.dependency)
                       if node.dependency is not None else set())
         enable = self.visit(node.enable) if node.enable is not None else set()
         reset = self.visit(node.reset) if node.reset is not None else set()
-        return right | size | initval | dependency | enable | reset
+        return right | size | interval | initval | dependency | enable | reset
 
     def visit_Substream(self, node):
         return self.visit__SpecialOperator(node)
@@ -195,6 +197,8 @@ def visit__SpecialOperator(self, node):
     def visit__Accumulator(self, node):
         right = self.visit(node.right)
         size = self.visit(node.size) if node.size is not None else set()
+        interval = (self.visit(node.interval)
+                    if node.interval is not None else set())
         initval = (self.visit(node.initval)
                    if node.initval is not None else set())
         dependency = (self.visit(node.dependency)
@@ -203,7 +207,7 @@ def visit__Accumulator(self, node):
         #reset = self.visit(node.reset) if node.reset is not None else set()
         reset = set()
         mine = set([node]) if node._has_output() else set()
-        return right | size | initval | dependency | enable | reset | mine
+        return right | size | interval | initval | dependency | enable | reset | mine
 
     def visit_Substream(self, node):
         return self.visit__SpecialOperator(node)
@@ -276,14 +280,16 @@ def visit__SpecialOperator(self, node):
     def visit__Accumulator(self, node):
         right = self.visit(node.right)
         size = self.visit(node.size) if node.size is not None else set()
+        interval = (self.visit(node.interval)
+                    if node.interval is not None else set())
         initval = (self.visit(node.initval)
                    if node.initval is not None else set())
         dependency = (self.visit(node.dependency)
                       if node.dependency is not None else set())
         enable = self.visit(node.enable) if node.enable is not None else set()
         reset = self.visit(node.reset) if node.reset is not None else set()
         mine = set([node])
-        return right | size | initval | dependency | enable | reset | mine
+        return right | size | interval | initval | dependency | enable | reset | mine
 
     def visit_Substream(self, node):
         return self.visit__SpecialOperator(node)