diagnose_apk_bloat.py: add diff summary.

tools/binary_size/diagnose_apk_bloat.py

 #!/usr/bin/env python
 # 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.
 
 """Tool for finding the cause of APK bloat.
 
 Run diagnose_apk_bloat.py -h for detailed usage help.
 """
 
@@ skipping 26 matching lines @@
 
 _global_restore_checkout_func = None
 
 
 def _SetRestoreFunc(subrepo):
   branch = _GitCmd(['rev-parse', '--abbrev-ref', 'HEAD'], subrepo)
   global _global_restore_checkout_func
   _global_restore_checkout_func = lambda: _GitCmd(['checkout', branch], subrepo)
 
 
+_DiffResult = collections.namedtuple(
+    'DiffResult', ['name', 'value', 'units'])
+
+
 class BaseDiff(object):
   """Base class capturing binary size diffs."""
   def __init__(self, name):
     self.name = name
     self.banner = '\n' + '*' * 30 + name + '*' * 30
 
   def AppendResults(self, logfile):
     """Print and write diff results to an open |logfile|."""
     _PrintAndWriteToFile(logfile, self.banner)
     _PrintAndWriteToFile(logfile, 'Summary:')
     _PrintAndWriteToFile(logfile, self.Summary())
     _PrintAndWriteToFile(logfile, '\nDetails:')
     _PrintAndWriteToFile(logfile, self.DetailedResults())
 
+  @property
+  def summary_stat(self):
+    return None
+
   def Summary(self):
     """A short description that summarizes the source of binary size bloat."""
     raise NotImplementedError()
 
   def DetailedResults(self):
     """An iterable description of the cause of binary size bloat."""
     raise NotImplementedError()
 
   def ProduceDiff(self, archive_dirs):
     """Prepare a binary size diff with ready to print results."""
     raise NotImplementedError()
 
   def RunDiff(self, logfile, archive_dirs):
     self.ProduceDiff(archive_dirs)
     self.AppendResults(logfile)
 
 
 class NativeDiff(BaseDiff):
   _RE_SUMMARY = re.compile(
       r'.*(Section Sizes .*? object files added, \d+ removed).*',
       flags=re.DOTALL)
+  _RE_SUMMARY_STAT = re.compile(
+      r'Section Sizes \(Total=(?P<value>\d+) (?P<units>\w+)\)')
+  _SUMMARY_STAT_NAME = 'Native Library Delta'
 
   def __init__(self, size_name, supersize_path):
     self._size_name = size_name
     self._supersize_path = supersize_path
     self._diff = []
     super(NativeDiff, self).__init__('Native Diff')
 
+  @property
+  def summary_stat(self):
+    m = NativeDiff._RE_SUMMARY_STAT.search(self._diff)
+    if m:
+      return _DiffResult(
+          NativeDiff._SUMMARY_STAT_NAME, m.group('value'), m.group('units'))
+    return None
+
   def DetailedResults(self):
     return self._diff.splitlines()
 
   def Summary(self):
     return NativeDiff._RE_SUMMARY.match(self._diff).group(1)
 
   def ProduceDiff(self, archive_dirs):
     size_files = [os.path.join(a, self._size_name)
                   for a in reversed(archive_dirs)]
     cmd = [self._supersize_path, 'diff'] + size_files
     self._diff = _RunCmd(cmd)[0].replace('{', '{{').replace('}', '}}')
 
 
-_ResourceSizesDiffResult = collections.namedtuple(
-    'ResourceSizesDiffResult', ['section', 'value', 'units'])
-
-
 class ResourceSizesDiff(BaseDiff):
   _RESOURCE_SIZES_PATH = os.path.join(
       _SRC_ROOT, 'build', 'android', 'resource_sizes.py')
 
   def __init__(self, apk_name, slow_options=False):
     self._apk_name = apk_name
     self._slow_options = slow_options
     self._diff = None  # Set by |ProduceDiff()|
     super(ResourceSizesDiff, self).__init__('Resource Sizes Diff')
 
+  @property
+  def summary_stat(self):
+    for s in self._diff:
+      if 'normalized' in s.name:
+        return s
+    return None
+
   def DetailedResults(self):
-    return ['{:>+10,} {} {}'.format(value, units, section)
-            for section, value, units in self._diff]
+    return ['{:>+10,} {} {}'.format(value, units, name)
+            for name, value, units in self._diff]
 
   def Summary(self):
-    for s in self._diff:
-      if 'normalized' in s.section:
-        return 'Normalized APK size: {:+,} {}'.format(s.value, s.units)
-    return ''
+    return 'Normalized APK size: {:+,} {}'.format(
+        self.summary_stat.value, self.summary_stat.units)
 
   def ProduceDiff(self, archive_dirs):
     chartjsons = self._RunResourceSizes(archive_dirs)
     diff = []
     with_patch = chartjsons[0]['charts']
     without_patch = chartjsons[1]['charts']
     for section, section_dict in with_patch.iteritems():
       for subsection, v in section_dict.iteritems():
         # Ignore entries when resource_sizes.py chartjson format has changed.
         if (section not in without_patch or
             subsection not in without_patch[section] or
             v['units'] != without_patch[section][subsection]['units']):
           _Print('Found differing dict structures for resource_sizes.py, '
                  'skipping {} {}', section, subsection)
         else:
           diff.append(
-              _ResourceSizesDiffResult(
+              _DiffResult(
                   '%s %s' % (section, subsection),
                   v['value'] - without_patch[section][subsection]['value'],
                   v['units']))
     self._diff = sorted(diff, key=lambda x: abs(x.value), reverse=True)
 
   def _RunResourceSizes(self, archive_dirs):
     chartjsons = []
     for archive_dir in archive_dirs:
       apk_path = os.path.join(archive_dir, self._apk_name)
       chartjson_file = os.path.join(archive_dir, 'results-chart.json')
@@ skipping 148 matching lines @@
 
 class _DiffArchiveManager(object):
   """Class for maintaining BuildArchives and their related diff artifacts."""
   def __init__(self, revs, archive_dir, diffs, build, subrepo):
     self.archive_dir = archive_dir
     self.build = build
     self.build_archives = [_BuildArchive(rev, archive_dir, build, subrepo)
                            for rev in revs]
     self.diffs = diffs
     self.subrepo = subrepo
+    self._summary_stats = []
 
   def IterArchives(self):
     return iter(self.build_archives)
 
   def MaybeDiff(self, first_id, second_id):
     """Perform diffs given two build archives."""
     archives = [
         self.build_archives[first_id], self.build_archives[second_id]]
     diff_path = self._DiffFilePath(archives)
     if not self._CanDiff(archives):
       _Print('Skipping diff for {} due to missing build archives.', diff_path)
       return
 
     metadata_path = self._DiffMetadataPath(archives)
     metadata = _GenerateMetadata(
         archives, self.build, metadata_path, self.subrepo)
     if _MetadataExists(metadata):
       _Print('Skipping diff for {} and {}. Matching diff already exists: {}',
              archives[0].rev, archives[1].rev, diff_path)
     else:
       if os.path.exists(diff_path):
         os.remove(diff_path)
       archive_dirs = [archives[0].dir, archives[1].dir]
       with open(diff_path, 'a') as diff_file:
         for d in self.diffs:
           d.RunDiff(diff_file, archive_dirs)
-        _Print('See detailed diff results here: {}.', diff_path)
+        _Print('\nSee detailed diff results here: {}.', diff_path)
       _WriteMetadata(metadata)
+      self._AddDiffSummaryStat(archives)
+
+  def Summarize(self):
+    if self._summary_stats:
+      path = os.path.join(self.archive_dir, 'last_diff_summary.txt')
+      with open(path, 'w') as f:
+        stats = sorted(
+            self._summary_stats, key=lambda x: x[0].value, reverse=True)
+        _PrintAndWriteToFile(f, '\nDiff Summary')
+        for s, before, after in stats:
+          _PrintAndWriteToFile(f, '{:>+10} {} {} for range: {}..{}',
+                               s.value, s.units, s.name, before, after)
+
+  def _AddDiffSummaryStat(self, archives):
+    stat = None
+    if self.build.IsAndroid():
+      summary_diff_type = ResourceSizesDiff
+    else:
+      summary_diff_type = NativeDiff
+    for d in self.diffs:
+      if isinstance(d, summary_diff_type):
+        stat = d.summary_stat
+    if stat:
+      self._summary_stats.append((stat, archives[1].rev, archives[0].rev))
 
   def _CanDiff(self, archives):
     return all(a.Exists() for a in archives)
 
   def _DiffFilePath(self, archives):
     return os.path.join(self._DiffDir(archives), 'diff_results.txt')
 
   def _DiffMetadataPath(self, archives):
     return os.path.join(self._DiffDir(archives), 'metadata.txt')
 
   def _DiffDir(self, archives):
-    diff_path = os.path.join(
-        self.archive_dir, 'diffs', '_'.join(a.rev for a in archives))
+    archive_range = '%s..%s' % (archives[1].rev, archives[0].rev)
+    diff_path = os.path.join(self.archive_dir, 'diffs', archive_range)
     _EnsureDirsExist(diff_path)
     return diff_path
 
 
 def _EnsureDirsExist(path):
   if not os.path.exists(path):
     os.makedirs(path)
 
 
 def _GenerateMetadata(archives, build, path, subrepo):
@@ skipping 201 matching lines @@
       'Storage bucket folder structure doesn\'t start with %s' % prefix)
   to_extract = [os.path.join(prefix, f) for f in to_extract]
   for f in to_extract:
     z.extract(f, path=dst)
 
 
 def _Print(s, *args, **kwargs):
   print s.format(*args, **kwargs)
 
 
-def _PrintAndWriteToFile(logfile, s):
+def _PrintAndWriteToFile(logfile, s, *args, **kwargs):
   """Write and print |s| thottling output if |s| is a large list."""
   if isinstance(s, basestring):
+    s = s.format(*args, **kwargs)
     _Print(s)
     logfile.write('%s\n' % s)
   else:
     for l in s[:_DIFF_DETAILS_LINES_THRESHOLD]:
       _Print(l)
     if len(s) > _DIFF_DETAILS_LINES_THRESHOLD:
       _Print('\nOutput truncated, see {} for more.', logfile.name)
     logfile.write('\n'.join(s))
 
 
@@ skipping 115 matching lines @@
             if consecutive_failures > _ALLOWED_CONSECUTIVE_FAILURES:
               _Die('{} builds failed in a row, last failure was {}.',
                    consecutive_failures, archive.rev)
           else:
             archive.ArchiveBuildResults(supersize_path)
             consecutive_failures = 0
 
       if i != 0:
         diff_mngr.MaybeDiff(i - 1, i)
 
+    diff_mngr.Summarize()
+
   _global_restore_checkout_func()
 
 if __name__ == '__main__':
   sys.exit(main())