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 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 __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 __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 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)
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.')
