def start_test(self): runner = self.args.app + '/androidx.test.runner.AndroidJUnitRunner' result = self.adb.run(['shell', 'am', 'instrument', '-e', 'class', self.args.test, runner]) if not result: self.record_subproc.terminate() log_exit("Can't start instrumentation test %s" % self.args.test)
def parse_samples(process, args, sample_filter_fn): """Read samples from record file. process: Process object args: arguments sample_filter_fn: if not None, is used to modify and filter samples. It returns false for samples should be filtered out. """ record_file = args.record_file symfs_dir = args.symfs kallsyms_file = args.kallsyms lib = ReportLib() lib.ShowIpForUnknownSymbol() if symfs_dir: lib.SetSymfs(symfs_dir) if record_file: lib.SetRecordFile(record_file) if kallsyms_file: lib.SetKallsymsFile(kallsyms_file) if args.show_art_frames: lib.ShowArtFrames(True) process.cmd = lib.GetRecordCmd() product_props = lib.MetaInfo().get("product_props") if product_props: manufacturer, model, name = product_props.split(':') process.props['ro.product.manufacturer'] = manufacturer process.props['ro.product.model'] = model process.props['ro.product.name'] = name if lib.MetaInfo().get('trace_offcpu') == 'true': process.props['trace_offcpu'] = True if args.one_flamegraph: log_exit("It doesn't make sense to report with --one-flamegraph for perf.data " + "recorded with --trace-offcpu.""") else: process.props['trace_offcpu'] = False while True: sample = lib.GetNextSample() if sample is None: lib.Close() break symbol = lib.GetSymbolOfCurrentSample() callchain = lib.GetCallChainOfCurrentSample() if sample_filter_fn and not sample_filter_fn(sample, symbol, callchain): continue process.add_sample(sample, symbol, callchain) if process.pid == 0: main_threads = [thread for thread in process.threads.values() if thread.tid == thread.pid] if main_threads: process.name = main_threads[0].name process.pid = main_threads[0].pid for thread in process.threads.values(): min_event_count = thread.num_events * args.min_callchain_percentage * 0.01 thread.flamegraph.trim_callchain(min_event_count) log_info("Parsed %s callchains." % process.num_samples)
def collect_data(args): """ Run app_profiler.py to generate record file. """ app_profiler_args = [sys.executable, os.path.join(scripts_path, "app_profiler.py"), "-nb"] if args.app: app_profiler_args += ["-p", args.app] elif args.native_program: app_profiler_args += ["-np", args.native_program] else: log_exit("Please set profiling target with -p or -np option.") if args.compile_java_code: app_profiler_args.append("--compile_java_code") if args.disable_adb_root: app_profiler_args.append("--disable_adb_root") record_arg_str = "" if args.dwarf_unwinding: record_arg_str += "-g " else: record_arg_str += "--call-graph fp " if args.events: tokens = args.events.split() if len(tokens) == 2: num_events = tokens[0] event_name = tokens[1] record_arg_str += "-c %s -e %s " % (num_events, event_name) else: log_exit("Event format string of -e option cann't be recognized.") log_info("Using event sampling (-c %s -e %s)." % (num_events, event_name)) else: record_arg_str += "-f %d " % args.sample_frequency log_info("Using frequency sampling (-f %d)." % args.sample_frequency) record_arg_str += "--duration %d " % args.capture_duration app_profiler_args += ["-r", record_arg_str] returncode = subprocess.call(app_profiler_args) return returncode == 0
def __init__(self, args): self.args = args self.adb = AdbHelper(enable_switch_to_root=not args.disable_adb_root) self.is_root_device = self.adb.switch_to_root() self.android_version = self.adb.get_android_version() if self.android_version < 7: log_exit("""app_profiler.py isn't supported on Android < N, please switch to use simpleperf binary directly.""") self.device_arch = self.adb.get_device_arch() self.record_subproc = None
def wait_profiling(self): """Wait until profiling finishes, or stop profiling when user presses Ctrl-C.""" returncode = None try: returncode = self.record_subproc.wait() except KeyboardInterrupt: self.stop_profiling() self.record_subproc = None # Don't check return value of record_subproc. Because record_subproc also # receives Ctrl-C, and always returns non-zero. returncode = 0 log_debug('profiling result [%s]' % (returncode == 0)) if returncode != 0: log_exit('Failed to record profiling data.')
def __init__(self, config): # check config variables config_names = [ 'perf_data_list', 'source_dirs', 'comm_filters', 'pid_filters', 'tid_filters', 'dso_filters', 'ndk_path' ] for name in config_names: if name not in config: log_exit('config [%s] is missing' % name) symfs_dir = 'binary_cache' if not os.path.isdir(symfs_dir): symfs_dir = None kallsyms = 'binary_cache/kallsyms' if not os.path.isfile(kallsyms): kallsyms = None # init member variables self.config = config self.symfs_dir = symfs_dir self.kallsyms = kallsyms self.comm_filter = set( config['comm_filters']) if config.get('comm_filters') else None if config.get('pid_filters'): self.pid_filter = {int(x) for x in config['pid_filters']} else: self.pid_filter = None if config.get('tid_filters'): self.tid_filter = {int(x) for x in config['tid_filters']} else: self.tid_filter = None self.dso_filter = set( config['dso_filters']) if config.get('dso_filters') else None config['annotate_dest_dir'] = 'annotated_files' output_dir = config['annotate_dest_dir'] if os.path.isdir(output_dir): shutil.rmtree(output_dir) os.makedirs(output_dir) self.addr2line = Addr2Line(self.config['ndk_path'], symfs_dir, config.get('source_dirs')) self.period = 0 self.dso_periods = {} self.file_periods = {}
def collect_data(args): """ Run app_profiler.py to generate record file. """ app_profiler_args = [ sys.executable, os.path.join(SCRIPTS_PATH, "app_profiler.py"), "-nb" ] if args.app: app_profiler_args += ["-p", args.app] elif args.native_program: app_profiler_args += ["-np", args.native_program] elif args.pid != -1: app_profiler_args += ['--pid', str(args.pid)] elif args.system_wide: app_profiler_args += ['--system_wide'] else: log_exit( "Please set profiling target with -p, -np, --pid or --system_wide option." ) if args.compile_java_code: app_profiler_args.append("--compile_java_code") if args.disable_adb_root: app_profiler_args.append("--disable_adb_root") record_arg_str = "" if args.dwarf_unwinding: record_arg_str += "-g " else: record_arg_str += "--call-graph fp " if args.events: tokens = args.events.split() if len(tokens) == 2: num_events = tokens[0] event_name = tokens[1] record_arg_str += "-c %s -e %s " % (num_events, event_name) else: log_exit("Event format string of -e option cann't be recognized.") log_info("Using event sampling (-c %s -e %s)." % (num_events, event_name)) else: record_arg_str += "-f %d " % args.sample_frequency log_info("Using frequency sampling (-f %d)." % args.sample_frequency) record_arg_str += "--duration %d " % args.capture_duration app_profiler_args += ["-r", record_arg_str] returncode = subprocess.call(app_profiler_args) return returncode == 0
def __init__(self, config): # check config variables config_names = ['perf_data_list', 'source_dirs', 'comm_filters', 'pid_filters', 'tid_filters', 'dso_filters', 'ndk_path'] for name in config_names: if name not in config: log_exit('config [%s] is missing' % name) symfs_dir = 'binary_cache' if not os.path.isdir(symfs_dir): symfs_dir = None kallsyms = 'binary_cache/kallsyms' if not os.path.isfile(kallsyms): kallsyms = None # init member variables self.config = config self.symfs_dir = symfs_dir self.kallsyms = kallsyms self.comm_filter = set(config['comm_filters']) if config.get('comm_filters') else None if config.get('pid_filters'): self.pid_filter = {int(x) for x in config['pid_filters']} else: self.pid_filter = None if config.get('tid_filters'): self.tid_filter = {int(x) for x in config['tid_filters']} else: self.tid_filter = None self.dso_filter = set(config['dso_filters']) if config.get('dso_filters') else None config['annotate_dest_dir'] = 'annotated_files' output_dir = config['annotate_dest_dir'] if os.path.isdir(output_dir): shutil.rmtree(output_dir) os.makedirs(output_dir) self.addr2line = Addr2Line(self.config['ndk_path'], symfs_dir, config.get('source_dirs')) self.period = 0 self.dso_periods = {} self.file_periods = {}
def collect_data(args): app_profiler_args = [ sys.executable, os.path.join(scripts_path, "app_profiler.py"), "-nb" ] if args.app: app_profiler_args += ["-p", args.app] elif args.native_program: app_profiler_args += ["-np", args.native_program] else: log_exit("Please set profiling target with -p or -np option.") if args.skip_recompile: app_profiler_args.append("-nc") if args.disable_adb_root: app_profiler_args.append("--disable_adb_root") record_arg_str = "" if args.dwarf_unwinding: record_arg_str += "-g " else: record_arg_str += "--call-graph fp " if args.events: tokens = args.events.split() if len(tokens) == 2: num_events = tokens[0] event_name = tokens[1] record_arg_str += "-c %s -e %s " % (num_events, event_name) else: log_exit("Event format string of -e option cann't be recognized.") log_info("Using event sampling (-c %s -e %s)." % (num_events, event_name)) else: record_arg_str += "-f %d " % args.sample_frequency log_info("Using frequency sampling (-f %d)." % args.sample_frequency) record_arg_str += "--duration %d " % args.capture_duration app_profiler_args += ["-r", record_arg_str] returncode = subprocess.call(app_profiler_args) return returncode == 0
def main(): parser = argparse.ArgumentParser( description='Report samples in perf.data.') parser.add_argument( '--symfs', help="""Set the path to find binaries with symbols and debug info.""") parser.add_argument('--kallsyms', help='Set the path to find kernel symbols.') parser.add_argument('--record_file', default='perf.data', help='Default is perf.data.') parser.add_argument('-t', '--capture_duration', type=int, default=10, help="""Capture duration in seconds.""") parser.add_argument('-p', '--app', help="""Profile an Android app, given the package name. Like -p com.example.android.myapp.""") parser.add_argument( '-np', '--native_program', default="surfaceflinger", help="""Profile a native program. The program should be running on the device. Like -np surfaceflinger.""") parser.add_argument( '-c', '--color', default='hot', choices=['hot', 'dso', 'legacy'], help="""Color theme: hot=percentage of samples, dso=callsite DSO name, legacy=brendan style""") parser.add_argument('-sc', '--skip_collection', default=False, help='Skip data collection', action="store_true") parser.add_argument('-nc', '--skip_recompile', action='store_true', help="""When profiling an Android app, by default we recompile java bytecode to native instructions to profile java code. It takes some time. You can skip it if the code has been compiled or you don't need to profile java code.""" ) parser.add_argument('-f', '--sample_frequency', type=int, default=6000, help='Sample frequency') parser.add_argument('-du', '--dwarf_unwinding', help='Perform unwinding using dwarf instead of fp.', default=False, action='store_true') parser.add_argument('-e', '--events', help="""Sample based on event occurences instead of frequency. Format expected is "event_counts event_name". e.g: "10000 cpu-cyles". A few examples of event_name: cpu-cycles, cache-references, cache-misses, branch-instructions, branch-misses""", default="") parser.add_argument('--disable_adb_root', action='store_true', help="""Force adb to run in non root mode.""") parser.add_argument('-o', '--report_path', default='report.html', help="Set report path.") parser.add_argument('--embedded_flamegraph', action='store_true', help=""" Generate embedded flamegraph.""") parser.add_argument('--min_callchain_percentage', default=0.01, type=float, help=""" Set min percentage of callchains shown in the report. It is used to limit nodes shown in the flamegraph. For example, when set to 0.01, only callchains taking >= 0.01%% of the event count of the owner thread are collected in the report.""") parser.add_argument('--no_browser', action='store_true', help="Don't open report in browser.") args = parser.parse_args() process = Process("", 0) if not args.skip_collection: process.name = args.app or args.native_program log_info("Starting data collection stage for process '%s'." % process.name) if not collect_data(args): log_exit("Unable to collect data.") result, output = AdbHelper().run_and_return_output( ['shell', 'pidof', process.name]) if result: try: process.pid = int(output) except: process.pid = 0 collect_machine_info(process) else: args.capture_duration = 0 parse_samples(process, args) generate_threads_offsets(process) report_path = output_report(process, args) if not args.no_browser: open_report_in_browser(report_path) log_info("Flamegraph generated at '%s'." % report_path)
def main(): sys.setrecursionlimit(MAX_CALLSTACK_LENGTH * 2 + 50) parser = argparse.ArgumentParser(description='report profiling data') parser.add_argument('-i', '--record_file', nargs='+', default=['perf.data'], help=""" Set profiling data file to report. Default is perf.data.""") parser.add_argument('-o', '--report_path', default='report.html', help=""" Set output html file. Default is report.html.""") parser.add_argument('--min_func_percent', default=0.01, type=float, help=""" Set min percentage of functions shown in the report. For example, when set to 0.01, only functions taking >= 0.01%% of total event count are collected in the report. Default is 0.01.""") parser.add_argument('--min_callchain_percent', default=0.01, type=float, help=""" Set min percentage of callchains shown in the report. It is used to limit nodes shown in the function flamegraph. For example, when set to 0.01, only callchains taking >= 0.01%% of the event count of the starting function are collected in the report. Default is 0.01.""") parser.add_argument('--add_source_code', action='store_true', help='Add source code.') parser.add_argument('--source_dirs', nargs='+', help='Source code directories.') parser.add_argument('--add_disassembly', action='store_true', help='Add disassembled code.') parser.add_argument('--binary_filter', nargs='+', help="""Annotate source code and disassembly only for selected binaries.""") parser.add_argument('--ndk_path', nargs=1, help='Find tools in the ndk path.') parser.add_argument('--no_browser', action='store_true', help="Don't open report in browser.") parser.add_argument('--show_art_frames', action='store_true', help='Show frames of internal methods in the ART Java interpreter.') args = parser.parse_args() # 1. Process args. binary_cache_path = 'binary_cache' if not os.path.isdir(binary_cache_path): if args.add_source_code or args.add_disassembly: log_exit("""binary_cache/ doesn't exist. Can't add source code or disassembled code without collected binaries. Please run binary_cache_builder.py to collect binaries for current profiling data, or run app_profiler.py without -nb option.""") binary_cache_path = None if args.add_source_code and not args.source_dirs: log_exit('--source_dirs is needed to add source code.') build_addr_hit_map = args.add_source_code or args.add_disassembly ndk_path = None if not args.ndk_path else args.ndk_path[0] # 2. Produce record data. record_data = RecordData(binary_cache_path, ndk_path, build_addr_hit_map) for record_file in args.record_file: record_data.load_record_file(record_file, args.show_art_frames) record_data.limit_percents(args.min_func_percent, args.min_callchain_percent) def filter_lib(lib_name): if not args.binary_filter: return True for binary in args.binary_filter: if binary in lib_name: return True return False if args.add_source_code: record_data.add_source_code(args.source_dirs, filter_lib) if args.add_disassembly: record_data.add_disassembly(filter_lib) # 3. Generate report html. report_generator = ReportGenerator(args.report_path) report_generator.write_script() report_generator.write_content_div() report_generator.write_record_data(record_data.gen_record_info()) report_generator.finish() if not args.no_browser: open_report_in_browser(args.report_path) log_info("Report generated at '%s'." % args.report_path)
def build_unwinding_result_report(args): simpleperf_path = get_host_binary_path('simpleperf') proc = subprocess.Popen([simpleperf_path, 'dump', args.record_file[0]], stdout=subprocess.PIPE) (stdoutdata, _) = proc.communicate() stdoutdata = bytes_to_str(stdoutdata) if 'debug_unwind = true' not in stdoutdata: log_exit("Can't parse unwinding result. Because " + "%s was not generated by the debug-unwind cmd." % args.record_file[0]) unwinding_report = UnwindingResultErrorReport(args.omit_callchains_fixed_by_joiner) process_maps = unwinding_report.process_maps lines = stdoutdata.split('\n') i = 0 while i < len(lines): if lines[i].startswith('record mmap:') or lines[i].startswith('record mmap2:'): i += 1 pid = None start = None end = None filename = None while i < len(lines) and not lines[i].startswith('record'): if lines[i].startswith(' pid'): m = re.search(r'pid\s+(\d+).+addr\s+0x(\w+).+len\s+0x(\w+)', lines[i]) if m: pid = int(m.group(1)) start = int(m.group(2), 16) end = start + int(m.group(3), 16) elif 'filename' in lines[i]: pos = lines[i].find('filename') + len('filename') filename = lines[i][pos:].strip() i += 1 if None in [pid, start, end, filename]: log_fatal('unexpected dump output near line %d' % i) process_maps.add(pid, MapEntry(start, end, filename)) elif lines[i].startswith('record unwinding_result:'): i += 1 unwinding_result = collections.OrderedDict() while i < len(lines) and not lines[i].startswith('record'): strs = (lines[i].strip()).split() if len(strs) == 2: unwinding_result[strs[0]] = strs[1] i += 1 for key in ['time', 'used_time', 'stop_reason']: if key not in unwinding_result: log_fatal('unexpected dump output near line %d' % i) i, sample_record = parse_sample_record(lines, i) i, original_record = parse_callchain_record(lines, i, 'ORIGINAL_OFFLINE', process_maps) i, joined_record = parse_callchain_record(lines, i, 'JOINED_OFFLINE', process_maps) if args.omit_sample: sample_record = [] sample_result = SampleResult(original_record.pid, original_record.tid, unwinding_result, original_record.callchain, sample_record) unwinding_report.add_sample_result(sample_result, joined_record) elif lines[i].startswith('record fork:'): i += 1 pid = None ppid = None while i < len(lines) and not lines[i].startswith('record'): if lines[i].startswith(' pid'): m = re.search(r'pid\s+(\w+),\s+ppid\s+(\w+)', lines[i]) if m: pid = int(m.group(1)) ppid = int(m.group(2)) i += 1 if None in [pid, ppid]: log_fatal('unexpected dump output near line %d' % i) process_maps.fork_pid(pid, ppid) elif lines[i].startswith(' debug_unwind_mem'): items = lines[i].strip().split(' = ') if len(items) == 2: unwinding_report.add_mem_stat(items[0], items[1]) i += 1 else: i += 1 return unwinding_report
def main(): # Allow deep callchain with length >1000. sys.setrecursionlimit(1500) parser = argparse.ArgumentParser(description="""Report samples in perf.data. Default option is: "-np surfaceflinger -f 6000 -t 10".""") record_group = parser.add_argument_group('Record options') record_group.add_argument('-du', '--dwarf_unwinding', action='store_true', help="""Perform unwinding using dwarf instead of fp.""") record_group.add_argument('-e', '--events', default="", help="""Sample based on event occurences instead of frequency. Format expected is "event_counts event_name". e.g: "10000 cpu-cyles". A few examples of event_name: cpu-cycles, cache-references, cache-misses, branch-instructions, branch-misses""") record_group.add_argument('-f', '--sample_frequency', type=int, default=6000, help="""Sample frequency""") record_group.add_argument('--compile_java_code', action='store_true', help="""On Android N and Android O, we need to compile Java code into native instructions to profile Java code. Android O also needs wrap.sh in the apk to use the native instructions.""") record_group.add_argument('-np', '--native_program', default="surfaceflinger", help="""Profile a native program. The program should be running on the device. Like -np surfaceflinger.""") record_group.add_argument('-p', '--app', help="""Profile an Android app, given the package name. Like -p com.example.android.myapp.""") record_group.add_argument('--pid', type=int, default=-1, help="""Profile a native program with given pid, the pid should exist on the device.""") record_group.add_argument('--record_file', default='perf.data', help='Default is perf.data.') record_group.add_argument('-sc', '--skip_collection', action='store_true', help="""Skip data collection""") record_group.add_argument('--system_wide', action='store_true', help='Profile system wide.') record_group.add_argument('-t', '--capture_duration', type=int, default=10, help="""Capture duration in seconds.""") report_group = parser.add_argument_group('Report options') report_group.add_argument('-c', '--color', default='hot', choices=['hot', 'dso', 'legacy'], help="""Color theme: hot=percentage of samples, dso=callsite DSO name, legacy=brendan style""") report_group.add_argument('--embedded_flamegraph', action='store_true', help="""Generate embedded flamegraph.""") report_group.add_argument('--kallsyms', help='Set the path to find kernel symbols.') report_group.add_argument('--min_callchain_percentage', default=0.01, type=float, help=""" Set min percentage of callchains shown in the report. It is used to limit nodes shown in the flamegraph. For example, when set to 0.01, only callchains taking >= 0.01%% of the event count of the owner thread are collected in the report.""") report_group.add_argument('--no_browser', action='store_true', help="""Don't open report in browser.""") report_group.add_argument('-o', '--report_path', default='report.html', help="""Set report path.""") report_group.add_argument('--one-flamegraph', action='store_true', help="""Generate one flamegraph instead of one for each thread.""") report_group.add_argument('--symfs', help="""Set the path to find binaries with symbols and debug info.""") report_group.add_argument('--title', help='Show a title in the report.') report_group.add_argument('--show_art_frames', action='store_true', help='Show frames of internal methods in the ART Java interpreter.') debug_group = parser.add_argument_group('Debug options') debug_group.add_argument('--disable_adb_root', action='store_true', help="""Force adb to run in non root mode.""") args = parser.parse_args() process = Process("", 0) if not args.skip_collection: if args.pid != -1: process.pid = args.pid args.native_program = '' if args.system_wide: process.pid = -1 args.native_program = '' if args.system_wide: process.name = 'system_wide' else: process.name = args.app or args.native_program or ('Process %d' % args.pid) log_info("Starting data collection stage for '%s'." % process.name) if not collect_data(args): log_exit("Unable to collect data.") if process.pid == 0: result, output = AdbHelper().run_and_return_output(['shell', 'pidof', process.name]) if result: try: process.pid = int(output) except ValueError: process.pid = 0 collect_machine_info(process) else: args.capture_duration = 0 sample_filter_fn = None if args.one_flamegraph: def filter_fn(sample, _symbol, _callchain): sample.pid = sample.tid = process.pid return True sample_filter_fn = filter_fn if not args.title: args.title = '' args.title += '(One Flamegraph)' parse_samples(process, args, sample_filter_fn) generate_threads_offsets(process) report_path = output_report(process, args) if not args.no_browser: open_report_in_browser(report_path) log_info("Flamegraph generated at '%s'." % report_path)
def check_args(args): if (not args.app) and (args.compile_java_code or args.activity or args.test): log_exit( '--compile_java_code, -a, -t can only be used when profiling an Android app.' )
def start_activity(self): activity = self.args.app + '/' + self.args.activity result = self.adb.run(['shell', 'am', 'start', '-n', activity]) if not result: self.record_subproc.terminate() log_exit("Can't start activity %s" % activity)
python pprof_proto_generator.py pprof -text pprof.profile """ from __future__ import print_function import argparse import os import os.path from simpleperf_report_lib import ReportLib from utils import Addr2Nearestline, bytes_to_str, extant_dir, find_tool_path, flatten_arg_list from utils import log_info, log_exit, str_to_bytes try: import profile_pb2 except ImportError: log_exit('google.protobuf module is missing. Please install it first.') def load_pprof_profile(filename): profile = profile_pb2.Profile() with open(filename, "rb") as f: profile.ParseFromString(bytes_to_str(f.read())) return profile def store_pprof_profile(filename, profile): with open(filename, 'wb') as f: f.write(str_to_bytes(profile.SerializeToString())) class PprofProfilePrinter(object):
def build_unwinding_result_report(args): simpleperf_path = get_host_binary_path('simpleperf') proc = subprocess.Popen([simpleperf_path, 'dump', args.record_file[0]], stdout=subprocess.PIPE) (stdoutdata, _) = proc.communicate() stdoutdata = bytes_to_str(stdoutdata) if 'debug_unwind = true' not in stdoutdata: log_exit("Can't parse unwinding result. Because " + "%s was not generated by the debug-unwind cmd." % args.record_file[0]) unwinding_report = UnwindingResultErrorReport( args.omit_callchains_fixed_by_joiner) process_maps = unwinding_report.process_maps lines = stdoutdata.split('\n') i = 0 while i < len(lines): if lines[i].startswith('record mmap:') or lines[i].startswith( 'record mmap2:'): i += 1 pid = None start = None end = None filename = None while i < len(lines) and not lines[i].startswith('record'): if lines[i].startswith(' pid'): m = re.search( r'pid\s+(\d+).+addr\s+0x(\w+).+len\s+0x(\w+)', lines[i]) if m: pid = int(m.group(1)) start = int(m.group(2), 16) end = start + int(m.group(3), 16) elif 'filename' in lines[i]: pos = lines[i].find('filename') + len('filename') filename = lines[i][pos:].strip() i += 1 if None in [pid, start, end, filename]: log_fatal('unexpected dump output near line %d' % i) process_maps.add(pid, MapEntry(start, end, filename)) elif lines[i].startswith('record unwinding_result:'): i += 1 unwinding_result = collections.OrderedDict() while i < len(lines) and not lines[i].startswith('record'): strs = (lines[i].strip()).split() if len(strs) == 2: unwinding_result[strs[0]] = strs[1] i += 1 for key in ['time', 'used_time', 'stop_reason']: if key not in unwinding_result: log_fatal('unexpected dump output near line %d' % i) i, sample_record = parse_sample_record(lines, i) i, original_record = parse_callchain_record( lines, i, 'ORIGINAL_OFFLINE', process_maps) i, joined_record = parse_callchain_record(lines, i, 'JOINED_OFFLINE', process_maps) if args.omit_sample: sample_record = [] sample_result = SampleResult(original_record.pid, original_record.tid, unwinding_result, original_record.callchain, sample_record) unwinding_report.add_sample_result(sample_result, joined_record) elif lines[i].startswith('record fork:'): i += 1 pid = None ppid = None while i < len(lines) and not lines[i].startswith('record'): if lines[i].startswith(' pid'): m = re.search(r'pid\s+(\w+),\s+ppid\s+(\w+)', lines[i]) if m: pid = int(m.group(1)) ppid = int(m.group(2)) i += 1 if None in [pid, ppid]: log_fatal('unexpected dump output near line %d' % i) process_maps.fork_pid(pid, ppid) elif lines[i].startswith(' debug_unwind_mem'): items = lines[i].strip().split(' = ') if len(items) == 2: unwinding_report.add_mem_stat(items[0], items[1]) i += 1 else: i += 1 return unwinding_report
def main(): sys.setrecursionlimit(MAX_CALLSTACK_LENGTH * 2 + 50) parser = argparse.ArgumentParser(description='report profiling data') parser.add_argument('-i', '--record_file', nargs='+', default=['perf.data'], help=""" Set profiling data file to report. Default is perf.data.""" ) parser.add_argument('-o', '--report_path', default='report.html', help=""" Set output html file. Default is report.html.""") parser.add_argument('--min_func_percent', default=0.01, type=float, help=""" Set min percentage of functions shown in the report. For example, when set to 0.01, only functions taking >= 0.01%% of total event count are collected in the report. Default is 0.01.""" ) parser.add_argument('--min_callchain_percent', default=0.01, type=float, help=""" Set min percentage of callchains shown in the report. It is used to limit nodes shown in the function flamegraph. For example, when set to 0.01, only callchains taking >= 0.01%% of the event count of the starting function are collected in the report. Default is 0.01.""" ) parser.add_argument('--add_source_code', action='store_true', help='Add source code.') parser.add_argument('--source_dirs', nargs='+', help='Source code directories.') parser.add_argument('--add_disassembly', action='store_true', help='Add disassembled code.') parser.add_argument('--binary_filter', nargs='+', help="""Annotate source code and disassembly only for selected binaries.""") parser.add_argument('--ndk_path', nargs=1, help='Find tools in the ndk path.') parser.add_argument('--no_browser', action='store_true', help="Don't open report in browser.") parser.add_argument( '--show_art_frames', action='store_true', help='Show frames of internal methods in the ART Java interpreter.') parser.add_argument('--aggregate-by-thread-name', action='store_true', help="""aggregate samples by thread name instead of thread id. This is useful for showing multiple perf.data generated for the same app.""" ) args = parser.parse_args() # 1. Process args. binary_cache_path = 'binary_cache' if not os.path.isdir(binary_cache_path): if args.add_source_code or args.add_disassembly: log_exit( """binary_cache/ doesn't exist. Can't add source code or disassembled code without collected binaries. Please run binary_cache_builder.py to collect binaries for current profiling data, or run app_profiler.py without -nb option.""") binary_cache_path = None if args.add_source_code and not args.source_dirs: log_exit('--source_dirs is needed to add source code.') build_addr_hit_map = args.add_source_code or args.add_disassembly ndk_path = None if not args.ndk_path else args.ndk_path[0] # 2. Produce record data. record_data = RecordData(binary_cache_path, ndk_path, build_addr_hit_map) for record_file in args.record_file: record_data.load_record_file(record_file, args.show_art_frames) if args.aggregate_by_thread_name: record_data.aggregate_by_thread_name() record_data.limit_percents(args.min_func_percent, args.min_callchain_percent) def filter_lib(lib_name): if not args.binary_filter: return True for binary in args.binary_filter: if binary in lib_name: return True return False if args.add_source_code: record_data.add_source_code(args.source_dirs, filter_lib) if args.add_disassembly: record_data.add_disassembly(filter_lib) # 3. Generate report html. report_generator = ReportGenerator(args.report_path) report_generator.write_script() report_generator.write_content_div() report_generator.write_record_data(record_data.gen_record_info()) report_generator.finish() if not args.no_browser: open_report_in_browser(args.report_path) log_info("Report generated at '%s'." % args.report_path)
def check_args(args): if (not args.app) and (args.compile_java_code or args.activity or args.test): log_exit('--compile_java_code, -a, -t can only be used when profiling an Android app.')