-
首先安装python3环境,参见 Download Python | Python.org
-
下载 perfetto ,地址在 GitHub - google/perfetto: Performance instrumentation and tracing for Android, Linux and Chrome (read-only mirror of https://android.googlesource.com/platform/external/perfetto/)
后面需要用到这里的perfetto\tools\heap_profile
本文放在了目录D:\tools\perfetto
-
抓取一次某个应用的内存命令如下,注意提前关闭其它adb程序,如AS
python D:\tools\perfetto\tools\heap_profile -n com.app.package.name
这里只能抓到一次内存的快照,如果想连续记录多次内存的数据需要能Root手机
首次运行会有如下联网下载
Downloading https://commondatastorage.googleapis.com/perfetto-luci-artifacts/v32.1/windows-amd64/traceconv.exe
如果下载失败,Windows系统请 从连接下载 并参考里面说明放文件。
或者参考如下,修改tools/heap_profile 中 curl 下载方式diff --git a/tools/heap_profile b/tools/heap_profile @@ -243,8 +243,9 @@ def download_or_get_cached(file_name, url, sha256): if needs_download: # Either the filed doesn't exist or the SHA256 doesn't match. tmp_path = bin_path + '.tmp' + proxy_7890='http://127.0.0.1:7890' print('Downloading ' + url) - subprocess.check_call(['curl', '-f', '-L', '-#', '-o', tmp_path, url]) + subprocess.check_call(['curl', '-f', '-L', '-#', '-x', proxy_7890, '-o', tmp_path, url]) with open(tmp_path, 'rb') as fd: actual_sha256 = hashlib.sha256(fd.read()).hexdigest() if actual_sha256 != sha256:
-
连续抓取多次内存快照
adb shell killall -USR1 heapprofd
需要Root权限,上一步骤不要停止
每执行一次,上一步会记录一次D:\tools\perfetto\tools\heap_profile -n com.app.package.name -c 5000
每隔5秒自动dump一次,直到Ctrl+C结束 -
使用
perfetto
分析抓到的raw-trace
文件,即从 Perfetto UI 打开raw-trace
文件
通过点击方块,对比不用时刻的内存。
可以看到第一个大块有内存一直上升,结合其中的栈堆,分析并解决即可。
有时很小泄露,不容易看出,可以反复很多次操作应用后,对比前后数据
以上都是转载的这篇 Android性能优化--Perfetto分析native内存泄露_perfetto native内存-CSDN博客
使用过程中发现 Ctrl+C 结束dump的时候会报错
具体也不知道什么原因。
后来找了个新的heap_profile可以用
#!/usr/bin/env python3
# Copyright (C) 2017 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import atexit
import hashlib
import os
import shutil
import signal
import subprocess
import sys
import tempfile
import time
import uuid
import platform
TRACE_TO_TEXT_SHAS = {
'linux': '7e3e10dfb324e31723efd63ac25037856e06eba0',
'mac': '21f0f42dd019b4f09addd404a114fbf2322ca8a4',
}
TRACE_TO_TEXT_PATH = tempfile.gettempdir()
TRACE_TO_TEXT_BASE_URL = ('https://storage.googleapis.com/perfetto/')
NULL = open(os.devnull)
NOOUT = {
'stdout': NULL,
'stderr': NULL,
}
UUID = str(uuid.uuid4())[-6:]
def check_hash(file_name, sha_value):
file_hash = hashlib.sha1()
with open(file_name, 'rb') as fd:
while True:
chunk = fd.read(4096)
if not chunk:
break
file_hash.update(chunk)
return file_hash.hexdigest() == sha_value
def load_trace_to_text(os_name):
sha_value = TRACE_TO_TEXT_SHAS[os_name]
file_name = 'trace_to_text-' + os_name + '-' + sha_value
local_file = os.path.join(TRACE_TO_TEXT_PATH, file_name)
if os.path.exists(local_file):
if not check_hash(local_file, sha_value):
os.remove(local_file)
else:
return local_file
url = TRACE_TO_TEXT_BASE_URL + file_name
subprocess.check_call(['curl', '-L', '-#', '-o', local_file, url])
if not check_hash(local_file, sha_value):
os.remove(local_file)
raise ValueError("Invalid signature.")
os.chmod(local_file, 0o755)
return local_file
PACKAGES_LIST_CFG = '''data_sources {
config {
name: "android.packages_list"
}
}
'''
CFG_INDENT = ' '
CFG = '''buffers {{
size_kb: 63488
}}
data_sources {{
config {{
name: "android.heapprofd"
heapprofd_config {{
shmem_size_bytes: {shmem_size}
sampling_interval_bytes: {interval}
{target_cfg}
}}
}}
}}
duration_ms: {duration}
write_into_file: true
flush_timeout_ms: 30000
flush_period_ms: 604800000
'''
# flush_period_ms of 1 week to suppress trace_processor_shell warning.
CONTINUOUS_DUMP = """
continuous_dump_config {{
dump_phase_ms: 0
dump_interval_ms: {dump_interval}
}}
"""
PROFILE_LOCAL_PATH = os.path.join(tempfile.gettempdir(), UUID)
IS_INTERRUPTED = False
def sigint_handler(sig, frame):
global IS_INTERRUPTED
IS_INTERRUPTED = True
def print_no_profile_error():
print("No profiles generated", file=sys.stderr)
print(
"If this is unexpected, check "
"https://perfetto.dev/docs/data-sources/native-heap-profiler#troubleshooting.",
file=sys.stderr)
def known_issues_url(number):
return ('https://perfetto.dev/docs/data-sources/native-heap-profiler'
'#known-issues-android{}'.format(number))
KNOWN_ISSUES = {
'10': known_issues_url(10),
'Q': known_issues_url(10),
'11': known_issues_url(11),
'R': known_issues_url(11),
}
def maybe_known_issues():
release_or_codename = subprocess.check_output(
['adb', 'shell', 'getprop', 'ro.build.version.release_or_codename']
).decode('utf-8').strip()
return KNOWN_ISSUES.get(release_or_codename, None)
SDK = {
'R': 30,
}
def release_or_newer(release):
sdk = int(subprocess.check_output(
['adb', 'shell', 'getprop', 'ro.system.build.version.sdk']
).decode('utf-8').strip())
if sdk >= SDK[release]:
return True
codename = subprocess.check_output(
['adb', 'shell', 'getprop', 'ro.build.version.codename']
).decode('utf-8').strip()
return codename == release
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
"-i",
"--interval",
help="Sampling interval. "
"Default 4096 (4KiB)",
type=int,
default=4096)
parser.add_argument(
"-d",
"--duration",
help="Duration of profile (ms). 0 to run until interrupted. "
"Default: until interrupted by user.",
type=int,
default=0)
# This flag is a no-op now. We never start heapprofd explicitly using system
# properties.
parser.add_argument(
"--no-start", help="Do not start heapprofd.", action='store_true')
parser.add_argument(
"-p",
"--pid",
help="Comma-separated list of PIDs to "
"profile.",
metavar="PIDS")
parser.add_argument(
"-n",
"--name",
help="Comma-separated list of process "
"names to profile.",
metavar="NAMES")
parser.add_argument(
"-f",
"--functions",
help="Comma-separated list of functions "
"names to profile.",
metavar="FUNCTIONS")
parser.add_argument(
"-c",
"--continuous-dump",
help="Dump interval in ms. 0 to disable continuous dump.",
type=int,
default=0)
parser.add_argument(
"--heaps",
help="Comma-separated list of heaps to collect, e.g: malloc,art. "
"Requires Android 12.",
metavar="HEAPS")
parser.add_argument(
"--all-heaps",
action="store_true",
help="Collect allocations from all heaps registered by target."
)
parser.add_argument(
"--no-android-tree-symbolization",
action="store_true",
help="Do not symbolize using currently lunched target in the "
"Android tree."
)
parser.add_argument(
"--disable-selinux",
action="store_true",
help="Disable SELinux enforcement for duration of "
"profile.")
parser.add_argument(
"--no-versions",
action="store_true",
help="Do not get version information about APKs.")
parser.add_argument(
"--no-running",
action="store_true",
help="Do not target already running processes. Requires Android 11.")
parser.add_argument(
"--no-startup",
action="store_true",
help="Do not target processes that start during "
"the profile. Requires Android 11.")
parser.add_argument(
"--shmem-size",
help="Size of buffer between client and "
"heapprofd. Default 8MiB. Needs to be a power of two "
"multiple of 4096, at least 8192.",
type=int,
default=8 * 1048576)
parser.add_argument(
"--block-client",
help="When buffer is full, block the "
"client to wait for buffer space. Use with caution as "
"this can significantly slow down the client. "
"This is the default",
action="store_true")
parser.add_argument(
"--block-client-timeout",
help="If --block-client is given, do not block any allocation for "
"longer than this timeout (us).",
type=int)
parser.add_argument(
"--no-block-client",
help="When buffer is full, stop the "
"profile early.",
action="store_true")
parser.add_argument(
"--idle-allocations",
help="Keep track of how many "
"bytes were unused since the last dump, per "
"callstack",
action="store_true")
parser.add_argument(
"--dump-at-max",
help="Dump the maximum memory usage "
"rather than at the time of the dump.",
action="store_true")
parser.add_argument(
"--disable-fork-teardown",
help="Do not tear down client in forks. This can be useful for programs "
"that use vfork. Android 11+ only.",
action="store_true")
parser.add_argument(
"--simpleperf",
action="store_true",
help="Get simpleperf profile of heapprofd. This is "
"only for heapprofd development.")
parser.add_argument(
"--trace-to-text-binary",
help="Path to local trace to text. For debugging.")
parser.add_argument(
"--print-config",
action="store_true",
help="Print config instead of running. For debugging.")
parser.add_argument(
"-o",
"--output",
help="Output directory.",
metavar="DIRECTORY",
default=None)
args = parser.parse_args()
fail = False
if args.block_client and args.no_block_client:
print(
"FATAL: Both block-client and no-block-client given.", file=sys.stderr)
fail = True
if args.pid is None and args.name is None:
print("FATAL: Neither PID nor NAME given.", file=sys.stderr)
fail = True
if args.duration is None:
print("FATAL: No duration given.", file=sys.stderr)
fail = True
if args.interval is None:
print("FATAL: No interval given.", file=sys.stderr)
fail = True
if args.shmem_size % 4096:
print("FATAL: shmem-size is not a multiple of 4096.", file=sys.stderr)
fail = True
if args.shmem_size < 8192:
print("FATAL: shmem-size is less than 8192.", file=sys.stderr)
fail = True
if args.shmem_size & (args.shmem_size - 1):
print("FATAL: shmem-size is not a power of two.", file=sys.stderr)
fail = True
target_cfg = ""
if not args.no_block_client:
target_cfg += CFG_INDENT + "block_client: true\n"
if args.block_client_timeout:
target_cfg += (
CFG_INDENT + "block_client_timeout_us: %s\n" % args.block_client_timeout
)
if args.no_startup:
target_cfg += CFG_INDENT + "no_startup: true\n"
if args.no_running:
target_cfg += CFG_INDENT + "no_running: true\n"
if args.dump_at_max:
target_cfg += CFG_INDENT + "dump_at_max: true\n"
if args.disable_fork_teardown:
target_cfg += CFG_INDENT + "disable_fork_teardown: true\n"
if args.all_heaps:
target_cfg += CFG_INDENT + "all_heaps: true\n"
if args.pid:
for pid in args.pid.split(','):
try:
pid = int(pid)
except ValueError:
print("FATAL: invalid PID %s" % pid, file=sys.stderr)
fail = True
target_cfg += CFG_INDENT + 'pid: {}\n'.format(pid)
if args.name:
for name in args.name.split(','):
target_cfg += CFG_INDENT + 'process_cmdline: "{}"\n'.format(name)
if args.heaps:
for heap in args.heaps.split(','):
target_cfg += CFG_INDENT + 'heaps: "{}"\n'.format(heap)
if args.functions:
for functions in args.functions.split(','):
target_cfg += CFG_INDENT + 'function_names: "{}"\n'.format(functions)
if fail:
parser.print_help()
return 1
trace_to_text_binary = args.trace_to_text_binary
if args.continuous_dump:
target_cfg += CONTINUOUS_DUMP.format(dump_interval=args.continuous_dump)
cfg = CFG.format(
interval=args.interval,
duration=args.duration,
target_cfg=target_cfg,
shmem_size=args.shmem_size)
if not args.no_versions:
cfg += PACKAGES_LIST_CFG
if args.print_config:
print(cfg)
return 0
# Do this AFTER print_config so we do not download trace_to_text only to
# print out the config.
has_trace_to_text = True
if trace_to_text_binary is None:
os_name = None
if sys.platform.startswith('linux'):
os_name = 'linux'
elif sys.platform.startswith('darwin'):
os_name = 'mac'
elif sys.platform.startswith('win32'):
has_trace_to_text = False
else:
print("Invalid platform: {}".format(sys.platform), file=sys.stderr)
return 1
arch = platform.machine()
if arch not in ['x86_64', 'amd64']:
has_trace_to_text = False
if has_trace_to_text:
trace_to_text_binary = load_trace_to_text(os_name)
known_issues = maybe_known_issues()
if known_issues:
print('If you are experiencing problems, please see the known issues for '
'your release: {}.'.format(known_issues))
# TODO(fmayer): Maybe feature detect whether we can remove traces instead of
# this.
uuid_trace = release_or_newer('R')
if uuid_trace:
profile_device_path = '/data/misc/perfetto-traces/profile-' + UUID
else:
user = subprocess.check_output(
['adb', 'shell', 'whoami']).decode('utf-8').strip()
profile_device_path = '/data/misc/perfetto-traces/profile-' + user
perfetto_cmd = ('CFG=\'{cfg}\'; echo ${{CFG}} | '
'perfetto --txt -c - -o ' + profile_device_path + ' -d')
if args.disable_selinux:
enforcing = subprocess.check_output(['adb', 'shell', 'getenforce'])
atexit.register(
subprocess.check_call,
['adb', 'shell', 'su root setenforce %s' % enforcing])
subprocess.check_call(['adb', 'shell', 'su root setenforce 0'])
if args.simpleperf:
subprocess.check_call([
'adb', 'shell', 'mkdir -p /data/local/tmp/heapprofd_profile && '
'cd /data/local/tmp/heapprofd_profile &&'
'(nohup simpleperf record -g -p $(pidof heapprofd) 2>&1 &) '
'> /dev/null'
])
profile_target = PROFILE_LOCAL_PATH
if args.output is not None:
profile_target = args.output
else:
os.mkdir(profile_target)
if not os.path.isdir(profile_target):
print("Output directory {} not found".format(profile_target),
file=sys.stderr)
return 1
if os.listdir(profile_target):
print("Output directory {} not empty".format(profile_target),
file=sys.stderr)
return 1
perfetto_pid = subprocess.check_output(
['adb', 'exec-out',
perfetto_cmd.format(cfg=cfg)]).strip()
try:
perfetto_pid = int(perfetto_pid.strip())
except ValueError:
print("Failed to invoke perfetto: {}".format(perfetto_pid), file=sys.stderr)
return 1
old_handler = signal.signal(signal.SIGINT, sigint_handler)
print("Profiling active. Press Ctrl+C to terminate.")
print("You may disconnect your device.")
print()
exists = True
device_connected = True
while not device_connected or (exists and not IS_INTERRUPTED):
exists = subprocess.call(
['adb', 'shell', '[ -d /proc/{} ]'.format(perfetto_pid)], **NOOUT) == 0
device_connected = subprocess.call(['adb', 'shell', 'true'], **NOOUT) == 0
time.sleep(1)
print("Waiting for profiler shutdown...")
signal.signal(signal.SIGINT, old_handler)
if IS_INTERRUPTED:
# Not check_call because it could have existed in the meantime.
subprocess.call(['adb', 'shell', 'kill', '-INT', str(perfetto_pid)])
if args.simpleperf:
subprocess.check_call(['adb', 'shell', 'killall', '-INT', 'simpleperf'])
print("Waiting for simpleperf to exit.")
while subprocess.call(
['adb', 'shell', '[ -f /proc/$(pidof simpleperf)/exe ]'], **NOOUT) == 0:
time.sleep(1)
subprocess.check_call(
['adb', 'pull', '/data/local/tmp/heapprofd_profile', profile_target])
print(
"Pulled simpleperf profile to " + profile_target + "/heapprofd_profile")
# Wait for perfetto cmd to return.
while exists:
exists = subprocess.call(
['adb', 'shell', '[ -d /proc/{} ]'.format(perfetto_pid)]) == 0
time.sleep(1)
profile_host_path = os.path.join(profile_target, 'raw-trace')
subprocess.check_call(
['adb', 'pull', profile_device_path, profile_host_path], stdout=NULL)
if uuid_trace:
subprocess.check_call(
['adb', 'shell', 'rm', profile_device_path], stdout=NULL)
if not has_trace_to_text:
print('Wrote profile to {}'.format(profile_host_path))
print('This file can be opened using the Perfetto UI, https://ui.perfetto.dev')
return 0
binary_path = os.getenv('PERFETTO_BINARY_PATH')
if not args.no_android_tree_symbolization:
product_out = os.getenv('ANDROID_PRODUCT_OUT')
if product_out:
product_out_symbols = product_out + '/symbols'
else:
product_out_symbols = None
if binary_path is None:
binary_path = product_out_symbols
elif product_out_symbols is not None:
binary_path += ":" + product_out_symbols
trace_file = os.path.join(profile_target, 'raw-trace')
concat_files = [trace_file]
if binary_path is not None:
with open(os.path.join(profile_target, 'symbols'), 'w') as fd:
ret = subprocess.call([
trace_to_text_binary, 'symbolize',
os.path.join(profile_target, 'raw-trace')],
env=dict(os.environ, PERFETTO_BINARY_PATH=binary_path),
stdout=fd)
if ret == 0:
concat_files.append(os.path.join(profile_target, 'symbols'))
else:
print("Failed to symbolize. Continuing without symbols.",
file=sys.stderr)
proguard_map = os.getenv('PERFETTO_PROGUARD_MAP')
if proguard_map is not None:
with open(os.path.join(profile_target, 'deobfuscation-packets'), 'w') as fd:
ret = subprocess.call([
trace_to_text_binary, 'deobfuscate',
os.path.join(profile_target, 'raw-trace')],
env=dict(os.environ, PERFETTO_PROGUARD_MAP=proguard_map),
stdout=fd)
if ret == 0:
concat_files.append(
os.path.join(profile_target, 'deobfuscation-packets'))
else:
print("Failed to deobfuscate. Continuing without deobfuscated.",
file=sys.stderr)
if len(concat_files) > 1:
with open(os.path.join(profile_target, 'symbolized-trace'), 'wb') as out:
for fn in concat_files:
with open(fn, 'rb') as inp:
while True:
buf = inp.read(4096)
if not buf:
break
out.write(buf)
trace_file = os.path.join(profile_target, 'symbolized-trace')
trace_to_text_output = subprocess.check_output(
[trace_to_text_binary, 'profile', trace_file])
profile_path = None
print('caifc trace_file ' + str(trace_file))
print('caifc trace_to_text_output ' + str(trace_to_text_output))
for word in trace_to_text_output.decode('utf-8').split():
if 'heap_profile-' in word:
profile_path = word
if profile_path is None:
print_no_profile_error()
return 1
profile_files = os.listdir(profile_path)
if not profile_files:
print_no_profile_error()
return 1
for profile_file in profile_files:
shutil.copy(os.path.join(profile_path, profile_file), profile_target)
subprocess.check_call(
['gzip'] +
[os.path.join(profile_target, x) for x in profile_files])
symlink_path = None
if args.output is None:
symlink_path = os.path.join(
os.path.dirname(profile_target), "heap_profile-latest")
if os.path.lexists(symlink_path):
os.unlink(symlink_path)
os.symlink(profile_target, symlink_path)
if symlink_path is not None:
print("Wrote profiles to {} (symlink {})".format(
profile_target, symlink_path))
else:
print("Wrote profiles to {}".format(profile_target))
print("These can be viewed using pprof. Googlers: head to pprof/ and "
"upload them.")
if __name__ == '__main__':
sys.exit(main(sys.argv))
JAVA 层的内存泄露可以类似执行下面的脚本
#!/usr/bin/env python3
# Copyright (C) 2020 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import os
import subprocess
import sys
import tempfile
import time
import uuid
NULL = open(os.devnull)
PACKAGES_LIST_CFG = '''data_sources {
config {
name: "android.packages_list"
}
}
'''
CFG_INDENT = ' '
CFG = '''buffers {{
size_kb: {size_kb}
fill_policy: DISCARD
}}
data_sources {{
config {{
name: "android.java_hprof"
java_hprof_config {{
{target_cfg}
{continuous_dump_config}
}}
}}
}}
data_source_stop_timeout_ms: {data_source_stop_timeout_ms}
duration_ms: {duration_ms}
'''
OOM_CFG = '''buffers: {{
size_kb: {size_kb}
fill_policy: DISCARD
}}
data_sources: {{
config {{
name: "android.java_hprof.oom"
java_hprof_config {{
{process_cfg}
}}
}}
}}
data_source_stop_timeout_ms: 100000
trigger_config {{
trigger_mode: START_TRACING
trigger_timeout_ms: {wait_duration_ms}
triggers {{
name: "com.android.telemetry.art-outofmemory"
stop_delay_ms: 500
}}
}}
'''
CONTINUOUS_DUMP = """
continuous_dump_config {{
dump_phase_ms: 0
dump_interval_ms: {dump_interval}
}}
"""
UUID = str(uuid.uuid4())[-6:]
PROFILE_PATH = '/data/misc/perfetto-traces/java-profile-' + UUID
PERFETTO_CMD = ('CFG=\'{cfg}\'; echo ${{CFG}} | '
'perfetto --txt -c - -o ' + PROFILE_PATH + ' -d')
SDK = {
'S': 31,
'UpsideDownCake': 34,
}
def release_or_newer(release):
sdk = int(
subprocess.check_output(
['adb', 'shell', 'getprop',
'ro.system.build.version.sdk']).decode('utf-8').strip())
if sdk >= SDK[release]:
return True
codename = subprocess.check_output(
['adb', 'shell', 'getprop',
'ro.build.version.codename']).decode('utf-8').strip()
return codename == release
def convert_size_to_kb(size):
if size.endswith("kb"):
return int(size[:-2])
elif size.endswith("mb"):
return int(size[:-2]) * 1024
elif size.endswith("gb"):
return int(size[:-2]) * 1024 * 1024
else:
return int(size)
def generate_heap_dump_config(args):
fail = False
if args.pid is None and args.name is None:
print("FATAL: Neither PID nor NAME given.", file=sys.stderr)
fail = True
target_cfg = ""
if args.pid:
for pid in args.pid.split(','):
try:
pid = int(pid)
except ValueError:
print("FATAL: invalid PID %s" % pid, file=sys.stderr)
fail = True
target_cfg += '{}pid: {}\n'.format(CFG_INDENT, pid)
if args.name:
for name in args.name.split(','):
target_cfg += '{}process_cmdline: "{}"\n'.format(CFG_INDENT, name)
if args.dump_smaps:
target_cfg += '{}dump_smaps: true\n'.format(CFG_INDENT)
if fail:
return None
continuous_dump_cfg = ""
if args.continuous_dump:
continuous_dump_cfg = CONTINUOUS_DUMP.format(
dump_interval=args.continuous_dump)
if args.continuous_dump:
# Unlimited trace duration
duration_ms = 0
elif args.stop_when_done:
# Oneshot heapdump and the system supports data_source_stop_timeout_ms, we
# can use a short duration.
duration_ms = 1000
else:
# Oneshot heapdump, but the system doesn't supports
# data_source_stop_timeout_ms, we have to use a longer duration in the hope
# of giving enough time to capture the whole dump.
duration_ms = 20000
if args.stop_when_done:
data_source_stop_timeout_ms = 100000
else:
data_source_stop_timeout_ms = 0
return CFG.format(
size_kb=convert_size_to_kb(args.buffer_size),
target_cfg=target_cfg,
continuous_dump_config=continuous_dump_cfg,
duration_ms=duration_ms,
data_source_stop_timeout_ms=data_source_stop_timeout_ms)
def generate_oom_config(args):
if not release_or_newer('UpsideDownCake'):
print("FATAL: OOM mode not supported for this android version",
file=sys.stderr)
return None
if args.pid:
print("FATAL: Specifying pid not supported in OOM mode",
file=sys.stderr)
return None
if not args.name:
print("FATAL: Must specify process in OOM mode (use --name '*' to match all)",
file=sys.stderr)
return None
if args.continuous_dump:
print("FATAL: Specifying continuous dump not supported in OOM mode",
file=sys.stderr)
return None
if args.dump_smaps:
print("FATAL: Dumping smaps not supported in OOM mode",
file=sys.stderr)
return None
process_cfg = ''
for name in args.name.split(','):
process_cfg += '{}process_cmdline: "{}"\n'.format(CFG_INDENT, name)
return OOM_CFG.format(
size_kb=convert_size_to_kb(args.buffer_size),
wait_duration_ms=args.oom_wait_seconds * 1000,
process_cfg=process_cfg)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
"-o",
"--output",
help="Filename to save profile to.",
metavar="FILE",
default=None)
parser.add_argument(
"-p",
"--pid",
help="Comma-separated list of PIDs to "
"profile.",
metavar="PIDS")
parser.add_argument(
"-n",
"--name",
help="Comma-separated list of process "
"names to profile.",
metavar="NAMES")
parser.add_argument(
"-b",
"--buffer-size",
help="Buffer size in memory that store the whole java heap graph. N(kb|mb|gb)",
type=str,
default="100024kb")
parser.add_argument(
"-c",
"--continuous-dump",
help="Dump interval in ms. 0 to disable continuous dump. When continuous "
"dump is enabled, use CTRL+C to stop",
type=int,
default=0)
parser.add_argument(
"--no-versions",
action="store_true",
help="Do not get version information about APKs.")
parser.add_argument(
"--dump-smaps",
action="store_true",
help="Get information about /proc/$PID/smaps of target.")
parser.add_argument(
"--print-config",
action="store_true",
help="Print config instead of running. For debugging.")
parser.add_argument(
"--stop-when-done",
action="store_true",
default=None,
help="Use a new method to stop the profile when the dump is done. "
"Previously, we would hardcode a duration. Available and default on S.")
parser.add_argument(
"--no-stop-when-done",
action="store_false",
dest='stop_when_done',
help="Do not use a new method to stop the profile when the dump is done.")
parser.add_argument(
"--wait-for-oom",
action="store_true",
dest='wait_for_oom',
help="Starts a tracing session waiting for an OutOfMemoryError to be "
"thrown. Available on U.")
parser.add_argument(
"--oom-wait-seconds",
type=int,
default=60,
help="Seconds to wait for an OutOfMemoryError to be thrown. "
"Defaults to 60.")
args = parser.parse_args()
if args.stop_when_done is None:
args.stop_when_done = release_or_newer('S')
cfg = None
if args.wait_for_oom:
cfg = generate_oom_config(args)
else:
cfg = generate_heap_dump_config(args)
if not cfg:
parser.print_help()
return 1
if not args.no_versions:
cfg += PACKAGES_LIST_CFG
if args.print_config:
print(cfg)
return 0
output_file = args.output
if output_file is None:
fd, name = tempfile.mkstemp('profile')
os.close(fd)
output_file = name
user = subprocess.check_output(['adb', 'shell',
'whoami']).strip().decode('utf8')
perfetto_pid = subprocess.check_output(
['adb', 'exec-out',
PERFETTO_CMD.format(cfg=cfg, user=user)]).strip().decode('utf8')
try:
int(perfetto_pid.strip())
except ValueError:
print("Failed to invoke perfetto: {}".format(perfetto_pid), file=sys.stderr)
return 1
if args.wait_for_oom:
print("Waiting for OutOfMemoryError")
else:
print("Dumping Java Heap.")
exists = True
ctrl_c_count = 0
# Wait for perfetto cmd to return.
while exists:
try:
exists = subprocess.call(
['adb', 'shell', '[ -d /proc/{} ]'.format(perfetto_pid)]) == 0
time.sleep(1)
except KeyboardInterrupt as e:
ctrl_c_count += 1
subprocess.check_call(
['adb', 'shell', 'kill -TERM {}'.format(perfetto_pid)])
if ctrl_c_count == 1:
print("Stopping perfetto and waiting for data...")
else:
raise e
subprocess.check_call(['adb', 'pull', PROFILE_PATH, output_file], stdout=NULL)
subprocess.check_call(['adb', 'shell', 'rm', '-f', PROFILE_PATH], stdout=NULL)
print("Wrote profile to {}".format(output_file))
print("This can be viewed using https://ui.perfetto.dev.")
if __name__ == '__main__':
sys.exit(main(sys.argv))