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

calculation.

Author: mdko

pyrtl/simulation.py

@@ -876,21 +876,23 @@ 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):
         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)
         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):
         """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', and 'str' (for decimal). Defaults to 'hex'.
 
         Returns a string of printed length symbol_len that will draw the
         representation of current_val.  The input prior_val is used to
@@ -900,9 +902,9 @@ def _render_val_with_prev(self, w, n, current_val, symbol_len):
         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 + repr_func(current_val).rstrip('L').ljust(sl)[:sl]
             elif n == 0:
-                out += hex(current_val).rstrip('L').ljust(symbol_len)[:symbol_len]
+                out += repr_func(current_val).rstrip('L').ljust(symbol_len)[:symbol_len]
             else:
                 out += ' ' * symbol_len
             out += self._revstop
@@ -1130,14 +1132,18 @@ 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, 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 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 +1172,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,
+                symbol_len=symbol_len, repr_func=repr_func, 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, segment_size, segment_delim, extra_line):
 
         renderer = render_cls()
 
@@ -1185,7 +1191,8 @@ def formatted_trace_line(wire, trace):
                     self._wires[wire],
                     i % segment_size,
                     trace[i],
-                    symbol_len)
+                    symbol_len,
+                    repr_func)
             return heading + trace_line
 
         # default to printing all signals in sorted order
@@ -1204,6 +1211,12 @@ def formatted_trace_line(wire, trace):
                 "untraceable wires were removed prior to simulation, "
                 "if a CompiledSimulation was used.")
 
+        if symbol_len is None:
+            maxvallen = 0
+            for trace in self.trace.values():
+                maxvallen = max(maxvallen, max(len(repr_func(v)) 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,7 +459,7 @@ 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):
     """ Return a HTML block showing the trace.
 
     :param simtrace: A SimulationTrace object
@@ -484,12 +484,15 @@ def trace_to_html(simtrace, trace_list=None, sortkey=None):
         <script type="WaveDrom">
         { signal : [
         %s
-        ]}
+        ],
+        config: {hscale: %d }}
         </script>
 
         """
     )
 
+    vallens = []  # For determining longest value length
+
     def extract(w):
         wavelist = []
         datalist = []
@@ -506,7 +509,8 @@ def extract(w):
                 last = value
 
         wavestring = ''.join(wavelist)
-        datastring = ', '.join(['"%d"' % data for data in datalist])
+        datastring = ', '.join(['"%s"' % repr_func(data) for data in datalist])
+        vallens.extend([len(repr_func(data)) for data in datalist])
         if len(w) == 1:
             return bool_signal_template % (w, wavestring)
         else:
@@ -516,6 +520,8 @@ def extract(w):
     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,57 @@ 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 PrintTraceBase(unittest.TestCase):
     # note: doesn't include tests for compact=True because all the tests test that
     def setUp(self):