Use find_runtime_symbols in dmprof.

tools/deep_memory_profiler/dmprof

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """The deep heap profiler script for Chrome."""
 
 from datetime import datetime
 import json
 import os
 import re
+import shutil
 import subprocess
 import sys
 import tempfile
 
+FIND_RUNTIME_SYMBOLS_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    os.pardir,
+    'find_runtime_symbols')
+sys.path.append(FIND_RUNTIME_SYMBOLS_PATH)
+
+from prepare_symbol_info import prepare_symbol_info
+from find_runtime_symbols import find_runtime_symbols_list
+
 BUCKET_ID = 5
 VIRTUAL = 0
 COMMITTED = 1
 ALLOC_COUNT = 2
 FREE_COUNT = 3
 NULL_REGEX = re.compile('')
 
-# If an executable pprof script is in the directory of deep_memory_profiler,
-# use it.  Otherwise, use tcmalloc's pprof.
-#
-# A pprof script in deep_memory_profiler/ is prioritized to allow packaging
-# deep_memory_profiler files with a pprof script.  The packaged
-# deep_memory_profiler is downloaded with pprof by using download.sh.
-PPROF_PATH = os.path.join(os.path.dirname(__file__), 'pprof')
-if not (os.path.isfile(PPROF_PATH) and os.access(PPROF_PATH, os.X_OK)):
-  PPROF_PATH = os.path.join(os.path.dirname(__file__),
-                            os.pardir,
-                            os.pardir,
-                            'third_party',
-                            'tcmalloc',
-                            'chromium',
-                            'src',
-                            'pprof')
-
 # Heap Profile Dump versions
 
 # DUMP_DEEP_1 is OBSOLETE.
 # DUMP_DEEP_1 DOES NOT distinct mmap regions and malloc chunks.
 # Their stacktraces DO contain mmap* or tc-* at their tops.
 # They should be processed by POLICY_DEEP_1.
 DUMP_DEEP_1 = 'DUMP_DEEP_1'
 
 # DUMP_DEEP_2 is OBSOLETE.
 # DUMP_DEEP_2 DOES distinct mmap regions and malloc chunks.
@@ skipping 513 matching lines @@
 
     sorted_sizes_list = sorted(
         sizes.iteritems(), key=(lambda x: x[1]), reverse=True)
     total = 0
     for size_pair in sorted_sizes_list:
       sys.stdout.write('%10d %s\n' % (size_pair[1], size_pair[0]))
       total += size_pair[1]
     sys.stderr.write('total: %d\n' % (total))
 
 
-def update_symbols(symbol_path, mapping_lines, chrome_path):
+def update_symbols(symbol_path, mapping_lines, maps_path):
   """Updates address/symbol mapping on memory and in a .symbol cache file.
 
   It reads cached address/symbol mapping from a .symbol file if it exists.
   Then, it resolves unresolved addresses from a Chrome binary with pprof.
   Both mappings on memory and in a .symbol cache file are updated.
 
   Symbol files are formatted as follows:
     <Address> <Symbol>
     <Address> <Symbol>
     <Address> <Symbol>
     ...
 
   Args:
       symbol_path: A string representing a path for a .symbol file.
       mapping_lines: A list of strings containing /proc/.../maps.
-      chrome_path: A string representing a path for a Chrome binary.
+      maps_path: A string of the path of /proc/.../maps.
   """
   with open(symbol_path, mode='a+') as symbol_f:
     symbol_lines = symbol_f.readlines()
     if symbol_lines:
       for line in symbol_lines:
         items = line.split(None, 1)
         address_symbol_dict[items[0]] = items[1].rstrip()
 
     unresolved_addresses = sorted(
         a for a in appeared_addresses if a not in address_symbol_dict)
 
     if unresolved_addresses:
-      with tempfile.NamedTemporaryFile(
-          suffix='maps', prefix="dmprof", mode='w+') as pprof_in:
-        with tempfile.NamedTemporaryFile(
-            suffix='symbols', prefix="dmprof", mode='w+') as pprof_out:
-          for line in mapping_lines:
-            pprof_in.write(line)
+      prepared_data_dir = tempfile.mkdtemp()
+      try:
+        prepare_symbol_info(maps_path, prepared_data_dir)
 
-          for address in unresolved_addresses:
-            pprof_in.write(address + '\n')
+        symbols = find_runtime_symbols_list(
+            prepared_data_dir, unresolved_addresses)
 
-          pprof_in.seek(0)
-
-          p = subprocess.Popen(
-              '%s --symbols %s' % (PPROF_PATH, chrome_path),
-              shell=True, stdin=pprof_in, stdout=pprof_out)
-          p.wait()
-
-          pprof_out.seek(0)
-          symbols = pprof_out.readlines()
-          symbol_f.seek(0, 2)
-          for address, symbol in zip(unresolved_addresses, symbols):
-            stripped_symbol = symbol.strip()
-            address_symbol_dict[address] = stripped_symbol
-            symbol_f.write('%s %s\n' % (address, symbol.strip()))
+        for address, symbol in zip(unresolved_addresses, symbols):
+          stripped_symbol = symbol.strip()
+          address_symbol_dict[address] = stripped_symbol
+          symbol_f.write('%s %s\n' % (address, stripped_symbol))
+      finally:
+        shutil.rmtree(prepared_data_dir)
 
 
 def parse_policy(policy_path):
   """Parses policy file.
 
   A policy file contains component's names and their
   stacktrace pattern written in regular expression.
   Those patterns are matched against each symbols of
   each stacktraces in the order written in the policy file
 
@@ skipping 126 matching lines @@
       new_log.parse_log(buckets)
     except EmptyDumpException:
       sys.stderr.write('  WARNING: ignored an empty dump: %s\n' % path)
     except ParsingException, e:
       sys.stderr.write('  Error in parsing heap profile dump: %s\n' % e)
       sys.exit(1)
     else:
       logs.append(new_log)
 
   sys.stderr.write('getting symbols\n')
-  update_symbols(symbol_path, maps_lines, chrome_path)
+  update_symbols(symbol_path, maps_lines, maps_path)
 
   # TODO(dmikurube): Many modes now.  Split them into separete functions.
   if action == '--stacktrace':
     logs[0].dump_stacktrace(buckets)
 
   elif action == '--csv':
     sys.stdout.write(','.join(components))
     sys.stdout.write('\n')
 
     for log in logs:
@@ skipping 38 matching lines @@
 
   elif action == '--pprof':
     if len(sys.argv) > 5:
       logs[0].dump_for_pprof(policy_list, buckets, maps_lines, sys.argv[5])
     else:
       logs[0].dump_for_pprof(policy_list, buckets, maps_lines, None)
 
 
 if __name__ == '__main__':
   sys.exit(main())