Handle shared memory symbols better in the binarysize tool.

tools/binary_size/explain_binary_size_delta.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.
 
 """Describe the size difference of two binaries.
 
 Generates a description of the size difference of two binaries based
 on the difference of the size of various symbols.
 
@@ skipping 20 matching lines @@
       --nm-out /tmp/nm2.dump
 
   # cleanup useless files
   rm -r /tmp/throwaway
 
   # run this tool
   explain_binary_size_delta.py --nm1 /tmp/nm1.dump --nm2 /tmp/nm2.dump
 """
 
 import collections
+from collections import Counter
+from math import ceil
 import operator
 import optparse
 import os
 import sys
 
 import binary_size_utils
 
 
+def CalculateSharedAddresses(symbols):
+  """Checks how many symbols share the same memory space."""

[Andrew Hayden (chromium.org), 2015/02/16 12:47:38]

Please document the return type.

[Daniel Bratell, 2015/02/18 13:31:53]

Done.

+  count = Counter()
+  for _, _, _, _, address in symbols:
+    count[address] += 1
+
+  # metacount = Counter()

[Andrew Hayden (chromium.org), 2015/02/16 12:47:38]

Please remove the commented lines 57-61 or uncomment and hide them behind a
debug/verbose flag.

[Daniel Bratell, 2015/02/18 13:31:53]

Done.

+  # for share_count in count.itervalues():
+  #   metacount[share_count] += 1
+  # for (key, value) in metacount.items():
+  #   print("%d symbols were shared %d times" % ((value * key), key))
+  return count
+
 def Compare(symbols1, symbols2):
   """Executes a comparison of the symbols in symbols1 and symbols2.
 
   Returns:
       tuple of lists: (added_symbols, removed_symbols, changed_symbols, others)
   """
   added = [] # tuples
   removed = [] # tuples
   changed = [] # tuples
   unchanged = [] # tuples
 
   cache1 = {}
   cache2 = {}
-  # Make a map of (file, symbol_type) : (symbol_name, symbol_size)
-  for cache, symbols in ((cache1, symbols1), (cache2, symbols2)):
-    for symbol_name, symbol_type, symbol_size, file_path in symbols:
+  # Make a map of (file, symbol_type) : (symbol_name, effective_symbol_size)
+  share_count1 = CalculateSharedAddresses(symbols1)
+  share_count2 = CalculateSharedAddresses(symbols2)
+  for cache, symbols, share_count in ((cache1, symbols1, share_count1),
+                                      (cache2, symbols2, share_count2)):
+    for symbol_name, symbol_type, symbol_size, file_path, address in symbols:
       if 'vtable for ' in symbol_name:
         symbol_type = '@' # hack to categorize these separately
       if file_path:
         file_path = os.path.normpath(file_path)
       else:
         file_path = '(No Path)'
+      shared_count = share_count[address]
+      if shared_count == 1:
+        effective_symbol_size = symbol_size
+      else:
+        assert shared_count > 1
+        effective_symbol_size = int(ceil(symbol_size / float(shared_count)))

[Andrew Hayden (chromium.org), 2015/02/16 12:47:38]

For clarity, I'd prefer that we turn this line into a function like
"CalculateEffectiveSize" or something that we can potentially tweak (or at least
serves as a good way to document what we're trying to do here - there could be
other, better strategies that aren't just an equal distribution).

[Daniel Bratell, 2015/02/18 13:31:53]

Done.

       key = (file_path, symbol_type)
       bucket = cache.setdefault(key, {})
       size_list = bucket.setdefault(symbol_name, [])
-      size_list.append(symbol_size)
+      size_list.append(effective_symbol_size)
 
   # Now diff them. We iterate over the elements in cache1. For each symbol
   # that we find in cache2, we record whether it was deleted, changed, or
   # unchanged. We then remove it from cache2; all the symbols that remain
   # in cache2 at the end of the iteration over cache1 are the 'new' symbols.
   for key, bucket1 in cache1.items():
     bucket2 = cache2.get(key)
     if not bucket2:
       # A file was removed. Everything in bucket1 is dead.
       for symbol_name, symbol_size_list in bucket1.items():
@@ skipping 85 matching lines @@
     else:
       shrunk.append(item)
 
   new_symbols = CrunchStatsData(added)
   removed_symbols = CrunchStatsData(removed)
   grown_symbols = CrunchStatsData(grown)
   shrunk_symbols = CrunchStatsData(shrunk)
   sections = [new_symbols, removed_symbols, grown_symbols, shrunk_symbols]
   for section in sections:
     for file_path, symbol_type, symbol_name, size1, size2 in section.symbols:
+      assert not '&' in file_path, "File path: " + file_path

[Andrew Hayden (chromium.org), 2015/02/16 12:47:38]

Is there some context for this being added?

[Daniel Bratell, 2015/02/18 13:31:53]

I really can't remember. Probably remains from some debugging. I will remove it.

       section.sources.add(file_path)
       if size1 is not None:
         section.before_size += size1
       if size2 is not None:
         section.after_size += size2
       bucket = section.symbols_by_path.setdefault(file_path, [])
       bucket.append((symbol_name, symbol_type, size1, size2))
 
   total_change = sum(s.after_size - s.before_size for s in sections)
   summary = 'Total change: %s bytes' % DeltaStr(total_change)
@@ skipping 161 matching lines @@
     with file(path, 'r') as nm_input:
       if opts.verbose:
         print 'parsing ' + path + '...'
       symbols.append(list(binary_size_utils.ParseNm(nm_input)))
   (added, removed, changed, unchanged) = Compare(symbols[0], symbols[1])
   CrunchStats(added, removed, changed, unchanged,
     opts.showsources | opts.showsymbols, opts.showsymbols)
 
 if __name__ == '__main__':
   sys.exit(main())