VSync-app和VSync-appSf各自都有对应的EventThread和DispSyncSource

VSync-sf和VSync-app以及Sync-appSf通过Scheduler的成员mVsyncSchedule指向的VSyncDispatchTimerQueue实例对象关联

2.1

VSync信号分为两种硬件VSync信号HW-VSync和软件VSync信号SW-VSync。

SW-VSync信号由SW-VSync模型产生。

HW-VSync信号负责对SW-VSync模型进行校准。

2.2

三种场景下会开启硬件VSync信号HW-VSync会对软件VSync信号SW-VSync进行校准

SurfaceFlinger合成后添加FenceTime到VSyncTracker中导致模型计算误差过大。

2.3

谷歌官方采用一元线性回归分析预测法(最小二乘法)通过采样的HW-VSync信号样本(屏幕刷新率)计算对应的SW-VSync信号周期。

最终得到一条ybxa的拟合曲线。

其中b称为回归系数a称为截距。

SW-VSync模型就是这这条曲线的回归系数和截距。

2.4

SW-VSync信号也分为两种VSync-sf信号和Vsync-app信号。

这两个信号各司其职:

VSync-sf信号用于控制SurfaceFlinger的Layer合成

VSync-sf信号和VSync-app信号是在SW-VSync信号的基础上通过叠加不同的偏移量产生这些偏移量被称为VSync相位偏移。

由于偏移量不同VSync-sf信号和VSync-app信号的回调时机也不同。

VSync-sf用于控制SurfaceFlinger合成和渲染一帧图像。

当SurfaceFlinger上帧时(BufferQueue中有新的GraphicBuffer)SurfaceFlinger会触发MessageQueue的scheduleFrame方法。

接下来我们看下VSync-sf是如何完成从申请到分发的流程。

3.1

SurfaceFlinger::scheduleCommit(...)//请求上帧mScheduler-scheduleFrame()//MessageQueue.cppmVsync.registration-schedule()//这里的registration实现是VSyncCallbackRegistration定义在Scheduler/VSyncDispatchTimerQueue.cppmDispatch.get().schedule()//这里的mDispatch指向VSyncDispatchTimerQueue对象/***

brief

1根据CallbackToken找到所有满足要求的VSyncDispatchTimerQueueEntry。

VSyncDispatchTimerQueueEntry是VSyncDispatchTimerQueue中对外部VSync信号请求的封装。

*

2遍历调用VSyncDispatchTimerQueue的schedule方法计算下一次VSync信号的发送时间。

*

ScheduleResult

VSyncDispatchTimerQueue::schedule(CallbackToken

token,ScheduleTiming

{...//根据CallbackToken找到所有满足要求的VSyncDispatchTimerQueueEntry。

VSyncDispatchTimerQueueEntry是VSyncDispatchTimerQueue中对外部VSync信号请求的封装。

auto

callback

it-second;//遍历调用VSyncDispatchTimerQueue的schedule方法计算下一次VSync信号的发送时间result

callback-schedule(scheduleTiming,

mTracker,

now);//对发射时间进行定时等待下一次VSync-sf信号的发送rearmTimerSkippingUpdateFor(now,

it);VSyncDispatchTimerQueue::setTimer()void

VSyncDispatchTimerQueue::setTimer(nsecs_t

targetTime,

targetTime;mTimeKeeper-alarmAt(std::bind(VSyncDispatchTimerQueue::timerCallback,

this),mIntendedWakeupTime);mLastTimerSchedule

mTimeKeeper-now();

1遍历CallbackMap找到达到唤醒时间的VSyncDispatchTimerQueueEntry并封装成Invocation加入Invocation列表。

*

2遍历Invocation列表通过Invocation获取VSyncDispatchTimerQueueEntry并调用VSyncDispatchTimerQueueEntry的callback方法分发VSync信号。

*///Scheduler/VSyncDispatchTimerQueue.cpp

void

VSyncDispatchTimerQueue::timerCallback()

{struct

{std::shared_ptrVSyncDispatchTimerQueueEntry

callback;nsecs_t

deadlineTimestamp;};std::vectorInvocation

lock(mMutex);auto

mTimeKeeper-now();mLastTimerCallback

now;for

{callback-executing();invocations.emplace_back(Invocation{callback,

*callback-lastExecutedVsyncTarget(),*wakeupTime,

*readyTime});}}mIntendedWakeupTime

kInvalidTime;rearmTimer(mTimeKeeper-now());}for

(auto

{invocation.callback-callback(invocation.vsyncTimestamp,

invocation.wakeupTimestamp,invocation.deadlineTimestamp);}

3.2

那么VSync-df的callback是怎么注册到VSyncDispatchTimerQueue的呢这个我们看下:

SurfaceFlinger::initScheduler(...)mScheduler-initVsync(...)//实现在Scheduler/MessageQueue.cpp中mVsync.registration

std::make_uniquescheduler::VSyncCallbackRegistration(dispatch,std::bind(MessageQueue::vsyncCallback,

this,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3),sf);//这里的dispatch指向VSyncDispatchTimerQueue//Scheduler/VSyncDispatchTimerQueue.cppVSyncCallbackRegistration::VSyncCallbackRegistration(VSyncDispatch

dispatch,VSyncDispatch::Callback

callback,std::string

mDispatch(dispatch),mToken(dispatch.registerCallback(std::move(callback),

std::move(callbackName))),mValidToken(true)

VSyncDispatchTimerQueue::CallbackToken

VSyncDispatchTimerQueue::registerCallback(Callback

callback,

CallbackToken{//最终注册到了mCallbacks中mCallbacks.emplace(mCallbackToken,std::make_sharedVSyncDispatchTimerQueueEntry(std::move(callbackName),std::move(callback),mMinVsyncDistance)).first-first};

所以最后VSync-sf的分发会调用到MessageQueue::vsyncCallback中我们看下它的实现:

MessageQueue::vsyncCallback(...)mHandler-dispatchFrame(vsyncId,

vsyncTime)mQueue.mLooper-sendMessage(this,

Message())//Handle的handleMessage接收前面发过来的消息

void

MessageQueue::Handler::handleMessage(const

Message)

{mFramePending.store(false);const

nsecs_t

mQueue.mCompositor;//这里的compositor实现类是SurfaceFlingerif

mVsyncId,

{return;}compositor.composite(frameTime,

4.1

当Choreographer通过FrameDisplayEventReceiver调用scheduleVsync方法时会触发VSync-app信号的申请。

在FrameDisplayEventReceiver的scheduleVsync方法中会调用nativeScheduleVsync方法。

FrameDisplayEventReceiver的nativeScheduleVsync方法对应的native实现为android_view_DisplayEventReceiver的nativeScheduleVsync函数。

获取native层的DisplayEventDispatcher。

调用DisplayEventDispatcher的scheduleVsync方法请求VSync信号。

在DisplayEventDispatcher的scheduleVsync方法中会调用DisplayEventReceiver的requestNextVsync方法。

在DisplayEventReceiver的requestNextVsync方法中会调用IDisplayEventConnection的requestNextVsync方法。

IDisplayEventConnection是一个Binder类对应bn端的实现类为BnDisplayEventConnection。

而EventThreadConnection继承自BnDisplayEventConnection因此实际调用的是EventThreadConnection的requestNextVsync方法。

在EventThreadConnection的requestNextVsync方法中会调用EventThread的requestNextVsync方法。

在EventThread的requestNextVsync方法中主要做了三件事

标记EventThreadConnection的vsyncRequest为后续信号分发做准备。

唤起EventThread对应的线程继续执行VSync信号的分发。

void

EventThread::requestNextVsync(const

connection)

开启硬件Vsync信号对软件Vsync信号进行校准*/connection-resyncCallback();}std::lock_guardstd::mutex

lock(mMutex);if

VSyncRequest::Single;mCondition.notify_all();//唤起EventThread中的线程}

else

VSyncRequest::SingleSuppressCallback)

}在EventThread的threadMain中会通过VSyncCallbackRegistration请求或取消VSync信号。

如果是请求VSync信号会调用VSyncCallbackRegistration的schedule方法。

在VSyncCallbackRegistration的schedule方法会调用VSyncDispatch的schedule方法。

void

EventThread::threadMain(std::unique_lockstd::mutex

lock)

{mVSyncSource-setVSyncEnabled(false);}

else

{mVSyncSource-setVSyncEnabled(true);}mState

nextState;}}

之后的流程与VSync-sf信号的申请流程相同。

在VSyncDispatchTimerQueue的schedule方法中会调用scheduleLocked方法。

在VSyncDispatchTimerQueue的scheduleLocked方法中主要做了三件事

根据CallbackToken找到所有满足要求的VSyncDispatchTimerQueueEntry。

VSyncDispatchTimerQueueEntry是VSyncDispatchTimerQueue中对外部VSync信号请求的封装。

遍历调用VSyncDispatchTimerQueue的schedule方法计算下一次VSync信号的发送时间。

4.2

当定时时间到达时TimerKeeper会回调VSyncDispatchTimerQueue的timerCallback方法。

在VSyncDispatchTimerQueue的timerCallback方法方法中主要做了两件事

遍历CallbackMap找到达到唤醒时间的VSyncDispatchTimerQueueEntry并封装成Invocation加入Invocation列表。

遍历Invocation列表通过Invocation获取VSyncDispatchTimerQueueEntry并调用VSyncDispatchTimerQueueEntry的callback方法分发VSync信号。

在VSyncDispatchTimerQueueEntry的callback方法中会调用类型为CallbackRepeater::callbackk然后在该方法中接着调用mCallback(vsyncTime,

wakeupTime,

readyTime)方法而这里的mCallback(指向DispSyncSource::onVsyncCallback最后回调EventThread的onVSyncEvent方法。

对于上述的分发流程是不是还有点懵逼我们反过来看看VSync-app分发的注册其核心是DispSyncSource和EventThread以及VSyncDispatchTimerQueue的各种回调callback流程:

//Scheduler/VSyncDispatchTimerQueue.cpp

VSyncDispatchTimerQueue::CallbackToken

VSyncDispatchTimerQueue::registerCallback(Callback

callback,

CallbackToken{mCallbacks.emplace(mCallbackToken,std::make_sharedVSyncDispatchTimerQueueEntry(std::move(callbackName),std::move(callback),mMinVsyncDistance)).first-first};

}//Scheduler/VSyncDispatchTimerQueue.cpp

VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncDispatch

dispatch,VSyncDispatch::Callback

callback,std::string

mDispatch(dispatch),mToken(dispatch.registerCallback(std::move(callback),

std::move(callbackName))),mValidToken(true)

{}//Scheduler/DispSyncSource.cpp

class

public:CallbackRepeater(VSyncDispatch

dispatch,

readyDuration,std::chrono::nanoseconds

notBefore):

mName(name),mCallback(cb),//VSyncCallbackRegistration

mRegistration

GUARDED_BY(mMutex);mRegistration(dispatch,std::bind(CallbackRepeater::callback,

this,

std::placeholders::_1,std::placeholders::_2,

std::placeholders::_3),mName),mStarted(false),mWorkDuration(workDuration),mReadyDuration(readyDuration),mLastCallTime(notBefore)

{std::lock_guard

lock(mMutex);mRegistration.cancel();}void

workDuration,

mRegistration.schedule({.workDuration

mWorkDuration.count(),.readyDuration

mReadyDuration.count(),.earliestVsync

mLastCallTime.count()});LOG_ALWAYS_FATAL_IF((!scheduleResult.has_value()),

Error

lock(mMutex);LOG_ALWAYS_FATAL_IF(!mStarted,

DispSyncInterface

false;mRegistration.cancel();}void

dump(std::string

std::chrono::steady_clock::now().time_since_epoch();StringAppendF(result,

\t%s:

mName.c_str());StringAppendF(result,

mWorkDuration%.2f

std::chrono::nanoseconds(vsyncTime);}mCallback(vsyncTime,

wakeupTime,

mRegistration.schedule({.workDuration

mWorkDuration.count(),.readyDuration

mReadyDuration.count(),.earliestVsync

vsyncTime});LOG_ALWAYS_FATAL_IF(!scheduleResult.has_value(),

Error

mName;scheduler::VSyncDispatch::Callback

mCallback;mutable

mMutex;VSyncCallbackRegistration

mRegistration

mScheduler-createConnection(app

.....)Scheduler::createConnection()auto

vsyncSource

makePrimaryDispSyncSource(connectionName,

workDuration,

std::make_uniquescheduler::DispSyncSource(mVsyncSchedule-getDispatch(),mVsyncSchedule-getTracker(),

traceVsync,

name);//std::unique_ptrCallbackRepeater

mCallbackRepeater;mCallbackRepeater

std::make_uniqueCallbackRepeater(vSyncDispatch,std::bind(DispSyncSource::onVsyncCallback,

this,std::placeholders::_1,std::placeholders::_2,std::placeholders::_3),name,

workDuration,

readyDuration,std::chrono::steady_clock::now().time_since_epoch());

mVSyncSource-setCallback(this);//为DispVsyncSource设置回调void

DispSyncSource::setCallback(VSyncSource::Callback*

callback)

//最终整理出来的Vsync-app分发流程为,各种弯弯绕绕:VSyncDispatchTimerQueue::timerCallback()//Scheduler/VSyncDispatchTimerQueue.cppinvocation.callback-callback(...)//这里的callback指向VSyncDispatchTimerQueueEntry::callbackScheduler/VSyncDispatchTimerQueue.cppmCallback(vsyncTimestamp,

wakeupTimestamp,

mCallback指向CallbackRepeater::callback实现在Scheduler/DispSyncSource.cpp

mCallback(vsyncTime,

readyTime)//这里的callback指向DispSyncSource::onVsyncCallback。

是现在Scheduler/DispSyncSource.cppcallback

mCallback;callback-onVSyncEvent(targetWakeupTime,

{vsyncTime,

readyTime})//这里的callback指向EventThread::onVSyncEvent在EventThread的onVSyncEvent方法中主要做了三件事

将Event加入到vectorDisplayEventReceiver::Event

void

EventThread::onVSyncEvent(nsecs_t

timestamp,

lock(mMutex);LOG_FATAL_IF(!mVSyncState);//包装为DisplayEventReceiver::Event对象存入mPendingEvents尾部mPendingEvents.push_back(makeVSync(mVSyncState-displayId,

timestamp,

mVSyncState-count,vsyncData.expectedPresentationTime,vsyncData.deadlineTimestamp));//唤醒线程mCondition.notify_all();

void

EventThread::threadMain(std::unique_lockstd::mutex

lock)

{std::optionalDisplayEventReceiver::Event

event;//

mPendingEvents.front();mPendingEvents.pop_front();

...}//

mDisplayEventConnections.begin();while

(it

mDisplayEventConnections.end())

{if

VSyncRequest::None;//用来在任务的循环执行中保存当前Vsync信号的消费者if

(event

{consumers.push_back(connection);//这里的consumers就是待分发的目标}it;}

else

mDisplayEventConnections.erase(it);}}

/***

2收集监听Vsync信号的EventThreadConnection并加入到consumers中*

(!consumers.empty())

consumers);consumer-postEvent(copy)DisplayEventReceiver::sendEvents(...)consumers.clear();}

最终VSync-app分发的事件会被Choreographer模块接收开始安排应用相关的渲染UI逻辑

Andoid

App/Sf的Vsync部分源码流程结合perfetto/systrace分析

Android-View绘制原理(02)-VSync原理之SurfaceFlinger篇

一文搞定Android