[interpreter] Add relative numbers to dispatch report

tools/ignition/bytecode_dispatches_report.py

 #! /usr/bin/python
 #
 # Copyright 2016 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 #
 
 import argparse
 import heapq
 import json
 from matplotlib import colors
 from matplotlib import pyplot
 import numpy
 import struct
+import sys
 
 
 __DESCRIPTION = """
 Process v8.ignition_dispatches_counters.json and list top counters,
 or plot a dispatch heatmap.
 
 Please note that those handlers that may not or will never dispatch
 (e.g. Return or Throw) do not show up in the results.
 """
 
@@ skipping 19 matching lines @@
   # Display the top 5 sources and destinations of dispatches to/from LdaZero
   $ tools/ignition/bytecode_dispatches_report.py -f LdaZero -n 5
 """
 
 __COUNTER_BITS = struct.calcsize("P") * 8  # Size in bits of a pointer
 __COUNTER_MAX = 2**__COUNTER_BITS - 1
 
 
 def warn_if_counter_may_have_saturated(dispatches_table):
   for source, counters_from_source in dispatches_table.items():
-    for destination, counter in counters_from_source.items():
+    for destination, (counter, ratio) in counters_from_source.items():
       if counter == __COUNTER_MAX:
         print "WARNING: {} -> {} may have saturated.".format(source,
                                                              destination)
 
 
 def find_top_bytecode_dispatch_pairs(dispatches_table, top_count):
   def flattened_counters_generator():
     for source, counters_from_source in dispatches_table.items():
-      for destination, counter in counters_from_source.items():
+      for destination, (counter, ratio) in counters_from_source.items():
         yield source, destination, counter
 
   return heapq.nlargest(top_count, flattened_counters_generator(),
                         key=lambda x: x[2])
 
 
 def print_top_bytecode_dispatch_pairs(dispatches_table, top_count):
   top_bytecode_dispatch_pairs = (
     find_top_bytecode_dispatch_pairs(dispatches_table, top_count))
   print "Top {} bytecode dispatch pairs:".format(top_count)
   for source, destination, counter in top_bytecode_dispatch_pairs:
     print "{:>12d}\t{} -> {}".format(counter, source, destination)
 
 
-def find_top_bytecodes(dispatches_table):
-  top_bytecodes = []
-  for bytecode, counters_from_bytecode in dispatches_table.items():
-    top_bytecodes.append((bytecode, sum(counters_from_bytecode.values())))
+def find_top_bytecodes(dispatch_totals):
+  top_bytecodes = list(iteritems(dispatch_totals))
   top_bytecodes.sort(key=lambda x: x[1], reverse=True)
   return top_bytecodes
 
 
-def print_top_bytecodes(dispatches_table):
-  top_bytecodes = find_top_bytecodes(dispatches_table)
+def print_top_bytecodes(dispatch_totals):
+  top_bytecodes = find_top_bytecodes(dispatch_totals)
   print "Top bytecodes:"
   for bytecode, counter in top_bytecodes:
     print "{:>12d}\t{}".format(counter, bytecode)
 
 
-def find_top_dispatch_sources(dispatches_table, destination, top_count):
+def find_top_dispatch_sources(dispatches_table, destination, top_count,
+                              sort_source_relative):
   def source_counters_generator():
     for source, table_row in dispatches_table.items():
       if destination in table_row:
         yield source, table_row[destination]
 
   return heapq.nlargest(top_count, source_counters_generator(),
-                        key=lambda x: x[1])
+                        key=lambda x: x[1][1 if sort_source_relative else 0])
 
 
 def print_top_dispatch_sources_and_destinations(dispatches_table, bytecode,
-                                                top_count):
-  top_sources = find_top_dispatch_sources(dispatches_table, bytecode, top_count)
+                                                top_count, sort_relative):
+  top_sources = find_top_dispatch_sources(dispatches_table, bytecode,
+                                          top_count, sort_relative)
   top_destinations = heapq.nlargest(top_count,
                                     dispatches_table[bytecode].items(),
-                                    key=lambda x: x[1])
+                                    key=lambda x: x[1][0])
 
   print "Top sources of dispatches to {}:".format(bytecode)
-  for source_name, counter in top_sources:
-    print "{:>12d}\t{}".format(counter, source_name)
+  for source_name, (counter, ratio) in top_sources:
+    print "{:>12d}\t{:>5.1f}%\t{}".format(counter, ratio * 100, source_name)
 
   print "\nTop destinations of dispatches from {}:".format(bytecode)
-  for destination_name, counter in top_destinations:
-    print "{:>12d}\t{}".format(counter, destination_name)
+  for destination_name, (counter, ratio) in top_destinations:
+    print "{:>12d}\t{:>5.1f}%\t{}".format(counter, ratio * 100, destination_name)
 
 
 def build_counters_matrix(dispatches_table):
   labels = sorted(dispatches_table.keys())
 
   counters_matrix = numpy.empty([len(labels), len(labels)], dtype=int)
   for from_index, from_name in enumerate(labels):
     current_row = dispatches_table[from_name];
     for to_index, to_name in enumerate(labels):
-      counters_matrix[from_index, to_index] = current_row.get(to_name, 0)
+      counters_matrix[from_index, to_index] = current_row.get(to_name, (0, 0))[0]
 
   # Reverse y axis for a nicer appearance
   xlabels = labels
   ylabels = list(reversed(xlabels))
   counters_matrix = numpy.flipud(counters_matrix)
 
   return counters_matrix, xlabels, ylabels
 
 
 def plot_dispatches_table(dispatches_table, figure, axis):
@@ skipping 71 matching lines @@
     help="print top dispatch sources and destinations to the specified bytecode"
   )
   command_line_parser.add_argument(
     "--output-filename", "-o",
     metavar="<output filename>",
     default="v8.ignition_dispatches_table.svg",
     help=("file to save the plot file to. File type is deduced from the "
           "extension. PDF, SVG, PNG supported")
   )
   command_line_parser.add_argument(
+    "--sort-sources-relative", "-r",
+    action="store_true",
+    help=("print top sources in order to how often they dispatch to the "
+          "speficied bytecode")

[rmcilroy, 2016/07/19 09:23:08]

fix typo

[klaasb, 2016/07/19 10:24:27]

Done.

+  )
+  command_line_parser.add_argument(
     "input_filename",
     metavar="<input filename>",
     default="v8.ignition_dispatches_table.json",
     nargs='?',
     help="Ignition counters JSON file"
   )
 
   return command_line_parser.parse_args()
 
 
+def itervalues(d):
+  return d.values() if sys.version_info[0] > 2 else d.itervalues()
+
+
+def iteritems(d):
+  return d.items() if sys.version_info[0] > 2 else d.iteritems()
+
+
 def main():
   program_options = parse_command_line()
 
   with open(program_options.input_filename) as stream:
     dispatches_table = json.load(stream)
 
+  dispatch_totals = {}
+  for source, destinations in dispatches_table.items():
+    total = sum(itervalues(destinations))
+    dispatch_totals[source] = total
+    total = float(total)
+    for destination, count in destinations.iteritems():
+      destinations[destination] = (count, count / total)

[rmcilroy, 2016/07/19 09:23:08]

I think it would be better to do this as a processing stage in
print_top_dispatch_sources_and_destinations (with the result being a new table,
rather than modifying the existing one), since ratio is only used there. WDYT?

[klaasb, 2016/07/19 10:24:27]

Done.

+
   warn_if_counter_may_have_saturated(dispatches_table)
 
   if program_options.plot:
     figure, axis = pyplot.subplots()
     plot_dispatches_table(dispatches_table, figure, axis)
 
     if program_options.interactive:
       pyplot.show()
     else:
       figure.set_size_inches(program_options.plot_size,
                              program_options.plot_size)
       pyplot.savefig(program_options.output_filename)
   elif program_options.top_bytecode_dispatch_pairs:
     print_top_bytecode_dispatch_pairs(
       dispatches_table, program_options.top_entries_count)
   elif program_options.top_dispatches_for_bytecode:
     print_top_dispatch_sources_and_destinations(
       dispatches_table, program_options.top_dispatches_for_bytecode,
-      program_options.top_entries_count)
+      program_options.top_entries_count, program_options.sort_sources_relative)
   else:
-    print_top_bytecodes(dispatches_table)
+    print_top_bytecodes(dispatch_totals)
 
 
 if __name__ == "__main__":
   main()