Merge pull request #390 from pllab/render-base

Add ability to specify how values render in trace; improve symbol_len calculation.

Author: mdko

pyrtl/simulation.py

@@ -876,33 +876,46 @@ def tick_segment(self, n, symbol_len, segment_size):
         num_tick = self._tick + str(n)
         return num_tick.ljust(symbol_len * segment_size)
 
-    def render_val(self, w, n, current_val, symbol_len):
+    def render_val(self, w, n, current_val, symbol_len, repr_func, repr_per_name):
         if w is not self.prev_wire:
             self.prev_wire = w
             self.prior_val = current_val
-        out = self._render_val_with_prev(w, n, current_val, symbol_len)
+        out = self._render_val_with_prev(w, n, current_val, symbol_len, repr_func, repr_per_name)
         self.prior_val = current_val
         return out
 
-    def _render_val_with_prev(self, w, n, current_val, symbol_len):
+    def _render_val_with_prev(self, w, n, current_val, symbol_len, repr_func, repr_per_name):
         """Return a string encoding the given value in a waveform.
 
         :param w: The WireVector we are rendering to a waveform
         :param n: An integer from 0 to segment_len-1
         :param current_val: the value to be rendered
         :param symbol_len: and integer for how big to draw the current value
+        :param repr_func: function to use for representing the current_val;
+            examples are 'hex', 'oct', 'bin', 'str' (for decimal), or even the name
+            of an IntEnum class you know the value will belong to. Defaults to 'hex'.
+        :param repr_per_name: Map from signal name to a function that takes in the signal's
+            value and returns a user-defined representation. If a signal name is
+            not found in the map, the argument `repr_func` will be used instead.
 
         Returns a string of printed length symbol_len that will draw the
         representation of current_val.  The input prior_val is used to
         render transitions.
         """
+        def to_str(v):
+            f = repr_per_name.get(w.name)
+            if f is None:
+                return str(repr_func(v))
+            else:
+                return str(f(v))
+
         sl = symbol_len - 1
         if len(w) > 1:
             out = self._revstart
             if current_val != self.prior_val:
-                out += self._x + hex(current_val).rstrip('L').ljust(sl)[:sl]
+                out += self._x + to_str(current_val).rstrip('L').ljust(sl)[:sl]
             elif n == 0:
-                out += hex(current_val).rstrip('L').ljust(symbol_len)[:symbol_len]
+                out += to_str(current_val).rstrip('L').ljust(symbol_len)[:symbol_len]
             else:
                 out += ' ' * symbol_len
             out += self._revstop
@@ -1130,14 +1143,22 @@ def print_trace_strs(time):
 
     def render_trace(
             self, trace_list=None, file=sys.stdout, render_cls=default_renderer(),
-            symbol_len=5, segment_size=5, segment_delim=' ', extra_line=True):
+            symbol_len=5, repr_func=hex, repr_per_name={}, segment_size=5,
+            segment_delim=' ', extra_line=True):
 
         """ Render the trace to a file using unicode and ASCII escape sequences.
 
         :param trace_list: A list of signal names to be output in the specified order.
         :param file: The place to write output, default to stdout.
         :param render_cls: A class that translates traces into output bytes.
         :param symbol_len: The "length" of each rendered cycle in characters.
+            If None, the length will be automatically set such that the largest
+            represented value fits.
+        :param repr_func: Function to use for representing each value in the trace;
+            examples are 'hex', 'oct', 'bin', and 'str' (for decimal). Defaults to 'hex'.
+        :param repr_per_name: Map from signal name to a function that takes in the signal's
+            value and returns a user-defined representation. If a signal name is
+            not found in the map, the argument `repr_func` will be used instead.
         :param segment_size: Traces are broken in the segments of this number of cycles.
         :param segment_delim: The character to be output between segments.
         :param extra_line: A Boolean to determine if we should print a blank line between signals.
@@ -1166,12 +1187,12 @@ def render_trace(
         else:
             self.render_trace_to_text(
                 trace_list=trace_list, file=file, render_cls=render_cls,
-                symbol_len=symbol_len, segment_size=segment_size,
-                segment_delim=segment_delim, extra_line=extra_line)
+                symbol_len=symbol_len, repr_func=repr_func, repr_per_name=repr_per_name,
+                segment_size=segment_size, segment_delim=segment_delim, extra_line=extra_line)
 
     def render_trace_to_text(
             self, trace_list, file, render_cls,
-            symbol_len, segment_size, segment_delim, extra_line):
+            symbol_len, repr_func, repr_per_name, segment_size, segment_delim, extra_line):
 
         renderer = render_cls()
 
@@ -1185,7 +1206,9 @@ def formatted_trace_line(wire, trace):
                     self._wires[wire],
                     i % segment_size,
                     trace[i],
-                    symbol_len)
+                    symbol_len,
+                    repr_func,
+                    repr_per_name)
             return heading + trace_line
 
         # default to printing all signals in sorted order
@@ -1204,6 +1227,20 @@ def formatted_trace_line(wire, trace):
                 "untraceable wires were removed prior to simulation, "
                 "if a CompiledSimulation was used.")
 
+        if symbol_len is None:
+
+            def to_str(v, name):
+                f = repr_per_name.get(name)
+                if f is None:
+                    return str(repr_func(v))
+                else:
+                    return str(f(v))
+
+            maxvallen = 0
+            for name, trace in self.trace.items():
+                maxvallen = max(maxvallen, max(len(to_str(v, name)) for v in trace))
+            symbol_len = maxvallen + 1
+
         # print the 'ruler' which is just a list of 'ticks'
         # mapped by the pretty map
 

pyrtl/visualization.py

@@ -459,12 +459,18 @@ def block_to_svg(block=None, split_state=True, maintain_arg_order=False):
 #    |__|  |  |\/| |
 #    |  |  |  |  | |___
 
-def trace_to_html(simtrace, trace_list=None, sortkey=None):
+def trace_to_html(simtrace, trace_list=None, sortkey=None, repr_func=hex, repr_per_name={}):
     """ Return a HTML block showing the trace.
 
     :param simtrace: A SimulationTrace object
     :param trace_list: (optional) A list of wires to display
     :param sortkey: (optional) The key with which to sort the trace_list
+    :param repr_func: function to use for representing the current_val;
+        examples are 'hex', 'oct', 'bin', 'str' (for decimal), or even the name
+        of an IntEnum class you know the value will belong to. Defaults to 'hex'.
+    :param repr_per_name: Map from signal name to a function that takes in the signal's
+        value and returns a user-defined representation. If a signal name is
+        not found in the map, the argument `repr_func` will be used instead.
     :return: An HTML block showing the trace
     """
 
@@ -481,15 +487,19 @@ def trace_to_html(simtrace, trace_list=None, sortkey=None):
 
     wave_template = (
         """\
-        <script type="WaveDrom">
-        { signal : [
-        %s
-        ]}
-        </script>
-
-        """
+<script type="WaveDrom">
+{
+  signal : [
+%s
+  ],
+  config: { hscale: %d }
+}
+</script>
+"""
     )
 
+    vallens = []  # For determining longest value length
+
     def extract(w):
         wavelist = []
         datalist = []
@@ -498,24 +508,35 @@ def extract(w):
             if last == value:
                 wavelist.append('.')
             else:
-                if len(w) == 1:
+                if len(simtrace._wires[w]) == 1:
                     wavelist.append(str(value))
                 else:
                     wavelist.append('=')
-                    datalist.append(value)
+                    datalist.append((value, w))
                 last = value
 
+        def to_str(v, name):
+            f = repr_per_name.get(name)
+            if f is None:
+                return str(repr_func(v))
+            else:
+                return str(f(v))
+
         wavestring = ''.join(wavelist)
-        datastring = ', '.join(['"%d"' % data for data in datalist])
-        if len(w) == 1:
+        datastring = ', '.join(['"%s"' % to_str(data, name) for data, name in datalist])
+        if len(simtrace._wires[w]) == 1:
+            vallens.append(1)  # all are the same length
             return bool_signal_template % (w, wavestring)
         else:
+            vallens.extend([len(to_str(data, name)) for data, name in datalist])
             return int_signal_template % (w, wavestring, datastring)
 
-    bool_signal_template = '{ name: "%s",  wave: "%s" },'
-    int_signal_template = '{ name: "%s",  wave: "%s", data: [%s] },'
+    bool_signal_template = '    { name: "%s",  wave: "%s" },'
+    int_signal_template = '    { name: "%s",  wave: "%s", data: [%s] },'
     signals = [extract(w) for w in trace_list]
     all_signals = '\n'.join(signals)
-    wave = wave_template % all_signals
+    maxvallen = max(vallens)
+    scale = (maxvallen // 5) + 1
+    wave = wave_template % (all_signals, scale)
     # print(wave)
     return wave

tests/test_simulation.py

@@ -1,5 +1,6 @@
 import unittest
 import six
+import io
 
 import pyrtl
 from pyrtl.corecircuits import _basic_add
@@ -128,6 +129,101 @@ def test_reg_to_reg_simulation(self):
         self.check_trace(' r 00224466\nr2 02244660\n')
 
 
+class RenderTraceBase(unittest.TestCase):
+    def setUp(self):
+        pyrtl.reset_working_block()
+        a, b = pyrtl.input_list('a/8 b/8')
+        o = pyrtl.Output()
+        o <<= a + b
+
+    def check_rendered_trace(self, expected, **kwargs):
+        sim = pyrtl.Simulation()
+        sim.step_multiple({
+            'a': [1, 4, 9, 11, 12],
+            'b': [2, 23, 43, 120, 0],
+        })
+        buff = io.StringIO()
+        sim.tracer.render_trace(file=buff, render_cls=pyrtl.simulation.AsciiWaveRenderer,
+                                extra_line=False, **kwargs)
+        self.assertEqual(buff.getvalue(), expected)
+
+    def test_hex_trace(self):
+        expected = (
+            "  -0                       \n"
+            "a  0x1    x0x4   x0x9   x0xb   x0xc  \n"
+            "b  0x2    x0x17  x0x2b  x0x78  x0x0  \n"
+        )
+        self.check_rendered_trace(expected)
+
+    def test_hex_trace(self):
+        expected = (
+            "  -0                            \n"
+            "a  0o1     x0o4    x0o11   x0o13   x0o14  \n"
+            "b  0o2     x0o27   x0o53   x0o170  x0o0   \n"
+        )
+        self.check_rendered_trace(expected, repr_func=oct, symbol_len=None)
+
+    def test_bin_trace(self):
+        expected = (
+            "  -0                                                \n"
+            "a  0b1         x0b100      x0b1001     x0b1011     x0b1100    \n"
+            "b  0b10        x0b10111    x0b101011   x0b1111000  x0b0       \n"
+        )
+        self.check_rendered_trace(expected, repr_func=bin, symbol_len=None)
+
+    def test_decimal_trace(self):
+        expected = (
+            "  -0                  \n"
+            "a  1     x4    x9    x11   x12  \n"
+            "b  2     x23   x43   x120  x0   \n"
+        )
+        self.check_rendered_trace(expected, repr_func=str, symbol_len=None)
+
+
+class RenderTraceCustomBase(unittest.TestCase):
+    def setUp(self):
+        pyrtl.reset_working_block()
+
+    def test_custom_repr_per_wire(self):
+        from enum import IntEnum
+
+        class Foo(IntEnum):
+            A = 0
+            B = 1
+            C = 2
+            D = 3
+
+        i = pyrtl.Input(4, 'i')
+        state = pyrtl.Register(max(Foo).bit_length(), name='state')
+        o = pyrtl.Output(name='o')
+        o <<= state
+
+        with pyrtl.conditional_assignment:
+            with i == 0b0001:
+                state.next |= Foo.A
+            with i == 0b0010:
+                state.next |= Foo.B
+            with i == 0b0100:
+                state.next |= Foo.C
+            with i == 0b1000:
+                state.next |= Foo.D
+
+        sim = pyrtl.Simulation()
+        sim.step_multiple({
+            'i': [1, 2, 4, 8, 0]
+        })
+        buff = io.StringIO()
+        sim.tracer.render_trace(file=buff, render_cls=pyrtl.simulation.AsciiWaveRenderer,
+                                extra_line=None, repr_per_name={'state': Foo}, symbol_len=None)
+        expected = (
+            "      -0                            \n"
+            "    i  0x1     x0x2    x0x4    x0x8    x0x0   \n"
+            "    o  0x0             x0x1    x0x2    x0x3   \n"
+            "state  Foo.A           xFoo.B  xFoo.C  xFoo.D \n"
+        )
+        self.assertEqual(buff.getvalue(), expected)
+
+
 class PrintTraceBase(unittest.TestCase):
     # note: doesn't include tests for compact=True because all the tests test that
     def setUp(self):