binarysize tool: Cleaning up some progress output.

build/android/pylib/symbols/elf_symbolizer.py

 # 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.
 
 import collections
 import datetime
 import logging
 import multiprocessing
 import os
 import posixpath
 import Queue
 import re
 import subprocess
 import sys
 import threading
-
+import time

[Primiano Tucci (use gerrit), 2014/09/02 17:10:52]

Nit: you need an extra newline below.

[Daniel Bratell, 2014/09/02 19:48:40]

Done.

 
 # addr2line builds a possibly infinite memory cache that can exhaust
 # the computer's memory if allowed to grow for too long. This constant
 # controls how many lookups we do before restarting the process. 4000
 # gives near peak performance without extreme memory usage.
 ADDR2LINE_RECYCLE_LIMIT = 4000
 
 
 class ELFSymbolizer(object):
   """An uber-fast (multiprocessing, pipelined and asynchronous) ELF symbolizer.
@@ skipping 150 matching lines @@
       a2l.Terminate()
 
   def _CreateNewA2LInstance(self):
     assert(len(self._a2l_instances) < self.max_concurrent_jobs)
     a2l = ELFSymbolizer.Addr2Line(self)
     self._a2l_instances.append(a2l)
     return a2l
 
   def _CreateDisambiguationTable(self):
     """ Non-unique file names will result in None entries"""
+    start_time = time.time()
+    logging.info('Collecting information about available source files...')
     self.disambiguation_table = {}
 
     for root, _, filenames in os.walk(self.source_root_path):
       for f in filenames:
         self.disambiguation_table[f] = os.path.join(root, f) if (f not in
                                        self.disambiguation_table) else None
+    logging.info('Finished collecting information about '
+                 'possible files (took %.1f s).',
+                 (time.time() - start_time))
 
 
   class Addr2Line(object):
     """A python wrapper around an addr2line instance.
 
     The communication with the addr2line process looks as follows:
       [STDIN]         [STDOUT]  (from addr2line's viewpoint)
     > f001111
     > f002222
                     < Symbol::Name(foo, bar) for f001111
@@ skipping 249 matching lines @@
     self.source_line = source_line
     # In the case of |inlines|=True, the |inlined_by| points to the outer
     # function inlining the current one (and so on, to form a chain).
     self.inlined_by = None
     self.disambiguated = disambiguated
     self.was_ambiguous = was_ambiguous
 
   def __str__(self):
     return '%s [%s:%d]' % (
         self.name or '??', self.source_path or '??', self.source_line or 0)