blob: 7acbd11bc5db1d3606b762c0304011724278edd9 [file] [log] [blame]
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_GRAPHICS
Tim Murray4a4e4a22016-04-19 16:29:23 +000018//#define LOG_NDEBUG 0
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070019
20// This is needed for stdint.h to define INT64_MAX in C++
21#define __STDC_LIMIT_MACROS
22
23#include <math.h>
24
Mark Salyzyna5e161b2016-09-29 08:08:05 -070025#include <algorithm>
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070026
Mark Salyzyn7823e122016-09-29 08:08:05 -070027#include <log/log.h>
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070028#include <utils/String8.h>
29#include <utils/Thread.h>
30#include <utils/Trace.h>
31#include <utils/Vector.h>
32
Brian Andersonfbc80ae2017-05-26 16:23:54 -070033#include <ui/FenceTime.h>
Mark Salyzyna5e161b2016-09-29 08:08:05 -070034
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070035#include "DispSync.h"
36#include "EventLog/EventLog.h"
Lloyd Pique78ce4182018-01-31 16:39:51 -080037#include "SurfaceFlinger.h"
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070038
Tim Murray4a4e4a22016-04-19 16:29:23 +000039using std::max;
40using std::min;
41
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070042namespace android {
43
44// Setting this to true enables verbose tracing that can be used to debug
45// vsync event model or phase issues.
Andy McFadden5167ec62014-05-22 13:08:43 -070046static const bool kTraceDetailedInfo = false;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070047
Tim Murray4a4e4a22016-04-19 16:29:23 +000048// Setting this to true adds a zero-phase tracer for correlating with hardware
49// vsync events
50static const bool kEnableZeroPhaseTracer = false;
51
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070052// This is the threshold used to determine when hardware vsync events are
53// needed to re-synchronize the software vsync model with the hardware. The
54// error metric used is the mean of the squared difference between each
55// present time and the nearest software-predicted vsync.
Lloyd Pique78ce4182018-01-31 16:39:51 -080056static const nsecs_t kErrorThreshold = 160000000000; // 400 usec squared
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070057
Tim Murray4a4e4a22016-04-19 16:29:23 +000058#undef LOG_TAG
59#define LOG_TAG "DispSyncThread"
Lloyd Pique78ce4182018-01-31 16:39:51 -080060class DispSyncThread : public Thread {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070061public:
Lloyd Pique78ce4182018-01-31 16:39:51 -080062 explicit DispSyncThread(const char* name)
63 : mName(name),
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070064 mStop(false),
65 mPeriod(0),
66 mPhase(0),
Haixia Shi676b1f62015-10-28 16:19:01 -070067 mReferenceTime(0),
Tim Murray4a4e4a22016-04-19 16:29:23 +000068 mWakeupLatency(0),
69 mFrameNumber(0) {}
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070070
71 virtual ~DispSyncThread() {}
72
Haixia Shi676b1f62015-10-28 16:19:01 -070073 void updateModel(nsecs_t period, nsecs_t phase, nsecs_t referenceTime) {
Tim Murray4a4e4a22016-04-19 16:29:23 +000074 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070075 Mutex::Autolock lock(mMutex);
76 mPeriod = period;
77 mPhase = phase;
Haixia Shi676b1f62015-10-28 16:19:01 -070078 mReferenceTime = referenceTime;
Tim Murray4a4e4a22016-04-19 16:29:23 +000079 ALOGV("[%s] updateModel: mPeriod = %" PRId64 ", mPhase = %" PRId64
Lloyd Pique78ce4182018-01-31 16:39:51 -080080 " mReferenceTime = %" PRId64,
81 mName, ns2us(mPeriod), ns2us(mPhase), ns2us(mReferenceTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070082 mCond.signal();
83 }
84
85 void stop() {
Tim Murray4a4e4a22016-04-19 16:29:23 +000086 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070087 Mutex::Autolock lock(mMutex);
88 mStop = true;
89 mCond.signal();
90 }
91
92 virtual bool threadLoop() {
93 status_t err;
94 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -070095
96 while (true) {
97 Vector<CallbackInvocation> callbackInvocations;
98
99 nsecs_t targetTime = 0;
100
101 { // Scope for lock
102 Mutex::Autolock lock(mMutex);
103
Tim Murray4a4e4a22016-04-19 16:29:23 +0000104 if (kTraceDetailedInfo) {
105 ATRACE_INT64("DispSync:Frame", mFrameNumber);
106 }
107 ALOGV("[%s] Frame %" PRId64, mName, mFrameNumber);
108 ++mFrameNumber;
109
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700110 if (mStop) {
111 return false;
112 }
113
114 if (mPeriod == 0) {
115 err = mCond.wait(mMutex);
116 if (err != NO_ERROR) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800117 ALOGE("error waiting for new events: %s (%d)", strerror(-err), err);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700118 return false;
119 }
120 continue;
121 }
122
Dan Stoza8f8374d2016-04-19 10:03:46 -0700123 targetTime = computeNextEventTimeLocked(now);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700124
125 bool isWakeup = false;
126
127 if (now < targetTime) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000128 if (kTraceDetailedInfo) ATRACE_NAME("DispSync waiting");
Dan Stoza8f8374d2016-04-19 10:03:46 -0700129
130 if (targetTime == INT64_MAX) {
131 ALOGV("[%s] Waiting forever", mName);
132 err = mCond.wait(mMutex);
133 } else {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800134 ALOGV("[%s] Waiting until %" PRId64, mName, ns2us(targetTime));
Dan Stoza8f8374d2016-04-19 10:03:46 -0700135 err = mCond.waitRelative(mMutex, targetTime - now);
136 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700137
138 if (err == TIMED_OUT) {
139 isWakeup = true;
140 } else if (err != NO_ERROR) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800141 ALOGE("error waiting for next event: %s (%d)", strerror(-err), err);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700142 return false;
143 }
144 }
145
146 now = systemTime(SYSTEM_TIME_MONOTONIC);
147
Tim Murray4a4e4a22016-04-19 16:29:23 +0000148 // Don't correct by more than 1.5 ms
149 static const nsecs_t kMaxWakeupLatency = us2ns(1500);
150
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700151 if (isWakeup) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800152 mWakeupLatency = ((mWakeupLatency * 63) + (now - targetTime)) / 64;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000153 mWakeupLatency = min(mWakeupLatency, kMaxWakeupLatency);
Andy McFadden5167ec62014-05-22 13:08:43 -0700154 if (kTraceDetailedInfo) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000155 ATRACE_INT64("DispSync:WakeupLat", now - targetTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700156 ATRACE_INT64("DispSync:AvgWakeupLat", mWakeupLatency);
157 }
158 }
159
160 callbackInvocations = gatherCallbackInvocationsLocked(now);
161 }
162
163 if (callbackInvocations.size() > 0) {
Andy McFadden645b1f72014-06-10 14:43:32 -0700164 fireCallbackInvocations(callbackInvocations);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700165 }
166 }
167
168 return false;
169 }
170
Lloyd Piquee83f9312018-02-01 12:53:17 -0800171 status_t addEventListener(const char* name, nsecs_t phase, DispSync::Callback* callback) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000172 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700173 Mutex::Autolock lock(mMutex);
174
175 for (size_t i = 0; i < mEventListeners.size(); i++) {
176 if (mEventListeners[i].mCallback == callback) {
177 return BAD_VALUE;
178 }
179 }
180
181 EventListener listener;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000182 listener.mName = name;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700183 listener.mPhase = phase;
184 listener.mCallback = callback;
Jamie Gennis629b9872013-10-29 13:36:12 -0700185
186 // We want to allow the firstmost future event to fire without
Tim Murray4a4e4a22016-04-19 16:29:23 +0000187 // allowing any past events to fire
Lloyd Pique78ce4182018-01-31 16:39:51 -0800188 listener.mLastEventTime = systemTime() - mPeriod / 2 + mPhase - mWakeupLatency;
Jamie Gennis629b9872013-10-29 13:36:12 -0700189
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700190 mEventListeners.push(listener);
191
192 mCond.signal();
193
194 return NO_ERROR;
195 }
196
Lloyd Piquee83f9312018-02-01 12:53:17 -0800197 status_t removeEventListener(DispSync::Callback* callback) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000198 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700199 Mutex::Autolock lock(mMutex);
200
201 for (size_t i = 0; i < mEventListeners.size(); i++) {
202 if (mEventListeners[i].mCallback == callback) {
203 mEventListeners.removeAt(i);
204 mCond.signal();
205 return NO_ERROR;
206 }
207 }
208
209 return BAD_VALUE;
210 }
211
Dan Stoza84d619e2018-03-28 17:07:36 -0700212 status_t changePhaseOffset(DispSync::Callback* callback, nsecs_t phase) {
213 if (kTraceDetailedInfo) ATRACE_CALL();
214 Mutex::Autolock lock(mMutex);
215
216 for (size_t i = 0; i < mEventListeners.size(); i++) {
217 if (mEventListeners[i].mCallback == callback) {
218 EventListener& listener = mEventListeners.editItemAt(i);
219 const nsecs_t oldPhase = listener.mPhase;
220 listener.mPhase = phase;
221
222 // Pretend that the last time this event was handled at the same frame but with the
223 // new offset to allow for a seamless offset change without double-firing or
224 // skipping.
225 listener.mLastEventTime -= (oldPhase - phase);
226 mCond.signal();
227 return NO_ERROR;
228 }
229 }
230
231 return BAD_VALUE;
232 }
233
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800234 // This method is only here to handle the !SurfaceFlinger::hasSyncFramework
235 // case.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700236 bool hasAnyEventListeners() {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000237 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700238 Mutex::Autolock lock(mMutex);
239 return !mEventListeners.empty();
240 }
241
242private:
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700243 struct EventListener {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000244 const char* mName;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700245 nsecs_t mPhase;
246 nsecs_t mLastEventTime;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800247 DispSync::Callback* mCallback;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700248 };
249
250 struct CallbackInvocation {
Lloyd Piquee83f9312018-02-01 12:53:17 -0800251 DispSync::Callback* mCallback;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700252 nsecs_t mEventTime;
253 };
254
255 nsecs_t computeNextEventTimeLocked(nsecs_t now) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000256 if (kTraceDetailedInfo) ATRACE_CALL();
257 ALOGV("[%s] computeNextEventTimeLocked", mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700258 nsecs_t nextEventTime = INT64_MAX;
259 for (size_t i = 0; i < mEventListeners.size(); i++) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800260 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], now);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700261
262 if (t < nextEventTime) {
263 nextEventTime = t;
264 }
265 }
266
Tim Murray4a4e4a22016-04-19 16:29:23 +0000267 ALOGV("[%s] nextEventTime = %" PRId64, mName, ns2us(nextEventTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700268 return nextEventTime;
269 }
270
271 Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000272 if (kTraceDetailedInfo) ATRACE_CALL();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800273 ALOGV("[%s] gatherCallbackInvocationsLocked @ %" PRId64, mName, ns2us(now));
Tim Murray4a4e4a22016-04-19 16:29:23 +0000274
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700275 Vector<CallbackInvocation> callbackInvocations;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000276 nsecs_t onePeriodAgo = now - mPeriod;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700277
278 for (size_t i = 0; i < mEventListeners.size(); i++) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800279 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], onePeriodAgo);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700280
Jamie Gennis0d5c60e2013-10-09 17:49:37 -0700281 if (t < now) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700282 CallbackInvocation ci;
283 ci.mCallback = mEventListeners[i].mCallback;
284 ci.mEventTime = t;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800285 ALOGV("[%s] [%s] Preparing to fire", mName, mEventListeners[i].mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700286 callbackInvocations.push(ci);
287 mEventListeners.editItemAt(i).mLastEventTime = t;
288 }
289 }
290
291 return callbackInvocations;
292 }
293
Lloyd Pique78ce4182018-01-31 16:39:51 -0800294 nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener, nsecs_t baseTime) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000295 if (kTraceDetailedInfo) ATRACE_CALL();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800296 ALOGV("[%s] [%s] computeListenerNextEventTimeLocked(%" PRId64 ")", mName, listener.mName,
297 ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700298
Tim Murray4a4e4a22016-04-19 16:29:23 +0000299 nsecs_t lastEventTime = listener.mLastEventTime + mWakeupLatency;
300 ALOGV("[%s] lastEventTime: %" PRId64, mName, ns2us(lastEventTime));
301 if (baseTime < lastEventTime) {
302 baseTime = lastEventTime;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800303 ALOGV("[%s] Clamping baseTime to lastEventTime -> %" PRId64, mName, ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700304 }
305
Tim Murray4a4e4a22016-04-19 16:29:23 +0000306 baseTime -= mReferenceTime;
307 ALOGV("[%s] Relative baseTime = %" PRId64, mName, ns2us(baseTime));
308 nsecs_t phase = mPhase + listener.mPhase;
309 ALOGV("[%s] Phase = %" PRId64, mName, ns2us(phase));
310 baseTime -= phase;
311 ALOGV("[%s] baseTime - phase = %" PRId64, mName, ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700312
Tim Murray4a4e4a22016-04-19 16:29:23 +0000313 // If our previous time is before the reference (because the reference
314 // has since been updated), the division by mPeriod will truncate
315 // towards zero instead of computing the floor. Since in all cases
316 // before the reference we want the next time to be effectively now, we
317 // set baseTime to -mPeriod so that numPeriods will be -1.
318 // When we add 1 and the phase, we will be at the correct event time for
319 // this period.
320 if (baseTime < 0) {
321 ALOGV("[%s] Correcting negative baseTime", mName);
322 baseTime = -mPeriod;
323 }
324
325 nsecs_t numPeriods = baseTime / mPeriod;
326 ALOGV("[%s] numPeriods = %" PRId64, mName, numPeriods);
327 nsecs_t t = (numPeriods + 1) * mPeriod + phase;
328 ALOGV("[%s] t = %" PRId64, mName, ns2us(t));
329 t += mReferenceTime;
330 ALOGV("[%s] Absolute t = %" PRId64, mName, ns2us(t));
331
332 // Check that it's been slightly more than half a period since the last
333 // event so that we don't accidentally fall into double-rate vsyncs
334 if (t - listener.mLastEventTime < (3 * mPeriod / 5)) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700335 t += mPeriod;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000336 ALOGV("[%s] Modifying t -> %" PRId64, mName, ns2us(t));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700337 }
338
Tim Murray4a4e4a22016-04-19 16:29:23 +0000339 t -= mWakeupLatency;
340 ALOGV("[%s] Corrected for wakeup latency -> %" PRId64, mName, ns2us(t));
341
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700342 return t;
343 }
344
345 void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000346 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700347 for (size_t i = 0; i < callbacks.size(); i++) {
348 callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime);
349 }
350 }
351
Tim Murray4a4e4a22016-04-19 16:29:23 +0000352 const char* const mName;
353
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700354 bool mStop;
355
356 nsecs_t mPeriod;
357 nsecs_t mPhase;
Haixia Shi676b1f62015-10-28 16:19:01 -0700358 nsecs_t mReferenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700359 nsecs_t mWakeupLatency;
360
Tim Murray4a4e4a22016-04-19 16:29:23 +0000361 int64_t mFrameNumber;
362
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700363 Vector<EventListener> mEventListeners;
364
365 Mutex mMutex;
366 Condition mCond;
367};
368
Tim Murray4a4e4a22016-04-19 16:29:23 +0000369#undef LOG_TAG
370#define LOG_TAG "DispSync"
371
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700372class ZeroPhaseTracer : public DispSync::Callback {
373public:
374 ZeroPhaseTracer() : mParity(false) {}
375
Mark Salyzyn92dc3fc2014-03-12 13:12:44 -0700376 virtual void onDispSyncEvent(nsecs_t /*when*/) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700377 mParity = !mParity;
378 ATRACE_INT("ZERO_PHASE_VSYNC", mParity ? 1 : 0);
379 }
380
381private:
382 bool mParity;
383};
384
Lloyd Pique78ce4182018-01-31 16:39:51 -0800385DispSync::DispSync(const char* name)
386 : mName(name), mRefreshSkipCount(0), mThread(new DispSyncThread(name)) {}
Andy McFadden645b1f72014-06-10 14:43:32 -0700387
Saurabh Shahf4174532017-07-13 10:45:07 -0700388DispSync::~DispSync() {}
389
390void DispSync::init(bool hasSyncFramework, int64_t dispSyncPresentTimeOffset) {
391 mIgnorePresentFences = !hasSyncFramework;
392 mPresentTimeOffset = dispSyncPresentTimeOffset;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700393 mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
Saurabh Shahf4174532017-07-13 10:45:07 -0700394
Tim Murrayacff43d2016-07-29 13:57:24 -0700395 // set DispSync to SCHED_FIFO to minimize jitter
396 struct sched_param param = {0};
Tim Murray35520632016-09-07 12:18:17 -0700397 param.sched_priority = 2;
Tim Murrayacff43d2016-07-29 13:57:24 -0700398 if (sched_setscheduler(mThread->getTid(), SCHED_FIFO, &param) != 0) {
399 ALOGE("Couldn't set SCHED_FIFO for DispSyncThread");
400 }
401
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700402 reset();
403 beginResync();
404
Andy McFadden5167ec62014-05-22 13:08:43 -0700405 if (kTraceDetailedInfo) {
406 // If we're not getting present fences then the ZeroPhaseTracer
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700407 // would prevent HW vsync event from ever being turned off.
Andy McFadden5167ec62014-05-22 13:08:43 -0700408 // Even if we're just ignoring the fences, the zero-phase tracing is
409 // not needed because any time there is an event registered we will
410 // turn on the HW vsync events.
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800411 if (!mIgnorePresentFences && kEnableZeroPhaseTracer) {
Lloyd Piquee83f9312018-02-01 12:53:17 -0800412 mZeroPhaseTracer = std::make_unique<ZeroPhaseTracer>();
413 addEventListener("ZeroPhaseTracer", 0, mZeroPhaseTracer.get());
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700414 }
415 }
416}
417
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700418void DispSync::reset() {
419 Mutex::Autolock lock(mMutex);
420
Haixia Shi676b1f62015-10-28 16:19:01 -0700421 mPhase = 0;
422 mReferenceTime = 0;
423 mModelUpdated = false;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700424 mNumResyncSamples = 0;
425 mFirstResyncSample = 0;
426 mNumResyncSamplesSincePresent = 0;
427 resetErrorLocked();
428}
429
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700430bool DispSync::addPresentFence(const std::shared_ptr<FenceTime>& fenceTime) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700431 Mutex::Autolock lock(mMutex);
432
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700433 mPresentFences[mPresentSampleOffset] = fenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700434 mPresentSampleOffset = (mPresentSampleOffset + 1) % NUM_PRESENT_SAMPLES;
435 mNumResyncSamplesSincePresent = 0;
436
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700437 updateErrorLocked();
438
Haixia Shi676b1f62015-10-28 16:19:01 -0700439 return !mModelUpdated || mError > kErrorThreshold;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700440}
441
442void DispSync::beginResync() {
443 Mutex::Autolock lock(mMutex);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000444 ALOGV("[%s] beginResync", mName);
Haixia Shi676b1f62015-10-28 16:19:01 -0700445 mModelUpdated = false;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700446 mNumResyncSamples = 0;
447}
448
449bool DispSync::addResyncSample(nsecs_t timestamp) {
450 Mutex::Autolock lock(mMutex);
451
Tim Murray4a4e4a22016-04-19 16:29:23 +0000452 ALOGV("[%s] addResyncSample(%" PRId64 ")", mName, ns2us(timestamp));
453
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700454 size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES;
455 mResyncSamples[idx] = timestamp;
Haixia Shi664339a2015-10-28 13:22:22 -0700456 if (mNumResyncSamples == 0) {
Haixia Shi676b1f62015-10-28 16:19:01 -0700457 mPhase = 0;
458 mReferenceTime = timestamp;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000459 ALOGV("[%s] First resync sample: mPeriod = %" PRId64 ", mPhase = 0, "
Lloyd Pique78ce4182018-01-31 16:39:51 -0800460 "mReferenceTime = %" PRId64,
461 mName, ns2us(mPeriod), ns2us(mReferenceTime));
Tim Murray4a4e4a22016-04-19 16:29:23 +0000462 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
Haixia Shi664339a2015-10-28 13:22:22 -0700463 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700464
465 if (mNumResyncSamples < MAX_RESYNC_SAMPLES) {
466 mNumResyncSamples++;
467 } else {
468 mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES;
469 }
470
471 updateModelLocked();
472
473 if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) {
474 resetErrorLocked();
475 }
476
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800477 if (mIgnorePresentFences) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700478 // If we don't have the sync framework we will never have
479 // addPresentFence called. This means we have no way to know whether
480 // or not we're synchronized with the HW vsyncs, so we just request
481 // that the HW vsync events be turned on whenever we need to generate
482 // SW vsync events.
483 return mThread->hasAnyEventListeners();
484 }
485
Tim Murray4a4e4a22016-04-19 16:29:23 +0000486 // Check against kErrorThreshold / 2 to add some hysteresis before having to
487 // resync again
488 bool modelLocked = mModelUpdated && mError < (kErrorThreshold / 2);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800489 ALOGV("[%s] addResyncSample returning %s", mName, modelLocked ? "locked" : "unlocked");
Tim Murray4a4e4a22016-04-19 16:29:23 +0000490 return !modelLocked;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700491}
492
Lloyd Pique78ce4182018-01-31 16:39:51 -0800493void DispSync::endResync() {}
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700494
Lloyd Piquee83f9312018-02-01 12:53:17 -0800495status_t DispSync::addEventListener(const char* name, nsecs_t phase, Callback* callback) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700496 Mutex::Autolock lock(mMutex);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000497 return mThread->addEventListener(name, phase, callback);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700498}
499
Andy McFadden645b1f72014-06-10 14:43:32 -0700500void DispSync::setRefreshSkipCount(int count) {
501 Mutex::Autolock lock(mMutex);
502 ALOGD("setRefreshSkipCount(%d)", count);
503 mRefreshSkipCount = count;
504 updateModelLocked();
Ruchi Kandoif52b3c82014-04-24 16:42:35 -0700505}
506
Lloyd Piquee83f9312018-02-01 12:53:17 -0800507status_t DispSync::removeEventListener(Callback* callback) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700508 Mutex::Autolock lock(mMutex);
509 return mThread->removeEventListener(callback);
510}
511
Dan Stoza84d619e2018-03-28 17:07:36 -0700512status_t DispSync::changePhaseOffset(Callback* callback, nsecs_t phase) {
513 Mutex::Autolock lock(mMutex);
514 return mThread->changePhaseOffset(callback, phase);
515}
516
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700517void DispSync::setPeriod(nsecs_t period) {
518 Mutex::Autolock lock(mMutex);
519 mPeriod = period;
520 mPhase = 0;
Haixia Shi676b1f62015-10-28 16:19:01 -0700521 mReferenceTime = 0;
522 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700523}
524
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700525nsecs_t DispSync::getPeriod() {
526 // lock mutex as mPeriod changes multiple times in updateModelLocked
527 Mutex::Autolock lock(mMutex);
528 return mPeriod;
529}
530
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700531void DispSync::updateModelLocked() {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000532 ALOGV("[%s] updateModelLocked %zu", mName, mNumResyncSamples);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700533 if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000534 ALOGV("[%s] Computing...", mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700535 nsecs_t durationSum = 0;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000536 nsecs_t minDuration = INT64_MAX;
537 nsecs_t maxDuration = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700538 for (size_t i = 1; i < mNumResyncSamples; i++) {
539 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
540 size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000541 nsecs_t duration = mResyncSamples[idx] - mResyncSamples[prev];
542 durationSum += duration;
543 minDuration = min(minDuration, duration);
544 maxDuration = max(maxDuration, duration);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700545 }
546
Tim Murray4a4e4a22016-04-19 16:29:23 +0000547 // Exclude the min and max from the average
548 durationSum -= minDuration + maxDuration;
549 mPeriod = durationSum / (mNumResyncSamples - 3);
550
551 ALOGV("[%s] mPeriod = %" PRId64, mName, ns2us(mPeriod));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700552
553 double sampleAvgX = 0;
554 double sampleAvgY = 0;
555 double scale = 2.0 * M_PI / double(mPeriod);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000556 // Intentionally skip the first sample
557 for (size_t i = 1; i < mNumResyncSamples; i++) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700558 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
Haixia Shi676b1f62015-10-28 16:19:01 -0700559 nsecs_t sample = mResyncSamples[idx] - mReferenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700560 double samplePhase = double(sample % mPeriod) * scale;
561 sampleAvgX += cos(samplePhase);
562 sampleAvgY += sin(samplePhase);
563 }
564
Tim Murray4a4e4a22016-04-19 16:29:23 +0000565 sampleAvgX /= double(mNumResyncSamples - 1);
566 sampleAvgY /= double(mNumResyncSamples - 1);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700567
568 mPhase = nsecs_t(atan2(sampleAvgY, sampleAvgX) / scale);
569
Tim Murray4a4e4a22016-04-19 16:29:23 +0000570 ALOGV("[%s] mPhase = %" PRId64, mName, ns2us(mPhase));
571
572 if (mPhase < -(mPeriod / 2)) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700573 mPhase += mPeriod;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000574 ALOGV("[%s] Adjusting mPhase -> %" PRId64, mName, ns2us(mPhase));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700575 }
576
Andy McFadden5167ec62014-05-22 13:08:43 -0700577 if (kTraceDetailedInfo) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700578 ATRACE_INT64("DispSync:Period", mPeriod);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000579 ATRACE_INT64("DispSync:Phase", mPhase + mPeriod / 2);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700580 }
581
Andy McFadden645b1f72014-06-10 14:43:32 -0700582 // Artificially inflate the period if requested.
583 mPeriod += mPeriod * mRefreshSkipCount;
584
Haixia Shi676b1f62015-10-28 16:19:01 -0700585 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
586 mModelUpdated = true;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700587 }
588}
589
590void DispSync::updateErrorLocked() {
Haixia Shi676b1f62015-10-28 16:19:01 -0700591 if (!mModelUpdated) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700592 return;
593 }
594
Andy McFadden645b1f72014-06-10 14:43:32 -0700595 // Need to compare present fences against the un-adjusted refresh period,
596 // since they might arrive between two events.
597 nsecs_t period = mPeriod / (1 + mRefreshSkipCount);
598
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700599 int numErrSamples = 0;
600 nsecs_t sqErrSum = 0;
601
602 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700603 // Only check for the cached value of signal time to avoid unecessary
604 // syscalls. It is the responsibility of the DispSync owner to
605 // call getSignalTime() periodically so the cache is updated when the
606 // fence signals.
607 nsecs_t time = mPresentFences[i]->getCachedSignalTime();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800608 if (time == Fence::SIGNAL_TIME_PENDING || time == Fence::SIGNAL_TIME_INVALID) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700609 continue;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700610 }
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700611
612 nsecs_t sample = time - mReferenceTime;
613 if (sample <= mPhase) {
614 continue;
615 }
616
617 nsecs_t sampleErr = (sample - mPhase) % period;
618 if (sampleErr > period / 2) {
619 sampleErr -= period;
620 }
621 sqErrSum += sampleErr * sampleErr;
622 numErrSamples++;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700623 }
624
625 if (numErrSamples > 0) {
626 mError = sqErrSum / numErrSamples;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700627 mZeroErrSamplesCount = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700628 } else {
629 mError = 0;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700630 // Use mod ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT to avoid log spam.
631 mZeroErrSamplesCount++;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800632 ALOGE_IF((mZeroErrSamplesCount % ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT) == 0,
633 "No present times for model error.");
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700634 }
635
Andy McFadden5167ec62014-05-22 13:08:43 -0700636 if (kTraceDetailedInfo) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700637 ATRACE_INT64("DispSync:Error", mError);
638 }
639}
640
641void DispSync::resetErrorLocked() {
642 mPresentSampleOffset = 0;
643 mError = 0;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700644 mZeroErrSamplesCount = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700645 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700646 mPresentFences[i] = FenceTime::NO_FENCE;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700647 }
648}
649
Andy McFadden41d67d72014-04-25 16:58:34 -0700650nsecs_t DispSync::computeNextRefresh(int periodOffset) const {
Andy McFadden150ecd82014-05-08 14:56:50 -0700651 Mutex::Autolock lock(mMutex);
Andy McFadden41d67d72014-04-25 16:58:34 -0700652 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
Haixia Shi676b1f62015-10-28 16:19:01 -0700653 nsecs_t phase = mReferenceTime + mPhase;
654 return (((now - phase) / mPeriod) + periodOffset + 1) * mPeriod + phase;
Andy McFadden41d67d72014-04-25 16:58:34 -0700655}
656
Andy McFaddenc751e922014-05-08 14:53:26 -0700657void DispSync::dump(String8& result) const {
658 Mutex::Autolock lock(mMutex);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800659 result.appendFormat("present fences are %s\n", mIgnorePresentFences ? "ignored" : "used");
660 result.appendFormat("mPeriod: %" PRId64 " ns (%.3f fps; skipCount=%d)\n", mPeriod,
661 1000000000.0 / mPeriod, mRefreshSkipCount);
Andy McFadden5167ec62014-05-22 13:08:43 -0700662 result.appendFormat("mPhase: %" PRId64 " ns\n", mPhase);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800663 result.appendFormat("mError: %" PRId64 " ns (sqrt=%.1f)\n", mError, sqrt(mError));
Andy McFadden5167ec62014-05-22 13:08:43 -0700664 result.appendFormat("mNumResyncSamplesSincePresent: %d (limit %d)\n",
Lloyd Pique78ce4182018-01-31 16:39:51 -0800665 mNumResyncSamplesSincePresent, MAX_RESYNC_SAMPLES_WITHOUT_PRESENT);
666 result.appendFormat("mNumResyncSamples: %zd (max %d)\n", mNumResyncSamples, MAX_RESYNC_SAMPLES);
Andy McFaddenc751e922014-05-08 14:53:26 -0700667
668 result.appendFormat("mResyncSamples:\n");
669 nsecs_t previous = -1;
670 for (size_t i = 0; i < mNumResyncSamples; i++) {
671 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
672 nsecs_t sampleTime = mResyncSamples[idx];
673 if (i == 0) {
Andy McFadden5167ec62014-05-22 13:08:43 -0700674 result.appendFormat(" %" PRId64 "\n", sampleTime);
Andy McFaddenc751e922014-05-08 14:53:26 -0700675 } else {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800676 result.appendFormat(" %" PRId64 " (+%" PRId64 ")\n", sampleTime,
677 sampleTime - previous);
Andy McFaddenc751e922014-05-08 14:53:26 -0700678 }
679 previous = sampleTime;
680 }
681
Lloyd Pique78ce4182018-01-31 16:39:51 -0800682 result.appendFormat("mPresentFences [%d]:\n", NUM_PRESENT_SAMPLES);
Andy McFadden5167ec62014-05-22 13:08:43 -0700683 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700684 previous = Fence::SIGNAL_TIME_INVALID;
Andy McFaddenc751e922014-05-08 14:53:26 -0700685 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
686 size_t idx = (i + mPresentSampleOffset) % NUM_PRESENT_SAMPLES;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700687 nsecs_t presentTime = mPresentFences[idx]->getSignalTime();
688 if (presentTime == Fence::SIGNAL_TIME_PENDING) {
Andy McFaddenc751e922014-05-08 14:53:26 -0700689 result.appendFormat(" [unsignaled fence]\n");
Lloyd Pique78ce4182018-01-31 16:39:51 -0800690 } else if (presentTime == Fence::SIGNAL_TIME_INVALID) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700691 result.appendFormat(" [invalid fence]\n");
692 } else if (previous == Fence::SIGNAL_TIME_PENDING ||
Lloyd Pique78ce4182018-01-31 16:39:51 -0800693 previous == Fence::SIGNAL_TIME_INVALID) {
Andy McFadden5167ec62014-05-22 13:08:43 -0700694 result.appendFormat(" %" PRId64 " (%.3f ms ago)\n", presentTime,
Lloyd Pique78ce4182018-01-31 16:39:51 -0800695 (now - presentTime) / 1000000.0);
Andy McFaddenc751e922014-05-08 14:53:26 -0700696 } else {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800697 result.appendFormat(" %" PRId64 " (+%" PRId64 " / %.3f) (%.3f ms ago)\n", presentTime,
698 presentTime - previous, (presentTime - previous) / (double)mPeriod,
699 (now - presentTime) / 1000000.0);
Andy McFaddenc751e922014-05-08 14:53:26 -0700700 }
701 previous = presentTime;
702 }
Andy McFadden5167ec62014-05-22 13:08:43 -0700703
704 result.appendFormat("current monotonic time: %" PRId64 "\n", now);
Andy McFaddenc751e922014-05-08 14:53:26 -0700705}
706
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700707} // namespace android