binary_size: Easier-to-read output

tools/binary_size/run_binary_size_analysis.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """Generate a spatial analysis against an arbitrary library.
 
 To use, build the 'binary_size_tool' target. Then run this tool, passing
 in the location of the library to be analyzed along with any other options
 you desire.
@@ skipping 143 matching lines @@
       logging.warning('A container node used as symbol for %s.' % symbol_name)
     # This is going to be used as a leaf so no use for child list.
     del node[NODE_CHILDREN_KEY]
   node[NODE_SYMBOL_SIZE_KEY] = symbol_size
   node[NODE_SYMBOL_TYPE_KEY] = symbol_type
   node[NODE_TYPE_KEY] = 's'  # s for symbol
 
   return 2  # Depth of the added subtree.
 
 
-def MakeCompactTree(symbols):
+def MakeCompactTree(symbols, symbol_path_origin_dir):
   result = {NODE_NAME_KEY: '/',
             NODE_CHILDREN_KEY: {},
             NODE_TYPE_KEY: 'p',
             NODE_MAX_DEPTH_KEY: 0}
   seen_symbol_with_path = False
+  cwd = os.path.abspath(os.getcwd())
   for symbol_name, symbol_type, symbol_size, file_path in symbols:
 
     if 'vtable for ' in symbol_name:
       symbol_type = '@'  # hack to categorize these separately
     # Take path like '/foo/bar/baz', convert to ['foo', 'bar', 'baz']
-    if file_path:
-      file_path = os.path.normpath(file_path)
+    if file_path and file_path != "??":
+      file_path = os.path.abspath(os.path.join(symbol_path_origin_dir,
+                                               file_path))
+      # Let the output structure be relative to $CWD if inside $CWD,
+      # otherwise relative to the disk root. This is to avoid
+      # unnecessary click-through levels in the output.
+      if file_path.startswith(cwd + os.sep):
+        file_path = file_path[len(cwd):]
+      if file_path.startswith('/'):
+        file_path = file_path[1:]
       seen_symbol_with_path = True
     else:
       file_path = NAME_NO_PATH_BUCKET
 
-    if file_path.startswith('/'):
-      file_path = file_path[1:]
     path_parts = file_path.split('/')
 
     # Find pre-existing node in tree, or update if it already exists
     node = result
     depth = 0
     while len(path_parts) > 0:
       path_part = path_parts.pop(0)
       if len(path_part) == 0:
         continue
       depth += 1
@@ skipping 146 matching lines @@
   # Sort children by size, largest to smallest.
   children.sort(key=lambda child: -child['data']['$area'])
 
   # For leaf nodes, the 'size' attribute is the size of the leaf;
   # Non-leaf nodes don't really have a size, but their 'size' attribute is
   # the sum of the sizes of all their children.
   return {'name': name + ' (' + FormatBytes(tree['size']) + ')',
           'data': { '$area': tree['size'] },
           'children': children }
 
-def DumpCompactTree(symbols, outfile):
-  tree_root = MakeCompactTree(symbols)
+def DumpCompactTree(symbols, symbol_path_origin_dir, outfile):
+  tree_root = MakeCompactTree(symbols, symbol_path_origin_dir)
   with open(outfile, 'w') as out:
-    out.write('var tree_data = ')
-    json.dump(tree_root, out)
+    out.write('var tree_data=')
+    # Use separators without whitespace to get a smaller file.
+    json.dump(tree_root, out, separators=(',', ':'))
   print('Writing %d bytes json' % os.path.getsize(outfile))
 
 
 # TODO(andrewhayden): Only used for legacy reports. Delete.
 def DumpTreemap(symbols, outfile):
   dirs = TreeifySymbols(symbols)
   out = open(outfile, 'w')
   try:
     out.write('var kTree = ' + json.dumps(JsonifyTree(dirs, '/')))
   finally:
@@ skipping 128 matching lines @@
   progress = Progress()
   def map_address_symbol(symbol, addr):
     progress.count += 1
     if addr in address_symbol:
       # 'Collision between %s and %s.' % (str(symbol.name),
       #                                   str(address_symbol[addr].name))
       progress.collisions += 1
     else:
       address_symbol[addr] = symbol
 
+    progress_output()
+
+  def progress_output():
     progress_chunk = 100
     if progress.count % progress_chunk == 0:
       time_now = time.time()
       time_spent = time_now - progress.time_last_output
       if time_spent > 1.0:
         # Only output at most once per second.
         progress.time_last_output = time_now
         chunk_size = progress.count - progress.count_last_output
         progress.count_last_output = progress.count
         if time_spent > 0:
@@ skipping 37 matching lines @@
     symbolizer.Join()
   except KeyboardInterrupt:
     # Don't want to abort here since we will be finished in a few seconds.
     user_interrupted = True
     print('Patience you must have my young padawan.')
 
   if user_interrupted:
     print('Skipping the rest of the file mapping. '
           'Output will not be fully classified.')
 
+  symbol_path_origin_dir = os.path.dirname(os.path.abspath(library))
+
   with open(outfile, 'w') as out:
     for line in nm_output_lines:
       match = sNmPattern.match(line)
       if match:
         location = match.group(5)
         if not location:
           addr = int(match.group(1), 16)
           symbol = address_symbol.get(addr)
           if symbol is not None:
             path = '??'
             if symbol.source_path is not None:
-              path = symbol.source_path
+              path = os.path.abspath(os.path.join(symbol_path_origin_dir,
+                                                  symbol.source_path))
             line_number = 0
             if symbol.source_line is not None:
               line_number = symbol.source_line
             out.write('%s\t%s:%d\n' % (line, path, line_number))
             continue
 
       out.write('%s\n' % line)
 
   print('%d symbols in the results.' % len(address_symbol))
 
@@ skipping 191 matching lines @@
     treemap_out = os.path.join(opts.destdir, 'webtreemap')
     if not os.path.exists(treemap_out):
       os.makedirs(treemap_out, 0755)
     treemap_src = os.path.join('third_party', 'webtreemap', 'src')
     shutil.copy(os.path.join(treemap_src, 'COPYING'), treemap_out)
     shutil.copy(os.path.join(treemap_src, 'webtreemap.js'), treemap_out)
     shutil.copy(os.path.join(treemap_src, 'webtreemap.css'), treemap_out)
     shutil.copy(os.path.join('tools', 'binary_size', 'legacy_template',
                              'index.html'), opts.destdir)
   else: # modern report
-    DumpCompactTree(symbols, os.path.join(opts.destdir, 'data.js'))
+    if opts.library:
+      symbol_path_origin_dir = os.path.dirname(os.path.abspath(opts.library))
+    else:
+      # Just a guess. Hopefully all paths in the input file are absolute.
+      symbol_path_origin_dir = os.path.abspath(os.getcwd())
+    data_js_file_name = os.path.join(opts.destdir, 'data.js')
+    DumpCompactTree(symbols, symbol_path_origin_dir, data_js_file_name)
     d3_out = os.path.join(opts.destdir, 'd3')
     if not os.path.exists(d3_out):
       os.makedirs(d3_out, 0755)
     d3_src = os.path.join(os.path.dirname(__file__),
                           '..',
                           '..',
                           'third_party', 'd3', 'src')
     template_src = os.path.join(os.path.dirname(__file__),
                                 'template')
     shutil.copy(os.path.join(d3_src, 'LICENSE'), d3_out)
     shutil.copy(os.path.join(d3_src, 'd3.js'), d3_out)
     shutil.copy(os.path.join(template_src, 'index.html'), opts.destdir)
     shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), opts.destdir)
 
   print 'Report saved to ' + opts.destdir + '/index.html'
 
 
 if __name__ == '__main__':
   sys.exit(main())