EN

Android Perfetto 系列 8:深入理解 Vsync 机制与性能分析

字数统计: 6.3k阅读时长: 26 min
2025/08/05
loading

在 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性能优化知识星球 :历史介绍(已停止运营)

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

微信扫一扫

CATALOG
  1. 1. 本文目录
  • 系列文章目录
    1. 1. 什么是 Vsync
      1. 1.1. Vsync 解决什么问题?
    2. 2. Android 中 Vsync 的基本工作原理
      1. 2.1. Vsync 信号的分层架构
    3. 3. 在 Perfetto 中观察 Vsync
    4. 4. Android App 每一帧是如何基于 Vsync 工作的
      1. 4.1. 流程总览(按顺序)
      2. 4.2. App 什么时候会申请 Vsync 信号
      3. 4.3. App 申请 Vsync 的完整流程
      4. 4.4. 主线程如何监听 Vsync 信号
      5. 4.5. 几个遗留问题
      6. 4.6. Vsync Offset / WorkDuration 的技术实现
      7. 4.7. 相位差的简化时序示意
    5. 5. Vsync 信号的完整代码流程
      1. 5.1. Android 16 的关键代码(精简摘录)
      2. 5.2. 关键时序点分析
      3. 5.3. FrameTimeline
      4. 5.4. 刷新率/显示模式/VRR 对 Vsync 与 Offset/预测的影响
      5. 5.5. Perfetto 实战 Checklist(建议按序查看)
    6. 6. 参考文档
  • 关于我 && 博客