Android性能优化实战:如何用Perfetto精准追踪Java/C++方法耗时(附完整代码示例)
如果你在Android性能优化的路上摸爬滚打过一阵子,大概率会碰到这样的场景:应用在某些场景下卡顿,但用常规的Profiler工具只能看到CPU占用高,却很难定位到具体是哪一行代码、哪一个方法在“拖后腿”。这时候,系统级的追踪工具就显得尤为重要。过去几年,Systrace 曾是很多开发者的首选,但如今,Perfetto 已经全面接棒,成为Android平台性能分析的“新标准”。
Perfetto的强大之处在于,它不仅能捕获内核事件,还能无缝集成应用层的手动埋点。这意味着,你可以像在代码里打Log一样,在关键方法前后插入追踪点,然后在Perfetto的UI时间线上,清晰地看到每个方法的执行耗时、调用关系,甚至跨线程的异步操作。这不再是黑盒猜测,而是精准的“外科手术式”定位。
但问题来了:如何在Java和C++代码中正确地插入这些追踪点?原生AOSP开发、普通App的SDK开发、以及NDK开发,这三者的写法有何不同?为什么有时候明明加了代码,Perfetto里却什么也看不到?这篇文章,我将结合大量实战代码,带你彻底搞懂Perfetto的埋点机制,避开那些常见的“坑”。
1. 理解Perfetto的追踪模型:Slice、Counter与Async
在开始写代码之前,我们需要先理解Perfetto记录数据的几种基本模型。这决定了你该选择哪种API来标记你的代码。
Slice(切片) 是最常用的一种。它代表一段有明确开始和结束时间的代码块。在Perfetto UI上,它显示为一个水平条,长度直观地反映了执行耗时。Slice通常是同步的,意味着它必须在同一个线程内开始和结束。
Counter(计数器) 则用于追踪一个随时间变化的数值,比如队列长度、内存使用量、缓冲区填充率等。它在UI上以折线图的形式呈现,让你能观察数值的波动趋势。
Async Slice(异步切片) 用于标记那些开始和结束不在同一个线程(或同一时间点)的操作。例如,一个网络请求的发起和回调,或者一个跨进程的Binder调用。Async Slice通过一个唯一的cookie(或ID)来关联开始和结束事件。
为了更清晰地对比这三种模型,我整理了一个表格:
| 追踪类型 | Perfetto UI显示 | 典型用途 | 关键特性 |
|---|---|---|---|
| 同步Slice | 彩色水平条块 | 函数执行、关键代码段耗时 | 必须同线程内begin/end配对 |
| 异步Slice | 虚线连接的开始/结束标记 | 网络请求、跨线程任务、Binder调用 | 通过唯一ID关联,可跨线程/时间 |
| Counter | 折线图 | 队列深度、内存占用、帧率 | 可任意线程更新,反映数值变化 |
提示:对于绝大多数性能分析场景,同步Slice是你最先需要掌握的工具。它能最直接地回答“这个方法花了多长时间”这个问题。
理解了这些概念,我们就可以进入实战环节了。根据你的开发环境(是修改AOSP源码,还是开发普通App),你需要选择不同的API。
2. 为AOSP原生代码添加追踪点
如果你在进行Android系统底层开发,或者有权限修改AOSP中的Java和C++代码,那么你将使用最“原始”也最强大的一组API。这些API允许你指定追踪类别(Tag),从而在抓取Trace时可以有选择地只启用你关心的部分,减少开销。
2.1 Java层(Platform Private)埋点
在frameworks/base这样的原生Java代码中,你需要使用android.os.Trace类中那些标记为@SystemApi或@Hide的方法。核心方法是traceBegin(long traceTag, String methodName)和traceEnd(long traceTag)。
首先,你需要选择一个合适的traceTag。这个Tag是一个位掩码,定义在Trace.java中。例如:
TRACE_TAG_APP: 应用级代码(通常用于第三方App,但系统代码也可用)TRACE_TAG_AUDIO: 音频子系统TRACE_TAG_GRAPHICS: 图形渲染TRACE_TAG_VIEW: View系统TRACE_TAG_DALVIK: 虚拟机相关
你可以通过位或操作组合多个Tag。选择一个贴近你模块的Tag,有助于在分析时过滤信息。
下面是一个模拟音频播放流程的示例,展示了嵌套Slice和Counter的使用:
import android.os.Trace;
import static android.os.Trace.TRACE_TAG_AUDIO;
public class AudioPlayer {
private SoundDevice mDevice;
private int mBufferUsage = 0;
public void playSound(String path) {
// 开始一个最外层的Slice,命名为"PlaySound"
Trace.traceBegin(TRACE_TAG_AUDIO, "PlaySound");
try {
// 嵌套Slice:测量打开音频设备的时间
Trace.traceBegin(TRACE_TAG_AUDIO, "OpenAudioDevice");
try {
mDevice = openAudioDevice();
} finally {
Trace.traceEnd(); // 结束"OpenAudioDevice"
}
for (int i = 0; i < 10; i++) {
// 嵌套Slice:测量每次发送音频缓冲区的耗时
Trace.traceBegin(TRACE_TAG_AUDIO, "SendBuffer");
try {
sendAudioBuffer(mDevice, getNextAudioChunk());
} finally {
Trace.traceEnd(); // 结束"SendBuffer"
}
// 记录一个Counter:缓冲区的使用情况
mBufferUsage = mDevice.getBufferUsedBytes();
Trace.setCounter(TRACE_TAG_AUDIO, "SndBufferUsage", mBufferUsage);
}
} finally {
Trace.traceEnd(); // 结束最外层的"PlaySound"
}
}
private SoundDevice openAudioDevice() { /* ... */ }
private void sendAudioBuffer(SoundDevice dev, byte[] chunk) { /* ... */ }
private byte[] getNextAudioChunk() { /* ... */ }
}
关键点:
try-finally模式:这是确保每个traceBegin都有对应traceEnd的最佳实践。即使代码块中抛出异常,finally块也能保证结束追踪。- 嵌套结构:Perfetto UI会自动根据
begin和end的调用顺序呈现嵌套关系,让你一目了然地看到调用栈和时间分布。 - Counter更新:
setCounter可以在任何地方调用,用于记录瞬时状态。在UI上,你可以看到“SndBufferUsage”这个计数器随着循环的波动。
2.2 C++层(Platform Private)埋点
在原生C++代码中(例如frameworks/native或system/core),你需要包含<cutils/trace.h>头文件,并使用ATRACE_*系列的宏。同样,你需要先通过#define ATRACE_TAG来定义本编译单元的追踪Tag。
// 在文件顶部定义本模块使用的Tag
#define ATRACE_TAG ATRACE_TAG_AUDIO
#include <cutils/trace.h>
#include <utils/Trace.h> // 如果需要使用C++包装器
void PlaySound(const char* path) {
ATRACE_BEGIN("PlaySound");
// 测量打开音频设备的时间
ATRACE_BEGIN("OpenAudioDevice");
struct snd_dev* dev = OpenAudioDevice();
ATRACE_END(); // 结束 OpenAudioDevice
for (int i = 0; i < 10; i++) {
ATRACE_BEGIN("SendBuffer");
SendAudioBuffer(dev, GetNextAudioChunk());
ATRACE_END(); // 结束 SendBuffer
// 记录计数器:缓冲区使用量
int bufferUsed = dev->buffer_used_bytes;
ATRACE_INT("SndBufferUsage", bufferUsed);
}
ATRACE_END(); // 结束最外层的 PlaySound
}
C++的API风格与Java类似,但更简洁。ATRACE_BEGIN和ATRACE_END必须成对出现。Perfetto也提供了RAII风格的C++包装器在<utils/Trace.h>中,例如ATRACE_CALL()和ATRACE_NAME(),它们利用局部对象构造和析构自动处理begin和end,能有效避免因提前返回或异常导致的end丢失。
#include <utils/Trace.h>
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
void doComplexRendering() {
ATRACE_CALL(); // 自动以函数名“doComplexRendering”开始和结束Slice
// ... 复杂的渲染逻辑
}
void anotherFunction() {
{
ATRACE_NAME("BufferLockSection"); // 仅在此作用域内生效的Slice
// ... 锁操作
} // 作用域结束,Slice自动结束
}
3. 为普通Android App(SDK/NDK)添加追踪点
对于绝大多数应用开发者来说,你无法使用上面那些需要系统权限的Tag参数API。你只能使用Android SDK(Java)和NDK(C++)提供的公开API。这些API隐式使用TRACE_TAG_APP这个Tag。这意味着,你的追踪点默认是关闭的,需要特殊配置才能生效。这是很多开发者踩坑的地方。
3.1 Java(SDK)埋点
在App的Java代码中,使用android.os.Trace的公开方法beginSection(String)和endSection()。
import android.os.Trace;
public class MainActivity extends AppCompatActivity {
private AudioPlayer mPlayer = new AudioPlayer();
@Override
protected void onResume() {
super.onResume();
Trace.beginSection("MainActivity.onResume");
try {
initUI();
mPlayer.prepare();
} finally {
Trace.endSection();
}
}
private void initUI() {
Trace.beginSection("MainActivity.initUI");
// ... 初始化视图
Trace.endSection();
}
}
// 在另一个类中
public class AudioPlayer {
public void prepare() {
Trace.beginSection("AudioPlayer.prepare");
try {
loadResources();
initDecoder();
} finally {
Trace.endSection();
}
}
}
代码看起来很简单,对吧?但如果你直接这么写,然后去抓Perfetto trace,很可能在UI里根本找不到“MainActivity.onResume”这个Slice。问题就出在TRACE_TAG_APP默认没有被启用。
3.2 C/C++(NDK)埋点
在App的JNI或纯Native代码中,使用<android/trace.h>中提供的C API。
#include <android/trace.h>
#include <jni.h>
extern "C" JNIEXPORT void JNICALL
Java_com_example_myapp_AudioPlayer_nativePlay(JNIEnv* env, jobject /* this */, jstring path) {
ATrace_beginSection("nativePlay");
const char* c_path = env->GetStringUTFChars(path, nullptr);
// ... 复杂的本地解码和播放逻辑
for (int i = 0; i < bufferCount; ++i) {
ATrace_beginSection("nativeDecodeFrame");
decodeAndRenderFrame();
ATrace_endSection();
int queueSize = getAudioQueueSize();
ATrace_setCounter("AudioQueueDepth", queueSize);
}
env->ReleaseStringUTFChars(path, c_path);
ATrace_endSection();
}
NDK的API风格与SDK类似,也是beginSection/endSection配对,setCounter设置计数器。
3.3 关键一步:启用App的追踪Tag
为什么SDK/NDK的埋点不生效?因为Perfetto/Atrace系统为了性能,默认不会记录App级别的追踪事件。你需要显式地告诉系统:“我要记录这个App的Trace”。
方法是通过-a参数指定App的包名。
如果你使用命令行抓取Trace,命令如下:
# 使用record_android_trace脚本(推荐)
./record_android_trace -o my_trace.perfetto-trace -t 10s -a com.example.myapp sched freq gfx view
# 或者直接使用adb shell perfetto
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace -t 10s -a com.example.myapp sched freq gfx view
注意-a com.example.myapp这个参数。它的作用是在系统属性debug.atrace.app_cmdlines中设置你的App包名。系统底层的atrace服务会检查当前进程名,如果匹配,就会为你的进程启用ATRACE_TAG_APP标志位。只有这样,你在代码中调用的Trace.beginSection()才会真正生效。
注意:这个机制意味着,你无法在App启动的最初阶段(例如Application的onCreate或第一个Activity的onCreate)就捕获到Trace,因为系统在收到
-a参数并设置属性时,你的App进程可能已经过了这些生命周期。对于分析启动耗时,更推荐使用Android Studio Profiler的“System Trace”功能,或者确保你的启动路径上有足够的延迟,让Trace启用命令先执行。
4. 高级技巧:异步追踪与实战避坑指南
掌握了基础同步Slice和Counter后,我们来看看更复杂的异步场景,以及一些实战中必然会遇到的“坑”。
4.1 追踪异步任务
假设你有一个后台线程池处理任务,你想追踪一个任务从提交到完成的完整生命周期。这时就需要异步Slice。
Java (SDK) 示例:
import android.os.Trace;
import java.util.concurrent.atomic.AtomicInteger;
public class TaskManager {
private final AtomicInteger mTaskIdGenerator = new AtomicInteger(0);
public void submitNetworkTask(String url) {
final int taskId = mTaskIdGenerator.incrementAndGet();
// 在主线程记录异步任务开始
Trace.beginAsyncSection("NetworkRequest", taskId);
Executors.newSingleThreadExecutor().execute(() -> {
// 在后台线程执行
try {
performNetworkRequest(url);
} finally {
// 在后台线程记录异步任务结束
Trace.endAsyncSection("NetworkRequest", taskId);
}
});
}
private void performNetworkRequest(String url) {
// 模拟网络请求
SystemClock.sleep(500);
}
}
在Perfetto UI中,你会看到名为“NetworkRequest”的异步轨道(Async Track),上面有由相同taskId连接的开始和结束标记。这让你能清晰地看到任务的排队、执行和重叠情况。
C++ (NDK/Platform) 示例:
#include <android/trace.h>
#include <atomic>
#include <thread>
std::atomic<int> gLastJobId{0};
void onDecodeRequest(const std::string& filePath) {
int jobId = ++gLastJobId;
ATrace_beginAsyncSection("AsyncDecode", jobId);
std::thread([jobId, filePath]() {
// 在解码线程中执行
decodeFile(filePath);
ATrace_endAsyncSection("AsyncDecode", jobId);
}).detach();
}
4.2 常见问题与解决方案
在实际项目中,你可能会遇到以下问题:
-
Trace点不显示:
- 首要原因:忘记用
-a参数指定App包名。这是最常见的问题。 - 检查Tag是否启用:在平台代码中,你可以通过
Trace.isTagEnabled(tag)或ATRACE_ENABLED()宏来检查。但在SDK/NDK中,这个检查是内置的,如果Tag未启用,beginSection调用是空操作。 - 抓取配置:确保你的Perfetto配置中包含了
atrace数据源,并且勾选了app类别。
- 首要原因:忘记用
-
Slice不闭合或错乱:
- 严格配对:确保每个
begin都有对应的end,尤其是在有多个返回路径的函数中。强烈推荐使用try-finally(Java)或RAII对象(C++)。 - 线程安全:同步Slice不能跨线程。
begin和end必须在同一个线程调用。
- 严格配对:确保每个
-
性能开销:
- 条件编译:在发布(Release)版本中,考虑通过编译开关(如
#ifdef DEBUG)移除Trace代码。 - 采样:对于非常高频的函数,可以考虑采样追踪,而不是每次调用都记录。
- 条件编译:在发布(Release)版本中,考虑通过编译开关(如
-
Trace文件过大:
- 控制粒度:不要在所有函数上都加Trace。只关注关键路径、性能瓶颈怀疑点。
- 使用缓冲区大小参数:抓取时使用
-b参数(如-b 32mb)限制内存缓冲区大小。Perfetto是环形缓冲区,旧数据会被覆盖。
5. 从抓取到分析:完整工作流示例
理论说再多,不如一个完整的例子。假设我们有一个简单的音乐播放器App(包名:com.example.musicplayer),我们想分析其从点击“播放”到第一帧音频输出之间的耗时。
第一步:在代码中插入追踪点。
我们在Java层标记UI交互和播放器准备,在JNI层标记Native解码。
// MainActivity.java
public void onPlayButtonClicked() {
Trace.beginSection("UI_PlayButtonClick");
try {
mPlayer.play(mSelectedSong);
} finally {
Trace.endSection();
}
}
// AudioPlayer.java
public void play(Song song) {
Trace.beginSection("AudioPlayer.play");
try {
Trace.beginSection("AudioPlayer.init");
initAudioTrack();
Trace.endSection();
Trace.beginSection("AudioPlayer.startDecode");
nativeStartDecode(song.getPath()); // 调用JNI
Trace.endSection();
} finally {
Trace.endSection();
}
}
// native-lib.cpp
extern "C" JNIEXPORT void JNICALL
Java_com_example_musicplayer_AudioPlayer_nativeStartDecode(JNIEnv* env, jobject thiz, jstring path) {
ATrace_beginSection("NativeDecode");
const char* cPath = env->GetStringUTFChars(path, nullptr);
AudioDecoder decoder;
decoder.open(cPath);
ATrace_beginSection("NativeDecodeFirstFrame");
decoder.decodeFirstFrame(); // 假设这是个耗时操作
ATrace_endSection();
env->ReleaseStringUTFChars(path, cPath);
ATrace_endSection();
}
第二步:准备抓取脚本。
创建一个capture.sh脚本,使用-a参数指定我们的App。
#!/system/bin/sh
# capture.sh
OUTPUT_FILE="/data/misc/perfetto-traces/$(date +%Y%m%d_%H%M%S)_music_player.perfetto-trace"
DURATION="15s"
BUFFER_SIZE="32mb"
APP_PACKAGE="com.example.musicplayer"
# 使用perfetto命令行抓取
/system/bin/perfetto \
-o $OUTPUT_FILE \
-t $DURATION \
-b $BUFFER_SIZE \
-a $APP_PACKAGE \
sched freq idle am wm gfx view binder_driver hal audio input res memory
echo "Trace saved to: $OUTPUT_FILE"
第三步:执行抓取并复现问题。
# 将脚本推送到设备(需要adb root或可写/data分区)
adb push capture.sh /data/local/tmp/
adb shell chmod +x /data/local/tmp/capture.sh
# 执行脚本,并立即在手机上操作:启动App,点击播放按钮
adb shell /data/local/tmp/capture.sh &
# 操作完成后,拉取trace文件
adb pull $(adb shell "ls /data/misc/perfetto-traces/*music_player*.perfetto-trace | tail -1") .
第四步:在Perfetto UI中分析。
- 打开 ui.perfetto.dev。
- 将抓取的
.perfetto-trace文件拖入浏览器。 - 在UI左侧的进程列表中找到
com.example.musicplayer。 - 展开其线程(通常是主线程和一个可能的解码线程)。
- 现在,你应该能看到清晰的Slice层级:
UI_PlayButtonClickAudioPlayer.playAudioPlayer.initAudioPlayer.startDecodeNativeDecodeNativeDecodeFirstFrame
通过观察每个Slice的长度,你可以精确量化时间消耗在哪个阶段。是initAudioTrack太慢?还是decodeFirstFrame卡住了?一目了然。
6. 超越基础:自定义计数与进程间追踪
当你熟练使用基础Slice后,可以探索更高级的用法来应对复杂场景。
自定义计数器追踪复杂状态:不仅仅是简单的整数,你可以用多个计数器来描绘一个复杂对象的状态。
// 追踪一个连接池的状态
public class ConnectionPool {
private int mActiveConnections;
private int mIdleConnections;
private int mTotalRequests;
public void doRequest() {
Trace.beginSection("ConnectionPool.doRequest");
try {
Connection conn = acquireConnection(); // 内部会修改mActive/mIdle计数
mTotalRequests++;
// 同时更新多个计数器
Trace.setCounter("ConnPool_Active", mActiveConnections);
Trace.setCounter("ConnPool_Idle", mIdleConnections);
Trace.setCounter("ConnPool_TotalReqs", mTotalRequests);
// ... 使用连接
} finally {
Trace.endSection();
}
}
}
在Perfetto UI的计数器面板中,你可以同时观察这三个指标的变化曲线,分析它们之间的关联。
跨进程追踪:对于Binder调用等跨进程操作,你可以在客户端和服务端同时埋点,并使用相同的Slice名称或异步ID来关联它们。虽然Perfetto不会自动链接它们,但通过命名约定(例如Binder:callToXXX),你可以在时间线上手动对齐和分析跨进程调用的延迟。
最后,别忘了Perfetto强大的SQL分析引擎。所有你记录的Slice和Counter数据,都可以通过Perfetto UI内置的“Query (SQL)”功能进行查询。例如,你可以快速找出耗时最长的Slice:
SELECT name, SUM(dur) / 1e6 as total_ms, COUNT(*) as count
FROM slice
WHERE name LIKE 'AudioPlayer.%'
GROUP BY name
ORDER BY total_ms DESC;
这能帮你从海量的追踪数据中,快速聚焦到真正的性能热点上。
性能优化从来不是一蹴而就的,它是一个不断假设、验证、优化的循环。Perfetto提供的这套精准的代码级追踪能力,就是你这个循环中最可靠的“测量工具”。从今天开始,试着在你项目中怀疑的性能热点上插入几个Trace.beginSection,你可能会对代码的实际运行时间有全新的、数据驱动的认识。
323



被折叠的 条评论
为什么被折叠?



