Estimates a path in host from a corresponding path in Android device.

tools/deep_memory_profiler/dmprof.py

 # 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."""
 
 import copy
 import datetime
 import json
 import logging
@@ skipping 23 matching lines @@
 
 BUCKET_ID = 5
 VIRTUAL = 0
 COMMITTED = 1
 ALLOC_COUNT = 2
 FREE_COUNT = 3
 NULL_REGEX = re.compile('')
 
 LOGGER = logging.getLogger('dmprof')
 POLICIES_JSON_PATH = os.path.join(BASE_PATH, 'policies.json')
+CHROME_SRC_PATH = os.path.join(BASE_PATH, os.pardir, os.pardir)
 
 
 # Heap Profile Dump versions
 
 # DUMP_DEEP_[1-4] are obsolete.
 # DUMP_DEEP_2+ distinct mmap regions and malloc chunks.
 # DUMP_DEEP_3+ don't include allocation functions in their stack dumps.
 # DUMP_DEEP_4+ support comments with '#' and global stats "nonprofiled-*".
 # DUMP_DEEP_[1-2] should be processed by POLICY_DEEP_1.
 # DUMP_DEEP_[3-4] should be processed by POLICY_DEEP_2 or POLICY_DEEP_3.
@@ skipping 159 matching lines @@
   files by 'prepare()' with tools/find_runtime_symbols/prepare_symbol_info.py.
 
   Binaries are not mandatory to profile.  The prepared data sources work in
   place of the binary even if the binary has been overwritten with another
   binary.
 
   Note that loading the symbol data sources takes a long time.  They are often
   very big.  So, the 'dmprof' profiler is designed to use 'SymbolMappingCache'
   which caches actually used symbols.
   """
-  def __init__(self, prefix, fake_directories=None):
+  def __init__(self, prefix, alternative_dirs=None):
     self._prefix = prefix
     self._prepared_symbol_data_sources_path = None
     self._loaded_symbol_data_sources = None
-    self._fake_directories = fake_directories or {}
+    self._alternative_dirs = alternative_dirs or {}
 
   def prepare(self):
     """Prepares symbol data sources by extracting mapping from a binary.
 
     The prepared symbol data sources are stored in a directory.  The directory
     name is stored in |self._prepared_symbol_data_sources_path|.
 
     Returns:
         True if succeeded.
     """
     LOGGER.info('Preparing symbol mapping...')
     self._prepared_symbol_data_sources_path, used_tempdir = (
         prepare_symbol_info.prepare_symbol_info(
             self._prefix + '.maps',
             output_dir_path=self._prefix + '.symmap',
-            fake_directories=self._fake_directories,
+            alternative_dirs=self._alternative_dirs,
             use_tempdir=True,
             use_source_file_name=True))
     if self._prepared_symbol_data_sources_path:
       LOGGER.info('  Prepared symbol mapping.')
       if used_tempdir:
         LOGGER.warn('  Using a temporary directory for symbol mapping.')
         LOGGER.warn('  Delete it by yourself.')
         LOGGER.warn('  Or, move the directory by yourself to use it later.')
       return True
     else:
@@ skipping 789 matching lines @@
 
   def __getitem__(self, index):
     return self._dump_list[index]
 
 
 class Command(object):
   """Subclasses are a subcommand for this executable.
 
   See COMMANDS in main().
   """
+  _DEVICE_LIB_PATTERN = re.compile(r'(/data/app-lib/.*-[0-9])/.*')
+
   def __init__(self, usage):
     self._parser = optparse.OptionParser(usage)
 
   @staticmethod
   def load_basic_files(
-      dump_path, multiple, no_dump=False, fake_directories=None):
+      dump_path, multiple, no_dump=False, alternative_dirs=None):
     prefix = Command._find_prefix(dump_path)
-    symbol_data_sources = SymbolDataSources(prefix, fake_directories or {})
+    # Translate the symbol information from the Android device to the

[peria, 2013/05/15 17:03:21]

I'm not sure, but does this method work only for Android?
If not, please put "if for Android ..."

[Dai Mikurube (NOT FULLTIME), 2013/05/15 22:44:38]

This method is called even for Linux (not Android) processes.  It assumes that
it's working on Android if the binary is under "/data/app-lib".  (We have no
good way to determine the process was working on Android rather than estimating
from the path.)

Then, I'll add "If the target process is estimated to be working on Android, "
in the comment.  What do you think?

+    # corresponding files in the host.  The location of the files in the host
+    # is estimated from the binary path on the device.  Use --alternative-dirs
+    # to specify the location manually.
+    if not alternative_dirs:
+      alternative_dirs = Command._estimate_alternative_dirs(prefix)
+    if alternative_dirs:
+      for device, host in alternative_dirs.iteritems():
+        LOGGER.info('Assuming %s on device as %s on host' % (device, host))
+    symbol_data_sources = SymbolDataSources(prefix, alternative_dirs)
     symbol_data_sources.prepare()
     bucket_set = BucketSet()
     bucket_set.load(prefix)
     if not no_dump:
       if multiple:
         dump_list = DumpList.load(Command._find_all_dumps(dump_path))
       else:
         dump = Dump.load(dump_path)
     symbol_mapping_cache = SymbolMappingCache()
     with open(prefix + '.cache.function', 'a+') as cache_f:
@@ skipping 14 matching lines @@
     elif multiple:
       return (bucket_set, dump_list)
     else:
       return (bucket_set, dump)
 
   @staticmethod
   def _find_prefix(path):
     return re.sub('\.[0-9][0-9][0-9][0-9]\.heap', '', path)
 
   @staticmethod
+  def _estimate_alternative_dirs(prefix):
+    """Estimates a corresponding host directory for a device-local directory.
+
+    For Android, dmprof.py should find symbol information from the binary in
+    the host, not in the Android device, because dmprof.py doesn't run on
+    Android devices.  This method estimates the lib directory in the host
+    corresponding to the directory in the Android device.
+
+    Returns:
+        A dict that maps a path in the Android device to a path in host.
+        If a file in "/data/app-lib" found in /proc/maps, it assumes the
+        process was running on Android.  An empty dict unless Android.
+    """
+    device_lib_path_candidates = set()
+
+    with open(prefix + '.maps') as maps_f:
+      maps = proc_maps.ProcMaps.load(maps_f)
+      for entry in maps:
+        matched = Command._DEVICE_LIB_PATTERN.match(entry.as_dict()['name'])
+        if matched:
+          device_lib_path_candidates.add(matched.group(1))
+
+    if len(device_lib_path_candidates) == 1:
+      return {device_lib_path_candidates.pop(): os.path.join(
+                  CHROME_SRC_PATH, 'out', 'Debug', 'lib')}
+    else:
+      return {}
+
+  @staticmethod
   def _find_all_dumps(dump_path):
     prefix = Command._find_prefix(dump_path)
     dump_path_list = [dump_path]
 
     n = int(dump_path[len(dump_path) - 9 : len(dump_path) - 5])
     n += 1
     while True:
       p = '%s.%04d.heap' % (prefix, n)
       if os.path.exists(p):
         dump_path_list.append(p)
@@ skipping 92 matching lines @@
         out.write(frame + ' ')
       out.write('\n')
 
 
 class PolicyCommands(Command):
   def __init__(self, command):
     super(PolicyCommands, self).__init__(
         'Usage: %%prog %s [-p POLICY] <first-dump>' % command)
     self._parser.add_option('-p', '--policy', type='string', dest='policy',
                             help='profile with POLICY', metavar='POLICY')
-    self._parser.add_option('--fake-directories', dest='fake_directories',
+    self._parser.add_option('--alternative-dirs', dest='alternative_dirs',
                             metavar='/path/on/target@/path/on/host[:...]',
                             help='Read files in /path/on/host/ instead of '
                                  'files in /path/on/target/.')
 
   def _set_up(self, sys_argv):
     options, args = self._parse_args(sys_argv, 1)
     dump_path = args[1]
-    fake_directories_dict = {}
-    if options.fake_directories:
-      for fake_directory_pair in options.fake_directories.split(':'):
-        target_path, host_path = fake_directory_pair.split('@', 1)
-        fake_directories_dict[target_path] = host_path
+    alternative_dirs_dict = {}
+    if options.alternative_dirs:
+      for alternative_dir_pair in options.alternative_dirs.split(':'):
+        target_path, host_path = alternative_dir_pair.split('@', 1)
+        alternative_dirs_dict[target_path] = host_path
     (bucket_set, dumps) = Command.load_basic_files(
-        dump_path, True, fake_directories=fake_directories_dict)
+        dump_path, True, alternative_dirs=alternative_dirs_dict)
 
     policy_set = PolicySet.load(Command._parse_policy_list(options.policy))
     return policy_set, dumps, bucket_set
 
   @staticmethod
   def _apply_policy(dump, policy, bucket_set, first_dump_time):
     """Aggregates the total memory size of each component.
 
     Iterate through all stacktraces and attribute them to one of the components
     based on the policy.  It is important to apply policy in right order.
@@ skipping 538 matching lines @@
     errorcode = COMMANDS[action]().do(sys.argv)
   except ParsingException, e:
     errorcode = 1
     sys.stderr.write('Exit by parsing error: %s\n' % e)
 
   return errorcode
 
 
 if __name__ == '__main__':
   sys.exit(main())