Supersize: Chrome-specific breakdowns, console tweaks

tools/binary_size/libsupersize/console.py

 # Copyright 2017 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """An interactive console for looking analyzing .size files."""
 
 import argparse
 import atexit
 import code
 import contextlib
 import itertools
 import logging
 import os
 import readline
 import subprocess
 import sys
 
 import archive
+import canned_queries
 import describe
 import diff
 import file_format
 import match_util
 import models
 import paths
 
 
 # Number of lines before using less for Print().
-_THRESHOLD_FOR_PAGER = 30
+_THRESHOLD_FOR_PAGER = 50
 
 
 @contextlib.contextmanager
 def _LessPipe():
   """Output to `less`. Yields a file object to write to."""
   try:
     proc = subprocess.Popen(['less'], stdin=subprocess.PIPE, stdout=sys.stdout)
     yield proc.stdin
     proc.stdin.close()
     proc.wait()
@@ skipping 22 matching lines @@
   else:
     describe.WriteLines(lines, sys.stdout.write)
 
 
 class _Session(object):
   _readline_initialized = False
 
   def __init__(self, size_infos, lazy_paths):
     self._variables = {
         'Print': self._PrintFunc,
-        'Diff': diff.Diff,
+        'Diff': self._DiffFunc,
         'Disassemble': self._DisassembleFunc,
         'ExpandRegex': match_util.ExpandRegexIdentifierPlaceholder,
         'ShowExamples': self._ShowExamplesFunc,
+        'canned_queries': canned_queries.CannedQueries(size_infos),
     }
     self._lazy_paths = lazy_paths
     self._size_infos = size_infos
 
     if len(size_infos) == 1:
       self._variables['size_info'] = size_infos[0]
     else:
       for i, size_info in enumerate(size_infos):
         self._variables['size_info%d' % (i + 1)] = size_info
 
-  def _PrintFunc(self, obj, verbose=False, recursive=False, use_pager=None,
+  def _DiffFunc(self, before=None, after=None, cluster=True):
+    """Diffs two SizeInfo objects. Returns a SizeInfoDiff.
+
+    Args:
+      before: Defaults to first size_infos[0].
+      after: Defaults to second size_infos[1].
+      cluster: When True, calls SymbolGroup.Cluster() after diffing. This
+          generally reduces noise.
+    """
+    before = before if before is not None else self._size_infos[0]
+    after = after if after is not None else self._size_infos[1]
+    return diff.Diff(before, after, cluster=cluster)
+
+  def _PrintFunc(self, obj=None, verbose=False, recursive=False, use_pager=None,
                  to_file=None):
     """Prints out the given Symbol / SymbolGroup / SymbolDiff / SizeInfo.
 
     Args:
-      obj: The object to be printed.
+      obj: The object to be printed. Defaults to size_infos[-1].
       verbose: Show more detailed output.
       recursive: Print children of nested SymbolGroups.
       use_pager: Pipe output through `less`. Ignored when |obj| is a Symbol.
           default is to automatically pipe when output is long.
       to_file: Rather than print to stdio, write to the given file.
     """
+    obj = obj if obj is not None else self._size_infos[-1]
     lines = describe.GenerateLines(obj, verbose=verbose, recursive=recursive)
     _WriteToStream(lines, use_pager=use_pager, to_file=to_file)
 
   def _ElfPathForSymbol(self, symbol):
     size_info = None
     for size_info in self._size_infos:
       if symbol in size_info.symbols:
         break
     else:
       assert False, 'Symbol does not belong to a size_info.'
@@ skipping 26 matching lines @@
             '--start-address=0x%x' % symbol.address,
             '--stop-address=0x%x' % symbol.end_address, elf_path]
     proc = subprocess.Popen(args, stdout=subprocess.PIPE)
     lines = itertools.chain(('Showing disassembly for %r' % symbol,
                              'Command: %s' % ' '.join(args)),
                             (l.rstrip() for l in proc.stdout))
     _WriteToStream(lines, use_pager=use_pager, to_file=to_file)
     proc.kill()
 
   def _ShowExamplesFunc(self):
+    print self._CreateBanner()
     print '\n'.join([
         '# Show pydoc for main types:',
         'import models',
         'help(models)',
         '',
         '# Show all attributes of all symbols & per-section totals:',
         'Print(size_info, verbose=True)',
         '',
         '# Show two levels of .text, grouped by first two subdirectories',
         'text_syms = size_info.symbols.WhereInSection("t")',
-        'by_path = text_syms.GroupBySourcePath(depth=2)',
+        'by_path = text_syms.GroupByPath(depth=2)',
         'Print(by_path.WhereBiggerThan(1024))',
         '',
         '# Show all non-vtable generated symbols',
         'generated_syms = size_info.symbols.WhereGeneratedByToolchain()',
         'Print(generated_syms.WhereNameMatches(r"vtable").Inverted().Sorted())',
         '',
         '# Show all symbols that have "print" in their name or path, except',
         '# those within components/.',
         '# Note: Could have also used Inverted(), as above.',
         '# Note: Use "help(ExpandRegex)" for more about what {{_print_}} does.',
         'print_syms = size_info.symbols.WhereMatches(r"{{_print_}}")',
         'Print(print_syms - print_syms.WherePathMatches(r"^components/"))',
         '',
         '# Diff two .size files and save result to a file:',
         'Print(Diff(size_info1, size_info2), to_file="output.txt")',
         '',
+        '# View per-component breakdowns, then drill into the last entry.',
+        'c = canned_queries.CategorizeByChromeComponent()',
+        'Print(c)',
+        'Print(c[-1].GroupByPath(depth=2).Sorted())',
+        '',
+        '# For even more inspiration, look at canned_queries.py',
+        '# (and feel free to add your own!).',
     ])
 
   def _CreateBanner(self):
     symbol_info_keys = sorted(m for m in dir(models.SizeInfo) if m[0] != '_')
     symbol_keys = sorted(m for m in dir(models.Symbol) if m[0] != '_')
     symbol_group_keys = [m for m in dir(models.SymbolGroup) if m[0] != '_']
     symbol_diff_keys = sorted(m for m in dir(models.SymbolDiff)
                               if m[0] != '_' and m not in symbol_group_keys)
     symbol_group_keys = sorted(m for m in symbol_group_keys
                                if m not in symbol_keys)
+    canned_queries_keys = sorted(m for m in dir(canned_queries.CannedQueries)
+                                 if m[0] != '_')
     functions = sorted(k for k in self._variables if k[0].isupper())
     variables = sorted(k for k in self._variables if k[0].islower())
     return '\n'.join([
         '*' * 80,
         'Entering interactive Python shell. Quick reference:',
         '',
         'SizeInfo: %s' % ', '.join(symbol_info_keys),
         'Symbol: %s' % ', '.join(symbol_keys),
+        '',
         'SymbolGroup (extends Symbol): %s' % ', '.join(symbol_group_keys),
+        '',
         'SymbolDiff (extends SymbolGroup): %s' % ', '.join(symbol_diff_keys),
         '',
+        'canned_queries: %s' % ', '.join(canned_queries_keys),
+        '',
         'Functions: %s' % ', '.join('%s()' % f for f in functions),
         'Variables: %s' % ', '.join(variables),
         '*' * 80,
     ])
 
   @classmethod
   def _InitReadline(cls):
     if cls._readline_initialized:
       return
     cls._readline_initialized = True
@@ skipping 40 matching lines @@
                                output_directory=args.output_directory,
                                any_path_within_output_directory=args.inputs[0])
   session = _Session(size_infos, lazy_paths)
 
   if args.query:
     logging.info('Running query from command-line.')
     session.Eval(args.query)
   else:
     logging.info('Entering interactive console.')
     session.GoInteractive()