Dump mode of Stream is enhanced for RAM read/write

Author: shtaxxx

tests/extension/thread_/stream_dump_selective/thread_stream_dump_selective.py

@@ -32,6 +32,8 @@ def mkLed():
     c.dump = True
     strm.sink(c, 'c')
 
+    ram_c.dump = True
+
     def comp_stream(size, offset):
         strm.set_source('a', ram_a, offset, size)
         strm.set_source('b', ram_b, offset, size)

veriloggen/stream/stream.py

@@ -231,21 +231,23 @@ def implement(self, m=None, clock=None, reset=None, aswire=None, seq_name=None):
     def add_dump(self, m, seq, input_vars, output_vars, all_vars):
         dump_enable_name = '_stream_dump_enable_%d' % self.object_id
         dump_enable = m.Reg(dump_enable_name, initval=0)
-        dump_iter_name = '_stream_dump_iter_%d' % self.object_id
-        dump_iter = m.Reg(dump_iter_name, 32, initval=0)
+        dump_step_name = '_stream_dump_step_%d' % self.object_id
+        dump_step = m.Reg(dump_step_name, 32, initval=0, signed=True)
 
+        self.dump_step = dump_step
         self.dump_enable = dump_enable
 
         pipeline_depth = self.pipeline_depth()
-        log_pipeline_depth = int(math.ceil(math.log(pipeline_depth, 10)))
+        log_pipeline_depth = max(
+            int(math.ceil(math.log(pipeline_depth, 10))), 1)
 
         seq(
-            dump_iter(0)
+            dump_step(0)
         )
 
         for i in range(pipeline_depth + 1):
             seq.If(seq.Prev(dump_enable, i))(
-                dump_iter.inc()
+                dump_step.inc()
             )
 
         def get_name(obj):
@@ -257,7 +259,9 @@ def get_name(obj):
 
         longest_name_len = 0
         for input_var in sorted(input_vars, key=lambda x: x.object_id):
-            if not (self.dump_mode == 'all' or self.dump_mode == 'input' or
+            if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
+                    self.dump_mode == 'input' or
                     self.dump_mode == 'inout' or
                     (self.dump_mode == 'selective' and
                      hasattr(input_var, 'dump') and input_var.dump)):
@@ -271,6 +275,7 @@ def get_name(obj):
                           if x.end_stage is None else
                           (x.end_stage, x.object_id)):
             if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
                     (self.dump_mode == 'selective' and
                      hasattr(var, 'dump') and var.dump)):
                 continue
@@ -280,7 +285,9 @@ def get_name(obj):
             longest_name_len = max(longest_name_len, length)
 
         for output_var in sorted(output_vars, key=lambda x: x.object_id):
-            if not (self.dump_mode == 'all' or self.dump_mode == 'output' or
+            if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
+                    self.dump_mode == 'output' or
                     self.dump_mode == 'inout' or
                     (self.dump_mode == 'selective' and
                      hasattr(output_var, 'dump') and output_var.dump)):
@@ -325,7 +332,9 @@ def get_name(obj):
 
         enables = []
         for input_var in sorted(input_vars, key=lambda x: x.object_id):
-            if not (self.dump_mode == 'all' or self.dump_mode == 'input' or
+            if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
+                    self.dump_mode == 'input' or
                     self.dump_mode == 'inout' or
                     (self.dump_mode == 'selective' and
                      hasattr(input_var, 'dump') and input_var.dump)):
@@ -336,14 +345,15 @@ def get_name(obj):
             name = get_name(input_var.sig_data)
             name_alignment = ' ' * (longest_name_len - len(name) -
                                     len('(in) '))
-            fmt = ''.join(['<', self.name, '> (iter %d) ',
-                           '(stage %', str(log_pipeline_depth), 'd, age %d) ', '(in) ',
+            fmt = ''.join(['<', self.name, ' step:%d, ',
+                           'stage:%', str(
+                               log_pipeline_depth), 'd, age:%d> (in) ',
                            name_alignment, name, ' = ', vfmt])
 
             stage = input_var.end_stage if input_var.end_stage is not None else 0
             enable = seq.Prev(dump_enable, stage)
             enables.append(enable)
-            age = seq.Prev(dump_iter, stage)
+            age = seq.Prev(dump_step, stage)
 
             if input_var.point == 0:
                 sig_data = input_var.sig_data
@@ -352,13 +362,14 @@ def get_name(obj):
                                       1.0 * (2 ** input_var.point))
 
             seq.If(enable)(
-                vtypes.Display(fmt, dump_iter, stage, age, sig_data)
+                vtypes.Display(fmt, dump_step, stage, age, sig_data)
             )
 
         for var in sorted(all_vars, key=lambda x: (-1, x.object_id)
                           if x.end_stage is None else
                           (x.end_stage, x.object_id)):
             if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
                     (self.dump_mode == 'selective' and
                      hasattr(var, 'dump') and var.dump)):
                 continue
@@ -369,13 +380,13 @@ def get_name(obj):
             name_alignment = ' ' * (longest_name_len - len(name))
             stage = var.end_stage if var.end_stage is not None else 0
 
-            fmt = ''.join(['<', self.name, '> (iter %d) ',
-                           '(stage %', str(log_pipeline_depth), 'd, age %d) ',
+            fmt = ''.join(['<', self.name, ' step:%d, ',
+                           'stage:%', str(log_pipeline_depth), 'd, age:%d> ',
                            name_alignment, name, ' = ', vfmt])
 
             enable = seq.Prev(dump_enable, stage)
             enables.append(enable)
-            age = seq.Prev(dump_iter, stage)
+            age = seq.Prev(dump_step, stage)
 
             if var.point == 0:
                 sig_data = var.sig_data
@@ -384,11 +395,13 @@ def get_name(obj):
                                       1.0 * (2 ** var.point))
 
             seq.If(enable)(
-                vtypes.Display(fmt, dump_iter, stage, age, sig_data)
+                vtypes.Display(fmt, dump_step, stage, age, sig_data)
             )
 
         for output_var in sorted(output_vars, key=lambda x: x.object_id):
-            if not (self.dump_mode == 'all' or self.dump_mode == 'output' or
+            if not (self.dump_mode == 'all' or
+                    self.dump_mode == 'stream' or
+                    self.dump_mode == 'output' or
                     self.dump_mode == 'inout' or
                     (self.dump_mode == 'selective' and
                      hasattr(output_var, 'dump') and output_var.dump)):
@@ -399,14 +412,15 @@ def get_name(obj):
             name = get_name(output_var.output_sig_data)
             name_alignment = ' ' * (longest_name_len - len(name) -
                                     len('(out) '))
-            fmt = ''.join(['<', self.name, '> (iter %d) ',
-                           '(stage %', str(log_pipeline_depth), 'd, age %d) ', '(out) ',
+            fmt = ''.join(['<', self.name, ' step:%d, ',
+                           'stage:%', str(
+                               log_pipeline_depth), 'd, age:%d> (out) ',
                            name_alignment, name, ' = ', vfmt])
 
             stage = output_var.end_stage if output_var.end_stage is not None else 0
             enable = seq.Prev(dump_enable, stage)
             enables.append(enable)
-            age = seq.Prev(dump_iter, stage)
+            age = seq.Prev(dump_step, stage)
 
             if output_var.point == 0:
                 sig_data = output_var.output_sig_data
@@ -415,13 +429,7 @@ def get_name(obj):
                                       1.0 * (2 ** output_var.point))
 
             seq.If(enable)(
-                vtypes.Display(fmt, dump_iter, stage, age, sig_data)
-            )
-
-        if enables:
-            seq.If(vtypes.Ors(*enables))(
-                vtypes.Display(''.join(['<', self.name, '> (iter %d) ', '--------']),
-                               dump_iter)
+                vtypes.Display(fmt, dump_step, stage, age, sig_data)
             )
 
     # -------------------------------------------------------------------------

veriloggen/thread/stream.py

@@ -1180,6 +1180,72 @@ def _setup_source_ram(self, ram, var, port, set_cond):
             var.source_ram_rvalid(1)
         )
 
+        if (self.dump and
+            (self.dump_mode == 'all' or
+             self.dump_mode == 'ram' or
+             (self.dump_mode == 'selective' and
+              hasattr(ram, 'dump') and ram.dump))):
+            self._setup_source_ram_dump(ram, var, renable, d)
+
+    def _setup_source_ram_dump(self, ram, var, read_enable, read_data):
+        pipeline_depth = self.pipeline_depth()
+        log_pipeline_depth = max(
+            int(math.ceil(math.log(pipeline_depth, 10))), 1)
+
+        addr_base = (ram.dump_addr_base if hasattr(ram, 'dump_addr_base') else
+                     self.dump_base)
+        addr_base_char = ('b' if addr_base == 2 else
+                          'o' if addr_base == 8 else
+                          'd' if addr_base == 10 else
+                          'x')
+        addr_prefix = ('0b' if addr_base == 2 else
+                       '0o' if addr_base == 8 else
+                       '  ' if addr_base == 10 else
+                       '0x')
+        addr_vfmt = ''.join([addr_prefix, '%', addr_base_char])
+
+        data_base = (ram.dump_data_base if hasattr(ram, 'dump_data_base') else
+                     self.dump_base)
+        data_base_char = ('b' if data_base == 2 else
+                          'o' if data_base == 8 else
+                          'd' if (data_base == 10 and
+                                  (not hasattr(ram, 'point') or ram.point == 0)) else
+                          'f' if (data_base == 10 and
+                                  hasattr(ram, 'point') and ram.point > 0) else
+                          'x')
+        data_prefix = ('0b' if data_base == 2 else
+                       '0o' if data_base == 8 else
+                       '  ' if data_base == 10 else
+                       '0x')
+        data_vfmt = ''.join([data_prefix, '%', data_base_char])
+
+        name = ram.name
+        fmt = ''.join(['(', self.name, ' step:%d, ',
+                       'read, ', ' ' * (log_pipeline_depth + 2),
+                       'age:%d) ', name,
+                       '[', addr_vfmt, '] = ', data_vfmt])
+
+        dump_ram_step_name = ('_stream_dump_ram_step_%d_%s' %
+                              (self.object_id, name))
+        dump_ram_step = self.module.Reg(dump_ram_step_name, 32,
+                                        initval=0, signed=True)
+
+        enable = self.seq.Prev(read_enable, 2)
+        age = dump_ram_step + 1
+        addr = self.seq.Prev(var.source_ram_raddr, 2)
+        data = read_data
+
+        self.seq(
+            dump_ram_step(-1)
+        )
+        self.seq.If(enable)(
+            dump_ram_step.inc()
+        )
+
+        self.seq.If(enable)(
+            vtypes.Display(fmt, dump_ram_step, age, addr, data)
+        )
+
     def _synthesize_set_source(self, var, name):
         if var.source_fsm is not None:
             return
@@ -1556,6 +1622,60 @@ def _setup_sink_ram(self, ram, var, port, set_cond):
         ram.write_rtl(var.sink_ram_waddr, var.sink_ram_wdata,
                       port=port, cond=wenable)
 
+        if (self.dump and
+            (self.dump_mode == 'all' or
+             self.dump_mode == 'ram' or
+             (self.dump_mode == 'selective' and
+              hasattr(ram, 'dump') and ram.dump))):
+            self._setup_sink_ram_dump(ram, var, wenable)
+
+    def _setup_sink_ram_dump(self, ram, var, write_enable):
+        pipeline_depth = self.pipeline_depth()
+        log_pipeline_depth = max(
+            int(math.ceil(math.log(pipeline_depth, 10))), 1)
+
+        addr_base = (ram.dump_addr_base if hasattr(ram, 'dump_addr_base') else
+                     self.dump_base)
+        addr_base_char = ('b' if addr_base == 2 else
+                          'o' if addr_base == 8 else
+                          'd' if addr_base == 10 else
+                          'x')
+        addr_prefix = ('0b' if addr_base == 2 else
+                       '0o' if addr_base == 8 else
+                       '  ' if addr_base == 10 else
+                       '0x')
+        addr_vfmt = ''.join([addr_prefix, '%', addr_base_char])
+
+        data_base = (ram.dump_data_base if hasattr(ram, 'dump_data_base') else
+                     self.dump_base)
+        data_base_char = ('b' if data_base == 2 else
+                          'o' if data_base == 8 else
+                          'd' if (data_base == 10 and
+                                  (not hasattr(ram, 'point') or ram.point == 0)) else
+                          'f' if (data_base == 10 and
+                                  hasattr(ram, 'point') and ram.point > 0) else
+                          'x')
+        data_prefix = ('0b' if data_base == 2 else
+                       '0o' if data_base == 8 else
+                       '  ' if data_base == 10 else
+                       '0x')
+        data_vfmt = ''.join([data_prefix, '%', data_base_char])
+
+        name = ram.name
+        fmt = ''.join(['(', self.name, ' step:%d, ',
+                       'write, ', ' ' * (log_pipeline_depth + 1),
+                       'age:%d) ', name,
+                       '[', addr_vfmt, '] = ', data_vfmt])
+
+        enable = var.sink_ram_wenable
+        age = self.seq.Prev(self.dump_step, pipeline_depth + 1)
+        addr = var.sink_ram_waddr
+        data = var.sink_ram_wdata
+
+        self.seq.If(enable)(
+            vtypes.Display(fmt, self.dump_step, age, addr, data)
+        )
+
     def _synthesize_set_sink(self, var, name):
         if var.sink_fsm is not None:
             return