simpleperf/scripts/app_profiler.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (C) 2016 The Android Open Source Project
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #      http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18 """app_profiler.py: manage the process of profiling an android app.
  19     It downloads simpleperf on device, uses it to collect samples from
  20     user's app, and pulls perf.data and needed binaries on host.
  21 """
  22
  23 from __future__ import print_function
  24 import argparse
  25 import copy
  26 import os
  27 import os.path
  28 import shutil
  29 import subprocess
  30 import sys
  31 import time
  32
  33 from binary_cache_builder import BinaryCacheBuilder
  34 from simpleperf_report_lib import *
  35 from utils import *
  36
  37 class AppProfiler(object):
  38     """Used to manage the process of profiling an android app.
  39
  40     There are three steps:
  41        1. Prepare profiling.
  42        2. Profile the app.
  43        3. Collect profiling data.
  44     """
  45     def __init__(self, config):
  46         # check config variables
  47         config_names = ['app_package_name', 'native_lib_dir', 'apk_file_path',
  48                         'recompile_app', 'launch_activity', 'launch_inst_test',
  49                         'record_options', 'perf_data_path', 'adb_path', 'readelf_path',
  50                         'binary_cache_dir']
  51         for name in config_names:
  52             if not config.has_key(name):
  53                 log_fatal('config [%s] is missing' % name)
  54         native_lib_dir = config.get('native_lib_dir')
  55         if native_lib_dir and not os.path.isdir(native_lib_dir):
  56             log_fatal('[native_lib_dir] "%s" is not a dir' % native_lib_dir)
  57         apk_file_path = config.get('apk_file_path')
  58         if apk_file_path and not os.path.isfile(apk_file_path):
  59             log_fatal('[apk_file_path] "%s" is not a file' % apk_file_path)
  60         self.config = config
  61         self.adb = AdbHelper(self.config['adb_path'])
  62         self.is_root_device = False
  63         self.android_version = 0
  64         self.device_arch = None
  65         self.app_arch = None
  66         self.app_pid = None
  67
  68
  69     def profile(self):
  70         log_info('prepare profiling')
  71         self.prepare_profiling()
  72         log_info('start profiling')
  73         self.start_and_wait_profiling()
  74         log_info('collect profiling data')
  75         self.collect_profiling_data()
  76         log_info('profiling is finished.')
  77
  78
  79     def prepare_profiling(self):
  80         self._get_device_environment()
  81         self._enable_profiling()
  82         self._recompile_app()
  83         self._restart_app()
  84         self._get_app_environment()
  85         self._download_simpleperf()
  86         self._download_native_libs()
  87
  88
  89     def _get_device_environment(self):
  90         self.is_root_device = self.adb.switch_to_root()
  91
  92         # Get android version.
  93         build_version = self.adb.get_property('ro.build.version.release')
  94         if build_version:
  95             if not build_version[0].isdigit():
  96                 c = build_version[0].upper()
  97                 if c < 'L':
  98                     self.android_version = 0
  99                 else:
 100                     self.android_version = ord(c) - ord('L') + 5
 101             else:
 102                 strs = build_version.split('.')
 103                 if strs:
 104                     self.android_version = int(strs[0])
 105
 106         # Get device architecture.
 107         output = self.adb.check_run_and_return_output(['shell', 'uname', '-m'])
 108         if output.find('aarch64') != -1:
 109             self.device_arch = 'aarch64'
 110         elif output.find('arm') != -1:
 111             self.device_arch = 'arm'
 112         elif output.find('x86_64') != -1:
 113             self.device_arch = 'x86_64'
 114         elif output.find('86') != -1:
 115             self.device_arch = 'x86'
 116         else:
 117             log_fatal('unsupported architecture: %s' % output.strip())
 118
 119
 120     def _enable_profiling(self):
 121         self.adb.set_property('security.perf_harden', '0')
 122         if self.is_root_device:
 123             # We can enable kernel symbols
 124             self.adb.run(['shell', 'echo', '0', '>/proc/sys/kernel/kptr_restrict'])
 125
 126
 127     def _recompile_app(self):
 128         if not self.config['recompile_app']:
 129             return
 130         if self.android_version == 0:
 131             log_warning("Can't fully compile an app on android version < L.")
 132         elif self.android_version == 5 or self.android_version == 6:
 133             if not self.is_root_device:
 134                 log_warning("Can't fully compile an app on android version < N on non-root devices.")
 135             elif not self.config['apk_file_path']:
 136                 log_warning("apk file is needed to reinstall the app on android version < N.")
 137             else:
 138                 flag = '-g' if self.android_version == 6 else '--include-debug-symbols'
 139                 self.adb.set_property('dalvik.vm.dex2oat-flags', flag)
 140                 self.adb.check_run(['install', '-r', self.config['apk_file_path']])
 141         elif self.android_version >= 7:
 142             self.adb.set_property('debug.generate-debug-info', 'true')
 143             self.adb.check_run(['shell', 'cmd', 'package', 'compile', '-f', '-m', 'speed',
 144                                 self.config['app_package_name']])
 145         else:
 146             log_fatal('unreachable')
 147
 148
 149     def _restart_app(self):
 150         if not self.config['launch_activity'] and not self.config['launch_inst_test']:
 151             return
 152
 153         pid = self._find_app_process()
 154         if pid is not None:
 155             self.run_in_app_dir(['kill', '-9', str(pid)])
 156             time.sleep(1)
 157
 158         if self.config['launch_activity']:
 159             activity = self.config['app_package_name'] + '/' + self.config['launch_activity']
 160             result = self.adb.run(['shell', 'am', 'start', '-n', activity])
 161             if not result:
 162                 log_fatal("Can't start activity %s" % activity)
 163         else:
 164             runner = self.config['app_package_name'] + '/android.support.test.runner.AndroidJUnitRunner'
 165             result = self.adb.run(['shell', 'am', 'instrument', '-e', 'class',
 166                                    self.config['launch_inst_test'], runner])
 167             if not result:
 168                 log_fatal("Can't start instrumentation test  %s" % self.config['launch_inst_test'])
 169
 170         for i in range(10):
 171             pid = self._find_app_process()
 172             if pid is not None:
 173                 return
 174             time.sleep(1)
 175             log_info('Wait for the app process for %d seconds' % (i + 1))
 176         log_fatal("Can't find the app process")
 177
 178
 179     def _find_app_process(self):
 180         result, output = self.adb.run_and_return_output(['shell', 'ps'])
 181         if not result:
 182             return None
 183         output = output.split('\n')
 184         for line in output:
 185             strs = line.split()
 186             if len(strs) > 2 and strs[-1].find(self.config['app_package_name']) != -1:
 187                 return int(strs[1])
 188         return None
 189
 190
 191     def _get_app_environment(self):
 192         self.app_pid = self._find_app_process()
 193         if self.app_pid is None:
 194             log_fatal("can't find process for app [%s]" % self.config['app_package_name'])
 195         if self.device_arch in ['aarch64', 'x86_64']:
 196             output = self.run_in_app_dir(['cat', '/proc/%d/maps' % self.app_pid])
 197             if output.find('linker64') != -1:
 198                 self.app_arch = self.device_arch
 199             else:
 200                 self.app_arch = 'arm' if self.device_arch == 'aarch64' else 'x86'
 201         else:
 202             self.app_arch = self.device_arch
 203         log_info('app_arch: %s' % self.app_arch)
 204
 205
 206     def _download_simpleperf(self):
 207         simpleperf_binary = get_target_binary_path(self.app_arch, 'simpleperf')
 208         self.adb.check_run(['push', simpleperf_binary, '/data/local/tmp'])
 209         self.run_in_app_dir(['cp', '/data/local/tmp/simpleperf', '.'])
 210         self.run_in_app_dir(['chmod', 'a+x', 'simpleperf'])
 211
 212
 213     def _download_native_libs(self):
 214         if not self.config['native_lib_dir']:
 215             return
 216         filename_dict = dict()
 217         for root, _, files in os.walk(self.config['native_lib_dir']):
 218             for file in files:
 219                 if not file.endswith('.so'):
 220                     continue
 221                 path = os.path.join(root, file)
 222                 old_path = filename_dict.get(file)
 223                 log_info('app_arch = %s' % self.app_arch)
 224                 if self._is_lib_better(path, old_path):
 225                     log_info('%s is better than %s' % (path, old_path))
 226                     filename_dict[file] = path
 227                 else:
 228                     log_info('%s is worse than %s' % (path, old_path))
 229         maps = self.run_in_app_dir(['cat', '/proc/%d/maps' % self.app_pid])
 230         searched_lib = dict()
 231         for item in maps.split():
 232             if item.endswith('.so') and searched_lib.get(item) is None:
 233                 searched_lib[item] = True
 234                 # Use '/' as path separator as item comes from android environment.
 235                 filename = item[item.rfind('/') + 1:]
 236                 dirname = item[1:item.rfind('/')]
 237                 path = filename_dict.get(filename)
 238                 if path is None:
 239                     continue
 240                 self.adb.check_run(['push', path, '/data/local/tmp'])
 241                 self.run_in_app_dir(['mkdir', '-p', dirname])
 242                 self.run_in_app_dir(['cp', '/data/local/tmp/' + filename, dirname])
 243
 244
 245     def _is_lib_better(self, new_path, old_path):
 246         """ Return true if new_path is more likely to be used on device. """
 247         if old_path is None:
 248             return True
 249         if self.app_arch == 'arm':
 250             result1 = new_path.find('armeabi-v7a/') != -1
 251             result2 = old_path.find('armeabi-v7a') != -1
 252             if result1 != result2:
 253                 return result1
 254         arch_dir = 'arm64' if self.app_arch == 'aarch64' else self.app_arch + '/'
 255         result1 = new_path.find(arch_dir) != -1
 256         result2 = old_path.find(arch_dir) != -1
 257         if result1 != result2:
 258             return result1
 259         result1 = new_path.find('obj/') != -1
 260         result2 = old_path.find('obj/') != -1
 261         if result1 != result2:
 262             return result1
 263         return False
 264
 265
 266     def start_and_wait_profiling(self):
 267         self.run_in_app_dir([
 268             './simpleperf', 'record', self.config['record_options'], '-p',
 269             str(self.app_pid), '--symfs', '.'])
 270
 271
 272     def collect_profiling_data(self):
 273         self.run_in_app_dir(['chmod', 'a+rw', 'perf.data'])
 274         self.adb.check_run(['shell', 'cp',
 275             '/data/data/%s/perf.data' % self.config['app_package_name'], '/data/local/tmp'])
 276         self.adb.check_run(['pull', '/data/local/tmp/perf.data', self.config['perf_data_path']])
 277         config = copy.copy(self.config)
 278         config['symfs_dirs'] = []
 279         if self.config['native_lib_dir']:
 280             config['symfs_dirs'].append(self.config['native_lib_dir'])
 281         binary_cache_builder = BinaryCacheBuilder(config)
 282         binary_cache_builder.build_binary_cache()
 283
 284
 285     def run_in_app_dir(self, args):
 286         if self.is_root_device:
 287             cmd = 'cd /data/data/' + self.config['app_package_name'] + ' && ' + (' '.join(args))
 288             return self.adb.check_run_and_return_output(['shell', cmd])
 289         else:
 290             return self.adb.check_run_and_return_output(
 291                 ['shell', 'run-as', self.config['app_package_name']] + args)
 292
 293
 294 if __name__ == '__main__':
 295     parser = argparse.ArgumentParser(
 296         description='Profile an android app. See configurations in app_profiler.config.')
 297     parser.add_argument('--config', default='app_profiler.config',
 298                         help='Set configuration file. Default is app_profiler.config.')
 299     args = parser.parse_args()
 300     config = load_config(args.config)
 301     profiler = AppProfiler(config)
 302     profiler.profile()