supersize: Update README.md with technical details.

tools/binary_size/libsupersize/describe.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.
 """Methods for converting model objects to human-readable formats."""
 
 import datetime
 import itertools
 import time
 
 import models
@@ skipping 44 matching lines @@
     self.verbose = verbose
     self.recursive = recursive
 
   def _DescribeSectionSizes(self, section_sizes):
     relevant_names = models.SECTION_TO_SECTION_NAME.values()
     section_names = sorted(k for k in section_sizes.iterkeys()
                            if k in relevant_names or k.startswith('.data'))
     total_bytes = sum(v for k, v in section_sizes.iteritems()
                       if k in section_names and k != '.bss')
     yield ''
-    yield 'Section Sizes (Total={:,} bytes):'.format(total_bytes)
+    yield 'Section Sizes (Total={} ({} bytes)):'.format(
+        _PrettySize(total_bytes), total_bytes)
     for name in section_names:
       size = section_sizes[name]
       if name == '.bss':
-        yield '    {}: {:,} bytes (not included in totals)'.format(name, size)
+        yield '    {}: {} ({} bytes) (not included in totals)'.format(
+            name, _PrettySize(size), size)
       else:
         percent = float(size) / total_bytes if total_bytes else 0
-        yield '    {}: {:,} bytes ({:.1%})'.format(name, size, percent)
+        yield '    {}: {} ({} bytes) ({:.1%})'.format(
+            name, _PrettySize(size), size, percent)
 
     if self.verbose:
       yield ''
       yield 'Other section sizes:'
       section_names = sorted(k for k in section_sizes.iterkeys()
                              if k not in section_names)
       for name in section_names:
-        yield '    {}: {:,} bytes'.format(name, section_sizes[name])
+        yield '    {}: {} ({} bytes)'.format(
+            name, _PrettySize(section_sizes[name]), section_sizes[name])
 
   def _DescribeSymbol(self, sym, single_line=False):
     if sym.IsGroup():
       address = 'Group'
     else:
       address = hex(sym.address)
     if self.verbose:
       count_part = '  count=%d' % len(sym) if sym.IsGroup() else ''
       yield '{}@{:<9s}  pss={}  padding={}  size_without_padding={}{}'.format(
           sym.section, address, _FormatPss(sym.pss), sym.padding,
@@ skipping 44 matching lines @@
               _FormatPss(running_total), '({:.1%})'.format(running_percent), l)
 
       if self.recursive and s.IsGroup():
         for l in self._DescribeSymbolGroupChildren(s, indent=indent + 1):
           yield l
 
   def _DescribeSymbolGroup(self, group):
     total_size = group.pss
     code_size = 0
     ro_size = 0
+    data_size = 0
+    bss_size = 0
     unique_paths = set()
     for s in group.IterLeafSymbols():
       if s.section == 't':
         code_size += s.pss
       elif s.section == 'r':
         ro_size += s.pss
+      elif s.section == 'd':
+        data_size += s.pss
+      elif s.section == 'b':
+        bss_size += s.pss
       unique_paths.add(s.object_path)
     header_desc = [
         'Showing {:,} symbols ({:,} unique) with total pss: {} bytes'.format(
             len(group), group.CountUniqueSymbols(), int(total_size)),
-        '.text={:<10} .rodata={:<10} other={:<10} total={}'.format(
+        '.text={:<10} .rodata={:<10} .data*={:<10} .bss={:<10} total={}'.format(
             _PrettySize(int(code_size)), _PrettySize(int(ro_size)),
-            _PrettySize(int(total_size - code_size - ro_size)),
+            _PrettySize(int(data_size)), _PrettySize(int(bss_size)),
             _PrettySize(int(total_size))),
         'Number of object files: {}'.format(len(unique_paths)),
         '',
         'Index, Running Total, Section@Address, PSS',
         '-' * 60
     ]
     children_desc = self._DescribeSymbolGroupChildren(group)
     return itertools.chain(header_desc, children_desc)
 
   def _DescribeSymbolDiff(self, diff):
@@ skipping 150 matching lines @@
 
 def GenerateLines(obj, verbose=False, recursive=False):
   """Returns an iterable of lines (without \n) that describes |obj|."""
   return Describer(verbose=verbose, recursive=recursive).GenerateLines(obj)
 
 
 def WriteLines(lines, func):
   for l in lines:
     func(l)
     func('\n')