在 Perfetto 里看到 vsync-app、vsync-sf 和 App 的 doFrame,很容易把三条轨道当成同一个时刻。这篇沿一次帧请求看 VSync 怎样从 SurfaceFlinger 的调度进入 App,接着怎样和 RenderThread、Buffer、FrameTimeline 对齐。

示例以 120 Hz 设备为主。相位配置、是否启用硬件 VSync,以及 App 是否请求下一帧都会改变轨道形态;本文先分清每个信号代表什么,再谈延迟。

版本说明(2026-10 核查):Java、JNI 和调度代码按 android-16.0.0_r1 核对;app/appSf 的分工另引用 Android 13 源码。截图保留历史设备样例,不把它们视为 Android 16/17 的统一配置。代码省略外围状态时会明确说明,片段来自不同类,不能直接拼成可编译程序。

本文目录

系列文章目录

  1. Android Perfetto 系列目录
  2. Android Perfetto 系列 1:Perfetto 工具简介
  3. Android Perfetto 系列 2:Perfetto Trace 抓取
  4. Android Perfetto 系列 3:熟悉 Perfetto View
  5. Android Perfetto 系列 4:使用命令行在本地打开超大 Trace
  6. Android Perfetto 系列 5:Android App 基于 Choreographer 的渲染流程
  7. Android Perfetto 系列 6:为什么是 120Hz?高刷新率的优势与挑战
  8. Android Perfetto 系列 7:MainThread 和 RenderThread 解读
  9. Android Perfetto 系列 8:深入理解 Vsync 机制与性能分析
  10. Android Perfetto 系列 9:CPU 信息解读
  11. Android Perfetto 系列 10:Binder 调度与锁竞争
  12. Android Perfetto 系列 11:PerfettoSQL、Trace Processor 与回归检测
  13. Android Perfetto 系列 12:Trace 数据流与丢失排查
  14. Android Perfetto 系列 13:Perfetto SDK、Track Event 与 App 现场 Trace
  15. Android Perfetto 系列 14:heapprofd 与内存 Profiling
  16. Android Perfetto 系列 15:Boot Trace、长时间现场 Trace 与偶发问题抓取
  17. Android Perfetto 系列 16:GPU、Power Counters 与硬件瓶颈分析
  18. Android Perfetto 系列 17:专项场景自动化、问题清单与平台体系
  19. Android Perfetto 系列 18:响应速度实战,从输入事件到首帧反馈
  20. 视频(B站) - Android Perfetto 基础和案例分享
  21. 视频(B站) - Android Perfetto 分享 - 出图类型分享:AOSP、WebView、Flutter + OEM 系统优化分享

如果大家还没看过 Systrace 系列,下面是传送门:

  1. Systrace 系列目录 : 系统介绍了 Perfetto 的前身 Systrace 的使用,并通过 Systrace 来学习和了解 Android 性能优化和 Android 系统运行的基本规则。
  2. 个人博客 :个人博客,主要是 Android 相关的内容,也放了一些生活和工作相关的内容。

欢迎大家在 关于我 页面查看交流方式,讨论你的问题、你最想看到的关于 Perfetto 的部分,以及跟各位群友讨论所有 Android 开发相关的内容

什么是 Vsync

VSync(Vertical Synchronization,垂直同步)给帧生产和显示合成提供共同的时间参考。App、SurfaceFlinger 与显示硬件会按各自的调度相位工作,不能把它们画成同一个瞬间。

如果扫描输出正在读取的 buffer 被写入新内容,可能在一次刷新中混入不同帧而产生撕裂。Android 的帧调度、buffer 所有权与 fence 共同协调读写,不能简单分成“引入 Choreographer 前撕裂、之后就没有”。

Vsync 解决什么问题?

Android 用 VSync 安排帧回调和合成时点,再用 BufferQueue 与 fence 协调读写:

  1. 显示节拍:显示硬件提供刷新周期信息,系统也可以根据硬件反馈预测后续时点。
  2. App 回调:有待处理帧时,Choreographer 请求 VSync,在回调中执行已登记的 Input、Animation、Traversal 等工作;GPU 工作可继续异步运行。
  3. 合成与同步:SurfaceFlinger 按自己的调度时点取可用 Buffer;acquire fence 约束何时能安全读取,present fence 提供呈现反馈。

以固定 120 Hz 模式为例,名义显示间隔约 8.33 ms。App 的帧可能在更早的周期开始,也可能错过当前预期呈现时点;是否晚呈现要用 FrameTimeline 和合成侧记录判断,不能只看 queueBuffer 的时间。

Android 中 Vsync 的基本工作原理

Android 系统的 Vsync 实现比基本概念复杂得多,需要考虑多个不同的渲染组件,以及它们之间的协调工作。

Vsync 信号的分层架构

需要区分硬件回调、软件调度事件和 trace 计数器:

硬件 Vsync(HW Vsync):显示时序通过 HWC 接口上报给 SurfaceFlinger。固定刷新模式常见 60/90/120 Hz 的周期,但不能推广为硬件回调频率永远等于实际刷新率;Android 15 起支持的 ARR 设备可将 TE/Vsync 与刷新节奏解耦,见第六篇。

SurfaceFlinger 可启停 HWC 的 Vsync 回调并使用软件模型预测后续时点。停回调不等于面板停止刷新,也不能仅凭一张图断言设备“大部分时间”关闭或节省多少功耗。

Vsync-app(应用 Vsync):Choreographer 在有待处理回调时按需请求。下面是 Android 16 Vsync 路径的简化骨架,完整调度分支见后文:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Android 16 Vsync path, timer fallback/logging omitted.
private void scheduleFrameLocked(long now) {
if (!mFrameScheduled) {
mFrameScheduled = true;
if (USE_VSYNC) {
if (isRunningOnLooperThreadLocked()) {
scheduleVsyncLocked();
} else {
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
msg.setAsynchronous(true);
mHandler.sendMessageAtFrontOfQueue(msg);
}
}
// Non-Vsync timer fallback omitted here; shown later.
}
}

静态界面也可能主动注册 FrameCallback;是否请求由待处理工作决定,不是只由手指或肉眼可见动画决定。

Vsync-sf(SurfaceFlinger Vsync):驱动 SF 帧调度;它有独立的工作需求和目标时点,不等于每个 App 都收到一次回调。

Vsync-appSf(应用-SurfaceFlinger Vsync):Android 13 SurfaceFlinger 已分别创建 app、appSf 连接,并独立初始化 SF 的 Vsync 调度。Android 16 也区分 Render/LastComposite 两类客户端时序。appSf 不代表又多了一种面板硬件脉冲;具体客户端与预算须看目标分支。

在 Perfetto 中观察 Vsync

Perfetto trace 中包含多个与 Vsync 相关的 Track,理解这些 Track 的含义有助于分析性能问题。

在 SurfaceFlinger 进程中:

  1. vsync-app
    这份 Trace 中该 counter 在 0 和 1 之间变化,可用变化时点辅助观察调度节奏。它不是某个指定 App 已收到回调的证明。
    image-20250811221826847

  2. vsync-sf
    显示 SurfaceFlinger Vsync 信号状态。即使配置相位相同,按需请求、目标周期和实际调度也可能使它与 app 轨道不同步。
    image-20250811221902646

  3. vsync-appSf
    appSf 是单独的客户端时序。下面保留的截图只露出 VSYNC-app,并未清楚展示 appSf 轨道,不能据图确认其客户端或周期。
    image-20250811222036489

  4. HW_VSYNC
    图中有两类轨道:HW_VSYNC_<displayId> 在硬件回调时翻转;HW_VSYNC_ON_<displayId> 才表示回调启用状态(1/0)。二者不能混读,硬件回调也不等于 App 已执行帧回调。见 Android 16 HWComposer。
    image-20250811222159253

在应用进程中:

FrameDisplayEventReceiver.onVsync Slice Track:
显示应用接收 Vsync 信号的时间点。该事件连接通过 Binder 建链、通过 BitTube/Looper 通道分发事件,接收和分发延迟取决于调度。图中实际名称是 Choreographer#onVsync,缺少这类 slice 也可能是插桩/采集范围不同。

image-20250918220632473

UI Thread Slice Track:
包含 Choreographer#doFrame 及相关的 Input、Animation、Traversal 等 Slice。一次 doFrame 处理到期工作,不保证提交或呈现一帧。

image-20250918220709655

RenderThread Slice Track:
包含 DrawFrames、syncFrameState、drawing、queueBuffer 等渲染线程工作;syncAndDrawFrame/postAndWait 的发起与等待通常在 UI 线程,不能放错轨道。

image-20250918220730872

Android App 每一帧是如何基于 Vsync 工作的

下图把 App 请求回调、主线程执行和 SurfaceFlinger 合成放在一条时间线上。不同帧可能跳过某些阶段,图中箭头表示调查顺序,不表示所有工作都在一个 VSync 周期内完成。

image-20250918221821265

流程总览(按顺序)

  1. 登记到期工作:View 重绘可经 scheduleTraversals 注册 TRAVERSAL;动画、输入或 FrameCallback 也有各自路径,不必先经过遍历
  2. 申请 Vsync:Choreographer 通过 DisplayEventReceiver.scheduleVsync() 申请下一次 Vsync(app 相位)
  3. 接收 Vsync:DisplayEventReceiver.onVsync() 收到 Vsync 后,向主线程消息队列投递异步消息
  4. 主线程帧处理:Choreographer.doFrame() 按顺序执行五类回调:INPUT → ANIMATION → INSETS_ANIMATION → TRAVERSAL → COMMIT
  5. 渲染提交:UI 调用 syncAndDrawFrame,RenderThread 处理 DrawFrames/GPU 提交;buffer 经 BufferQueue/BLAST transaction 提交
  6. 合成显示:有待处理更新时,SurfaceFlinger 按 vsync-sf 调度合成(GPU 或 HWC),通过 HWC 提交显示并取得相应的呈现 fence
  7. 帧完成度量:通过 FrameTimeline(PresentType/JankType)与 acquire/present_fence 判定是否按期显示

下面分别展开每一步的关键实现与 Perfetto 观测点。

App 什么时候会申请 Vsync 信号

应用并不是时刻都在申请 Vsync 信号的。Vsync 信号是按需申请的,下面列出常见触发场景,并非穷尽所有请求来源:

常见的触发申请 Vsync 的场景:

  1. UI 更新需求:当 View 调用 invalidate() 时
  2. 动画执行:ValueAnimator、ObjectAnimator 等动画开始时
  3. 用户交互:触摸事件、按键事件等需要 UI 响应时
  4. 数据变化:RecyclerView 数据更新、TextView 文本改变等

App 申请 Vsync 的完整流程

当应用需要更新 UI 时,会通过以下流程申请 Vsync 信号:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// Android 16 excerpts from three different classes; surrounding state omitted.
// View.java
public void invalidate() {
invalidate(true);
}

public void invalidate(boolean invalidateCache) {
invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true);
}

// invalidateInternal propagates damage under further conditions.
// ViewRootImpl.java
void scheduleTraversals() {
if (!mTraversalScheduled) {
mTraversalScheduled = true;
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
}

// Choreographer.java
private void postCallbackDelayedInternal(int callbackType,
Object action, Object token, long delayMillis) {
if (DEBUG_FRAMES) {
Log.d(TAG, "PostCallback: type=" + callbackType
+ ", action=" + action + ", token=" + token
+ ", delayMillis=" + delayMillis);
}

synchronized (mLock) {
final long now = SystemClock.uptimeMillis();
final long dueTime = now + delayMillis;
mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

if (dueTime <= now) {
scheduleFrameLocked(now);
} else {
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
msg.arg1 = callbackType;
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, dueTime);
}
}
}

到期回调、可见性和已有调度状态共同决定是否请求;不能按 invalidate 次数直接计算 Vsync 次数,任意已到期的回调类型都可能触发调度。

主线程如何监听 Vsync 信号

应用主线程通过 DisplayEventReceiver 来监听 Vsync 信号。这个过程涉及几个关键步骤:

1. 建立连接:

1
2
3
4
5
6
7
8
9
// frameworks/base/core/java/android/view/Choreographer.java
private final class FrameDisplayEventReceiver extends DisplayEventReceiver
implements Runnable {

public FrameDisplayEventReceiver(Looper looper, int vsyncSource, long layerHandle) {
super(looper, vsyncSource, /* eventRegistration */ 0, layerHandle);
// 在构造时建立与 SurfaceFlinger 的连接
}
}

2. 接收 Vsync 信号:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
public void onVsync(long timestampNanos, long physicalDisplayId, int frame,
VsyncEventData vsyncEventData) {
// Timestamp checks, pending-state updates and tracing omitted.
mTimestampNanos = timestampNanos;
mFrame = frame;
mLastVsyncEventData.copyFrom(vsyncEventData);
Message msg = Message.obtain(mHandler, this);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
}

@Override
public void run() {
mHavePendingVsync = false;
doFrame(mTimestampNanos, mFrame, mLastVsyncEventData);
}

几个遗留问题

Q1:为什么不在 onVsync() 中直接执行 doFrame()?

image-20250918221936675

在 Choreographer 路径中,两者通常都在绑定的 Looper 线程;先接收事件,再通过异步 Message 进入帧处理。sendMessageAtTime 设置消息的到期时间,不保证准点获得 CPU。异步标记允许越过同步屏障,不会抢占当前回调或提高 Linux 调度优先级。

Q2:Vsync 来了但主线程在忙,会丢吗?

image-20250918222045731

单次 scheduleVsync 请求一次通知,不会为 App 永久排队每个硬件节拍。Android 16 DisplayEventDispatcher 在处理已积累的多个 Vsync 事件时,只保留较新的信息用于本次分发;这与最终是否有 buffer 被丢弃、是否晚呈现是不同问题。图中长 animation 同时有 Running 和等待状态,不能把整个 slice 都当 CPU 执行。

Q3:CPU/GPU 必须在单个 Vsync 周期内完成吗?

多缓冲允许不同帧的阶段交叠,实际期限由目标呈现时点和调度预算决定。App、BLAST 与 SF 不是各自固定配一套 front/back/第三缓冲;数量、所有权与等待随路径变化。超过一个名义周期不必然代表错过该帧期限,但也不能凭 buffer 数量宣布没有卡顿。

image-20250918222258536

图注“主线程约 14 ms 但没有掉帧”需要目标帧的 FrameTimeline/呈现记录支持,仅凭这些线程和 counter 轨道不足以确认。

Q4:GPU 和 CPU 怎样协同?

CPU 提交 GPU 工作后可继续执行,也可能在驱动或 fence 上等待。acquire fence 约束何时可读取写入结果;允许 unsignaled latch 的策略并不允许读取未完成内容。present fence 用于呈现反馈,不是 App 绘制完成标记。

image-20250918222626100

图中的 GPU completion 是 CPU 侧等待/记录完成的线程,不是 GPU 执行轨道;其 waiting for GPU completion 时长不能直接当 GPU 活跃时长。主线程按时结束仍可能有后续 GPU、合成或显示延迟。

Q5:Vsync 相位会影响什么?

改变 App/SF 计划唤醒时点,会移动各自的工作窗口,也可能改变可赶上的呈现机会;它不能代替降低持续超期的工作量。VsyncWorkDuration-app 记录该客户端的 workDuration 预算,不是实际执行时间、readyDuration 合计或直接的 appOffset。

image-20250918222707300

这张图来自我当时手上的手机,选区为 13 ms 292 μs 500 ns。我原先把这段长度当成了手机配置的 app offset。图中没有 VsyncWorkDuration 轨道或配置 dump,选区跨过不同翻转,不能据此认定手机配置了 13.3 ms app offset。确认配置需对照同一目标帧、显示模式与调度记录,不能用选区代替设备参数。

Vsync Offset / WorkDuration 的技术实现

以 Android 16 为例,配置入口是 VsyncConfiguration 抽象接口,返回的是按场景组织的 VsyncConfigSet。实现中 PhaseOffsets 与 WorkDuration 都派生自 impl::VsyncConfiguration;它再实现 scheduler::VsyncConfiguration 接口。下面保留命名空间,避免把两个同名类混为一谈:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Android 16 declarations: same class name in different namespaces.
namespace android::scheduler {
class VsyncConfiguration {
public:
virtual ~VsyncConfiguration() = default;
virtual VsyncConfigSet getCurrentConfigs() const = 0;
virtual VsyncConfigSet getConfigsForRefreshRate(Fps fps) const = 0;
virtual void reset() = 0;
virtual void setRefreshRateFps(Fps fps) = 0;
virtual void dump(std::string& result) const = 0;
};
namespace impl {
class VsyncConfiguration : public scheduler::VsyncConfiguration {
// Shared implementation, cache and virtual overrides omitted.
};
class WorkDuration : public VsyncConfiguration {
public:
explicit WorkDuration(Fps currentRefreshRate);
// Other constructors and constructOffsets implementation omitted.
};
} // namespace impl
} // namespace android::scheduler

关键概念:Android 16 VSyncDispatchTimerQueue 的基本计算是 wake = targetVsync - workDuration - readyDuration,ready = targetVsync - readyDuration。实际代码还处理重调度、已有目标与时间已过等分支;计划时刻不保证线程准点运行。

对 App 客户端,readyDuration 为 SF 后续工作预留时间;workDuration 是客户端预算。对应 trace counter 是预算值,不是计时器量到的工作耗时。比较 app/sf 相位时应保留符号、目标周期和显示模式,直接取绝对差会丢失先后与跨周期关系。

相位差的简化时序示意

以下只是假设固定 120 Hz、每 8.333 ms 一个呈现机会的理想示意。两种安排都令 App 工作 3 ms、SF 工作 2 ms,忽略其他等待,并以同一个 T0 为时间基准:

安排 A:App 与 SF 同时被计划唤醒

  • T0:App 开始,SF 本次尚无这帧的新 buffer。
  • T0+3 ms:App 的 buffer 已就绪。
  • T0+8.333 ms:假设 SF 在下次调度处理该 buffer。
  • T0+10.333 ms:SF 完成,赶上 T0+16.666 ms 的呈现机会。

安排 B:错开工作窗口

  • T0+1 ms:App 开始。
  • T0+4 ms:App 完成同样的 3 ms 工作,buffer 就绪。
  • T0+4.5 ms:SF 开始。
  • T0+6.5 ms:SF 完成同样的 2 ms 工作,赶上 T0+8.333 ms 的呈现机会。

这是一个在特定假设下赶上较早显示机会的例子,未给出输入采样时刻,也没有测量 scanout/触达像素的时间,不能推出输入延迟普遍减半。实际系统可能流水线重叠、跨周期或采用不同 deadline。

出现晚帧时继续检查:App/GPU 完成与目标期限、buffer 所有权与 fence、SF/显示工作、线程调度及资源竞争。buffer 耗尽不必由 App 执行慢引起;SF 晚帧的影响也需按显示和图层判断,不能笼统归于所有应用。

Vsync 信号的完整代码流程

下面展示请求、预测调度与事件送达的关键链路。硬件回调可用于校准,不是每次软件通知都要先经过一次硬件回调。

Android 16 的关键代码(精简摘录)

以下按 android-16.0.0_r1 解释,省略字段、外围循环或其他分支的位置均有说明。Java、JNI、客户端 native 与 SF 端属于不同类;不是可拼接编译的一份代码。

1)Choreographer 申请下一次 Vsync(Java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// android-16.0.0_r1, Choreographer.java
private void scheduleFrameLocked(long now) {
if (!mFrameScheduled) {
mFrameScheduled = true;
if (USE_VSYNC) {
if (DEBUG_FRAMES) {
Log.d(TAG, "Scheduling next frame on vsync.");
}

// If running on the Looper thread, then schedule the vsync immediately,
// otherwise post a message to schedule the vsync from the UI thread
// as soon as possible.
if (isRunningOnLooperThreadLocked()) {
scheduleVsyncLocked();
} else {
Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
msg.setAsynchronous(true);
mHandler.sendMessageAtFrontOfQueue(msg);
}
} else {
final long nextFrameTime = Math.max(
mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
if (DEBUG_FRAMES) {
Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");
}
Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, nextFrameTime);
}
}
}

private void scheduleVsyncLocked() {
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#scheduleVsyncLocked");
mDisplayEventReceiver.scheduleVsync();
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}

2)Choreographer 接收 Vsync(Java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
public void onVsync(long timestampNanos, long physicalDisplayId, int frame,
VsyncEventData vsyncEventData) {
// Timestamp checks, pending-state updates and tracing omitted.
mTimestampNanos = timestampNanos;
mFrame = frame;
mLastVsyncEventData.copyFrom(vsyncEventData);
Message msg = Message.obtain(mHandler, this);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
}

@Override
public void run() {
mHavePendingVsync = false;
doFrame(mTimestampNanos, mFrame, mLastVsyncEventData);
}

3)JNI 层桥接:DisplayEventDispatcher(C++)

1
2
3
4
5
6
7
8
9
10
11
12
// frameworks/base/core/jni/android_view_DisplayEventReceiver.cpp
class NativeDisplayEventReceiver : public DisplayEventDispatcher {
public:
NativeDisplayEventReceiver(JNIEnv* env, jobject receiverWeak, jobject vsyncEventDataWeak,
const sp<MessageQueue>& messageQueue, jint vsyncSource,
jint eventRegistration, jlong layerHandle);

private:
void dispatchVsync(nsecs_t timestamp, PhysicalDisplayId displayId, uint32_t count,
VsyncEventData vsyncEventData) override;
void dispatchHotplug(nsecs_t timestamp, PhysicalDisplayId displayId, bool connected) override;
};

4)Native 收发通道:DisplayEventReceiver + BitTube(C++)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// android-16.0.0_r1, DisplayEventReceiver.cpp
DisplayEventReceiver::DisplayEventReceiver(gui::ISurfaceComposer::VsyncSource vsyncSource,
EventRegistrationFlags eventRegistration,
const sp<IBinder>& layerHandle) {
sp<gui::ISurfaceComposer> sf(ComposerServiceAIDL::getComposerService());
if (sf != nullptr) {
mEventConnection = nullptr;
binder::Status status =
sf->createDisplayEventConnection(vsyncSource,
static_cast<
gui::ISurfaceComposer::EventRegistration>(
eventRegistration.get()),
layerHandle, &mEventConnection);
if (status.isOk() && mEventConnection != nullptr) {
mDataChannel = std::make_unique<gui::BitTube>();
status = mEventConnection->stealReceiveChannel(mDataChannel.get());
if (!status.isOk()) {
ALOGE("stealReceiveChannel failed: %s", status.toString8().c_str());
mInitError = std::make_optional<status_t>(status.transactionError());
mDataChannel.reset();
mEventConnection.clear();
}
} else {
ALOGE("DisplayEventConnection creation failed: status=%s", status.toString8().c_str());
}
}
}

status_t DisplayEventReceiver::requestNextVsync() {
if (mEventConnection != nullptr) {
mEventConnection->requestNextVsync();
return NO_ERROR;
}
return mInitError.has_value() ? mInitError.value() : NO_INIT;
}

ssize_t DisplayEventReceiver::getEvents(DisplayEventReceiver::Event* events,
size_t count) {
return DisplayEventReceiver::getEvents(mDataChannel.get(), events, count);
}

ssize_t DisplayEventReceiver::getEvents(gui::BitTube* dataChannel,
Event* events, size_t count)
{
return gui::BitTube::recvObjects(dataChannel, events, count);
}

5)SurfaceFlinger 调度与分发(C++)

1
2
3
// frameworks/native/services/surfaceflinger/Scheduler/VSyncDispatch.h
virtual std::optional<ScheduleResult> schedule(
CallbackToken token, ScheduleTiming scheduleTiming) = 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// android-16.0.0_r1, EventThread.cpp
void EventThread::onVsync(nsecs_t vsyncTime, nsecs_t wakeupTime, nsecs_t readyTime) {
std::lock_guard<std::mutex> lock(mMutex);
mLastVsyncCallbackTime = TimePoint::fromNs(vsyncTime);

LOG_FATAL_IF(!mVSyncState);
mVsyncTracer = (mVsyncTracer + 1) % 2;
mPendingEvents.push_back(makeVSync(mVsyncSchedule->getPhysicalDisplayId(), wakeupTime,
++mVSyncState->count, vsyncTime, readyTime));
mCondition.notify_all();
}

// Selected scheduling branch; surrounding loop and state updates omitted.
void EventThread::threadMain(std::unique_lock<std::mutex>& lock) {
// Consumer requests and state are evaluated before this branch.
if (mState == State::VSync) {
const auto scheduleResult = mVsyncRegistration.schedule(
{.workDuration = mWorkDuration.get().count(),
.readyDuration = mReadyDuration.count(),
.lastVsync = mLastVsyncCallbackTime.ns(),
.committedVsyncOpt = mLastCommittedVsyncTime.ns()});
LOG_ALWAYS_FATAL_IF(!scheduleResult, "Error scheduling callback");
} else {
mVsyncRegistration.cancel();
}
// Event delivery, waits and loop continuation omitted.
}

关键时序点分析

沿着上述代码流程,可以梳理出完整的时序链路:

  1. HWC 硬件 Vsync 或软件预测节拍 → SurfaceFlinger Scheduler 更新显示时序
  2. Scheduler 计算唤醒窗口 → VSyncDispatch::schedule(...)
  3. EventThread 生成/派发事件 → 写入 DisplayEventReceiver::Event(通过 BitTube)
  4. App 侧 Native 收到事件 → DisplayEventDispatcher::dispatchVsync(...)
  5. Java FrameDisplayEventReceiver 回调 → 异步消息进入同一 Looper 队列,不是另起线程
  6. Choreographer#doFrame(...) 执行 → Input/Animation/Insets Animation/Traversal/Commit

各环节的职责和优化点不同,理解完整流程有助于在 Perfetto 中分析 Vsync 相关性能问题。

FrameTimeline

Android 12 及以上可采集 android.surfaceflinger.frametimeline,具体须有数据源和路径支持。下图只展示 App 侧,完整分析还要关联 SF 的 DisplayFrame;缺轨道不能当作没有卡顿。

image-20250918223035361

  • 轨道:Expected Timeline、Actual Timeline
  • PresentType/JankType:
  • PresentType 指示本帧呈现方式(例如 On-time、Late),JankType 指示卡顿类型来源
  • 常见 JankType:AppDeadlineMissed、BufferStuffing、SurfaceFlingerCpuDeadlineMissed、SurfaceFlingerGpuDeadlineMissed 等
  • 操作步骤(Perfetto UI):
  1. 在应用进程选择目标 Surface/Layer 或使用 FrameToken 过滤
  2. 对齐 Expected 与 Actual,查看偏移与颜色编码
  3. 向上钻取:Choreographer#doFrame、RenderThread、queueBuffer、acquire/present_fence
  • 误判规避:
  • 仅凭 doFrame 时长判断掉帧不可靠;继续核对 PresentType、JankType、PredictionType 和数据完整性;分类不是具体代码根因
  • 多缓冲可能掩盖单帧超时,需要看连续帧与 Buffer 可用性

App Actual Timeline 的末端对应 GPU 工作完成与提交边界,不是最终呈现;SF Actual Timeline 才延伸到呈现反馈。原文中“多缓冲掩盖超时”指画面可能仍连续更新,不表示输入延迟或积压消失。见第七篇及官方说明。

刷新率/显示模式/VRR 对 Vsync 与 Offset/预测的影响

  • 模式变化:核对实际模式、应用请求/帧率覆盖和调度预算,再观察事件间隔;并非所有设备都输出同名 display mode change slice。
  • ARR 与传统模式切换:Android 15 起的 ARR 要求相应硬件和 HAL,可在同一显示模式内改变刷新节奏。TE/Vsync 与刷新频率可能不同,不能只用 counter 间隔推算 App fps,也不能笼统说所有 VRR 更依赖 present fence 校准。
  • 多显示:事件可携带 physicalDisplayId,但签名带 ID 不等于每个 Choreographer 都能独立按任意外屏节奏请求。按目标分支确认 pacesetter/显示选择,再匹配有 display ID 的轨道和帧记录,以该次采集可见的字段为准。

Perfetto 实战 Checklist(建议按序查看)

  1. Vsync 信号与周期
  • vsync-app / vsync-sf / vsync-appSf 间隔与实际模式和请求是否一致,区分软件事件、硬件事件与启用状态
  • 密集/稀疏也可能来自按需请求、模式变化、关屏或采集丢失,不能直接判预测抖动
    image-20250918223148748
  1. Vsync 相位差配置
  • 有预算轨道/配置时核对 VsyncWorkDuration;下图选区本身不提供该配置
  • 关联同一目标帧的唤醒、ready 与呈现,允许不同帧交错
    image-20250918222707300
  1. FrameTimeline 判读
  • 先看 PresentType,再看 JankType;初步定位晚完成的一侧,再核对预测有效性和线程证据
  • 选择目标 Surface/FrameToken 定位具体帧
    image-20250918223220718
  1. 应用主线程与渲染线程
  • Choreographer#doFrame 各阶段耗时(Input/Animation/Traversal)
  • UI 的 syncAndDrawFrame/postAndWait 与 RT 的 DrawFrames/syncFrameState 分别检查;红框不自动证明同一帧身份
    image-20250918223340940
  1. BufferQueue 与 Fence
  • 生产者:queueBuffer 后,BLAST 的本地队列/事务还需把 buffer 交给 SF;图注“就可以被消费”不能理解为 GPU 已完成或 SF 可立即读。present fence 主要用于确认该帧实际送显完成时间。unsignaled latch 仍需遵守 acquire fence;GPU completion 轨道是 CPU 等待线程,不是 GPU 执行本身。
    image-20250918224205093
  • 消费者 SF 与 BufferTX:SF 按事务、同步、期限和 fence 条件处理目标 layer;不保证每次都简单取最新 buffer。若某 layer 的 BufferTX 为 0,通常表示该 layer 暂无待处理 Buffer;静态页面属正常情况,只有本应持续更新却没有新 Buffer 时才需排查 App 侧。它不代表 SF 全局“停止合成”。
    image-20250918223441117
  1. 合成策略与显示
  • ClientComposition 与图层能力是否相符,HWC validate/present 是否延后;CPU 等待 presentFence 不等于整个显示管线卡住
  • 多显示/模式切换/VRR 时是否伴随明显预测偏差
    image-20250918223517315
  1. 资源与其他干扰
  • CPU 竞争(大核占用)、GPU 忙、IO/内存抖动(GC/compaction)
  • 结合目标线程 Runnable 等待、频率和调用栈定位竞争;CPU 轨道看起来忙并不单独证明谁阻塞谁
    image-20250918223532482

参考文档

  1. Android Graphics Architecture
  2. VSYNC Implementation Guide
  3. Frame Pacing
  4. Perfetto Documentation
  5. Android Perfetto 系列 5:Android App 基于 Choreographer 的渲染流程
  6. Android Perfetto 系列 6:为什么是 120Hz?高刷新率的优势与挑战
  7. Vsync offset 相关技术分析
  8. Android 13/14高版本SurfaceFlinger出现VSYNC-app/VSYNC-appSf/VSYNC-sf剖析
  9. AOSP - Choreographer.java(android-16.0.0_r1)
  10. AOSP - android_view_DisplayEventReceiver.cpp(android-16.0.0_r1)
  11. AOSP - DisplayEventDispatcher.h(android-16.0.0_r1)
  12. AOSP - DisplayEventReceiver.cpp(android-16.0.0_r1)
  13. AOSP - VSyncDispatch.h(android-16.0.0_r1)
  14. AOSP - EventThread.cpp(android-16.0.0_r1)
  15. Android Multi-display(官方文档)
  16. AOSP - VsyncConfiguration.h(android-16.0.0_r1)
  17. AOSP - DisplayEventDispatcher.cpp(android-16.0.0_r1)
  18. Unsignaled buffer latch(官方文档)

关于我 && 博客

下面是个人的介绍和相关的链接,期望与同行的各位多多交流,三人行,则必有我师!

  1. 博主个人介绍 :里面有个人的微信和微信群链接。
  2. 本博客内容导航 :个人博客内容的一个导航。
  3. 个人整理和搜集的优秀博客文章 - Android 性能优化必知必会 :欢迎大家自荐和推荐 (微信私聊即可)
  4. Android性能优化知识星球 :历史介绍(已停止运营)

一个人可以走的更快 , 一群人可以走的更远

微信扫一扫