blob: 37dc27d80d3edfc72539fe20cc52e23fbc5dae24 [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.
Jorim Jaggi22ec38b2018-06-19 15:57:08 +0200225 nsecs_t diff = oldPhase - phase;
226 if (diff > mPeriod / 2) {
227 diff -= mPeriod;
228 } else if (diff < -mPeriod / 2) {
229 diff += mPeriod;
230 }
231 listener.mLastEventTime -= diff;
Dan Stoza84d619e2018-03-28 17:07:36 -0700232 mCond.signal();
233 return NO_ERROR;
234 }
235 }
236
237 return BAD_VALUE;
238 }
239
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800240 // This method is only here to handle the !SurfaceFlinger::hasSyncFramework
241 // case.
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700242 bool hasAnyEventListeners() {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000243 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700244 Mutex::Autolock lock(mMutex);
245 return !mEventListeners.empty();
246 }
247
248private:
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700249 struct EventListener {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000250 const char* mName;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700251 nsecs_t mPhase;
252 nsecs_t mLastEventTime;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800253 DispSync::Callback* mCallback;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700254 };
255
256 struct CallbackInvocation {
Lloyd Piquee83f9312018-02-01 12:53:17 -0800257 DispSync::Callback* mCallback;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700258 nsecs_t mEventTime;
259 };
260
261 nsecs_t computeNextEventTimeLocked(nsecs_t now) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000262 if (kTraceDetailedInfo) ATRACE_CALL();
263 ALOGV("[%s] computeNextEventTimeLocked", mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700264 nsecs_t nextEventTime = INT64_MAX;
265 for (size_t i = 0; i < mEventListeners.size(); i++) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800266 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], now);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700267
268 if (t < nextEventTime) {
269 nextEventTime = t;
270 }
271 }
272
Tim Murray4a4e4a22016-04-19 16:29:23 +0000273 ALOGV("[%s] nextEventTime = %" PRId64, mName, ns2us(nextEventTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700274 return nextEventTime;
275 }
276
277 Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000278 if (kTraceDetailedInfo) ATRACE_CALL();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800279 ALOGV("[%s] gatherCallbackInvocationsLocked @ %" PRId64, mName, ns2us(now));
Tim Murray4a4e4a22016-04-19 16:29:23 +0000280
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700281 Vector<CallbackInvocation> callbackInvocations;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000282 nsecs_t onePeriodAgo = now - mPeriod;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700283
284 for (size_t i = 0; i < mEventListeners.size(); i++) {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800285 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], onePeriodAgo);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700286
Jamie Gennis0d5c60e2013-10-09 17:49:37 -0700287 if (t < now) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700288 CallbackInvocation ci;
289 ci.mCallback = mEventListeners[i].mCallback;
290 ci.mEventTime = t;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800291 ALOGV("[%s] [%s] Preparing to fire", mName, mEventListeners[i].mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700292 callbackInvocations.push(ci);
293 mEventListeners.editItemAt(i).mLastEventTime = t;
294 }
295 }
296
297 return callbackInvocations;
298 }
299
Lloyd Pique78ce4182018-01-31 16:39:51 -0800300 nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener, nsecs_t baseTime) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000301 if (kTraceDetailedInfo) ATRACE_CALL();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800302 ALOGV("[%s] [%s] computeListenerNextEventTimeLocked(%" PRId64 ")", mName, listener.mName,
303 ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700304
Tim Murray4a4e4a22016-04-19 16:29:23 +0000305 nsecs_t lastEventTime = listener.mLastEventTime + mWakeupLatency;
306 ALOGV("[%s] lastEventTime: %" PRId64, mName, ns2us(lastEventTime));
307 if (baseTime < lastEventTime) {
308 baseTime = lastEventTime;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800309 ALOGV("[%s] Clamping baseTime to lastEventTime -> %" PRId64, mName, ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700310 }
311
Tim Murray4a4e4a22016-04-19 16:29:23 +0000312 baseTime -= mReferenceTime;
313 ALOGV("[%s] Relative baseTime = %" PRId64, mName, ns2us(baseTime));
314 nsecs_t phase = mPhase + listener.mPhase;
315 ALOGV("[%s] Phase = %" PRId64, mName, ns2us(phase));
316 baseTime -= phase;
317 ALOGV("[%s] baseTime - phase = %" PRId64, mName, ns2us(baseTime));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700318
Tim Murray4a4e4a22016-04-19 16:29:23 +0000319 // If our previous time is before the reference (because the reference
320 // has since been updated), the division by mPeriod will truncate
321 // towards zero instead of computing the floor. Since in all cases
322 // before the reference we want the next time to be effectively now, we
323 // set baseTime to -mPeriod so that numPeriods will be -1.
324 // When we add 1 and the phase, we will be at the correct event time for
325 // this period.
326 if (baseTime < 0) {
327 ALOGV("[%s] Correcting negative baseTime", mName);
328 baseTime = -mPeriod;
329 }
330
331 nsecs_t numPeriods = baseTime / mPeriod;
332 ALOGV("[%s] numPeriods = %" PRId64, mName, numPeriods);
333 nsecs_t t = (numPeriods + 1) * mPeriod + phase;
334 ALOGV("[%s] t = %" PRId64, mName, ns2us(t));
335 t += mReferenceTime;
336 ALOGV("[%s] Absolute t = %" PRId64, mName, ns2us(t));
337
338 // Check that it's been slightly more than half a period since the last
339 // event so that we don't accidentally fall into double-rate vsyncs
340 if (t - listener.mLastEventTime < (3 * mPeriod / 5)) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700341 t += mPeriod;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000342 ALOGV("[%s] Modifying t -> %" PRId64, mName, ns2us(t));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700343 }
344
Tim Murray4a4e4a22016-04-19 16:29:23 +0000345 t -= mWakeupLatency;
346 ALOGV("[%s] Corrected for wakeup latency -> %" PRId64, mName, ns2us(t));
347
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700348 return t;
349 }
350
351 void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000352 if (kTraceDetailedInfo) ATRACE_CALL();
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700353 for (size_t i = 0; i < callbacks.size(); i++) {
354 callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime);
355 }
356 }
357
Tim Murray4a4e4a22016-04-19 16:29:23 +0000358 const char* const mName;
359
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700360 bool mStop;
361
362 nsecs_t mPeriod;
363 nsecs_t mPhase;
Haixia Shi676b1f62015-10-28 16:19:01 -0700364 nsecs_t mReferenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700365 nsecs_t mWakeupLatency;
366
Tim Murray4a4e4a22016-04-19 16:29:23 +0000367 int64_t mFrameNumber;
368
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700369 Vector<EventListener> mEventListeners;
370
371 Mutex mMutex;
372 Condition mCond;
373};
374
Tim Murray4a4e4a22016-04-19 16:29:23 +0000375#undef LOG_TAG
376#define LOG_TAG "DispSync"
377
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700378class ZeroPhaseTracer : public DispSync::Callback {
379public:
380 ZeroPhaseTracer() : mParity(false) {}
381
Mark Salyzyn92dc3fc2014-03-12 13:12:44 -0700382 virtual void onDispSyncEvent(nsecs_t /*when*/) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700383 mParity = !mParity;
384 ATRACE_INT("ZERO_PHASE_VSYNC", mParity ? 1 : 0);
385 }
386
387private:
388 bool mParity;
389};
390
Lloyd Pique78ce4182018-01-31 16:39:51 -0800391DispSync::DispSync(const char* name)
392 : mName(name), mRefreshSkipCount(0), mThread(new DispSyncThread(name)) {}
Andy McFadden645b1f72014-06-10 14:43:32 -0700393
Saurabh Shahf4174532017-07-13 10:45:07 -0700394DispSync::~DispSync() {}
395
396void DispSync::init(bool hasSyncFramework, int64_t dispSyncPresentTimeOffset) {
397 mIgnorePresentFences = !hasSyncFramework;
398 mPresentTimeOffset = dispSyncPresentTimeOffset;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700399 mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
Saurabh Shahf4174532017-07-13 10:45:07 -0700400
Tim Murrayacff43d2016-07-29 13:57:24 -0700401 // set DispSync to SCHED_FIFO to minimize jitter
402 struct sched_param param = {0};
Tim Murray35520632016-09-07 12:18:17 -0700403 param.sched_priority = 2;
Tim Murrayacff43d2016-07-29 13:57:24 -0700404 if (sched_setscheduler(mThread->getTid(), SCHED_FIFO, &param) != 0) {
405 ALOGE("Couldn't set SCHED_FIFO for DispSyncThread");
406 }
407
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700408 reset();
409 beginResync();
410
Andy McFadden5167ec62014-05-22 13:08:43 -0700411 if (kTraceDetailedInfo) {
412 // If we're not getting present fences then the ZeroPhaseTracer
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700413 // would prevent HW vsync event from ever being turned off.
Andy McFadden5167ec62014-05-22 13:08:43 -0700414 // Even if we're just ignoring the fences, the zero-phase tracing is
415 // not needed because any time there is an event registered we will
416 // turn on the HW vsync events.
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800417 if (!mIgnorePresentFences && kEnableZeroPhaseTracer) {
Lloyd Piquee83f9312018-02-01 12:53:17 -0800418 mZeroPhaseTracer = std::make_unique<ZeroPhaseTracer>();
419 addEventListener("ZeroPhaseTracer", 0, mZeroPhaseTracer.get());
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700420 }
421 }
422}
423
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700424void DispSync::reset() {
425 Mutex::Autolock lock(mMutex);
426
Haixia Shi676b1f62015-10-28 16:19:01 -0700427 mPhase = 0;
428 mReferenceTime = 0;
429 mModelUpdated = false;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700430 mNumResyncSamples = 0;
431 mFirstResyncSample = 0;
432 mNumResyncSamplesSincePresent = 0;
433 resetErrorLocked();
434}
435
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700436bool DispSync::addPresentFence(const std::shared_ptr<FenceTime>& fenceTime) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700437 Mutex::Autolock lock(mMutex);
438
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700439 mPresentFences[mPresentSampleOffset] = fenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700440 mPresentSampleOffset = (mPresentSampleOffset + 1) % NUM_PRESENT_SAMPLES;
441 mNumResyncSamplesSincePresent = 0;
442
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700443 updateErrorLocked();
444
Haixia Shi676b1f62015-10-28 16:19:01 -0700445 return !mModelUpdated || mError > kErrorThreshold;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700446}
447
448void DispSync::beginResync() {
449 Mutex::Autolock lock(mMutex);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000450 ALOGV("[%s] beginResync", mName);
Haixia Shi676b1f62015-10-28 16:19:01 -0700451 mModelUpdated = false;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700452 mNumResyncSamples = 0;
453}
454
455bool DispSync::addResyncSample(nsecs_t timestamp) {
456 Mutex::Autolock lock(mMutex);
457
Tim Murray4a4e4a22016-04-19 16:29:23 +0000458 ALOGV("[%s] addResyncSample(%" PRId64 ")", mName, ns2us(timestamp));
459
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700460 size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES;
461 mResyncSamples[idx] = timestamp;
Haixia Shi664339a2015-10-28 13:22:22 -0700462 if (mNumResyncSamples == 0) {
Haixia Shi676b1f62015-10-28 16:19:01 -0700463 mPhase = 0;
464 mReferenceTime = timestamp;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000465 ALOGV("[%s] First resync sample: mPeriod = %" PRId64 ", mPhase = 0, "
Lloyd Pique78ce4182018-01-31 16:39:51 -0800466 "mReferenceTime = %" PRId64,
467 mName, ns2us(mPeriod), ns2us(mReferenceTime));
Tim Murray4a4e4a22016-04-19 16:29:23 +0000468 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
Haixia Shi664339a2015-10-28 13:22:22 -0700469 }
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700470
471 if (mNumResyncSamples < MAX_RESYNC_SAMPLES) {
472 mNumResyncSamples++;
473 } else {
474 mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES;
475 }
476
477 updateModelLocked();
478
479 if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) {
480 resetErrorLocked();
481 }
482
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800483 if (mIgnorePresentFences) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700484 // If we don't have the sync framework we will never have
485 // addPresentFence called. This means we have no way to know whether
486 // or not we're synchronized with the HW vsyncs, so we just request
487 // that the HW vsync events be turned on whenever we need to generate
488 // SW vsync events.
489 return mThread->hasAnyEventListeners();
490 }
491
Tim Murray4a4e4a22016-04-19 16:29:23 +0000492 // Check against kErrorThreshold / 2 to add some hysteresis before having to
493 // resync again
494 bool modelLocked = mModelUpdated && mError < (kErrorThreshold / 2);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800495 ALOGV("[%s] addResyncSample returning %s", mName, modelLocked ? "locked" : "unlocked");
Tim Murray4a4e4a22016-04-19 16:29:23 +0000496 return !modelLocked;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700497}
498
Lloyd Pique78ce4182018-01-31 16:39:51 -0800499void DispSync::endResync() {}
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700500
Lloyd Piquee83f9312018-02-01 12:53:17 -0800501status_t DispSync::addEventListener(const char* name, nsecs_t phase, Callback* callback) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700502 Mutex::Autolock lock(mMutex);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000503 return mThread->addEventListener(name, phase, callback);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700504}
505
Andy McFadden645b1f72014-06-10 14:43:32 -0700506void DispSync::setRefreshSkipCount(int count) {
507 Mutex::Autolock lock(mMutex);
508 ALOGD("setRefreshSkipCount(%d)", count);
509 mRefreshSkipCount = count;
510 updateModelLocked();
Ruchi Kandoif52b3c82014-04-24 16:42:35 -0700511}
512
Lloyd Piquee83f9312018-02-01 12:53:17 -0800513status_t DispSync::removeEventListener(Callback* callback) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700514 Mutex::Autolock lock(mMutex);
515 return mThread->removeEventListener(callback);
516}
517
Dan Stoza84d619e2018-03-28 17:07:36 -0700518status_t DispSync::changePhaseOffset(Callback* callback, nsecs_t phase) {
519 Mutex::Autolock lock(mMutex);
520 return mThread->changePhaseOffset(callback, phase);
521}
522
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700523void DispSync::setPeriod(nsecs_t period) {
524 Mutex::Autolock lock(mMutex);
525 mPeriod = period;
526 mPhase = 0;
Haixia Shi676b1f62015-10-28 16:19:01 -0700527 mReferenceTime = 0;
528 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700529}
530
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700531nsecs_t DispSync::getPeriod() {
532 // lock mutex as mPeriod changes multiple times in updateModelLocked
533 Mutex::Autolock lock(mMutex);
534 return mPeriod;
535}
536
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700537void DispSync::updateModelLocked() {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000538 ALOGV("[%s] updateModelLocked %zu", mName, mNumResyncSamples);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700539 if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) {
Tim Murray4a4e4a22016-04-19 16:29:23 +0000540 ALOGV("[%s] Computing...", mName);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700541 nsecs_t durationSum = 0;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000542 nsecs_t minDuration = INT64_MAX;
543 nsecs_t maxDuration = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700544 for (size_t i = 1; i < mNumResyncSamples; i++) {
545 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
546 size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000547 nsecs_t duration = mResyncSamples[idx] - mResyncSamples[prev];
548 durationSum += duration;
549 minDuration = min(minDuration, duration);
550 maxDuration = max(maxDuration, duration);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700551 }
552
Tim Murray4a4e4a22016-04-19 16:29:23 +0000553 // Exclude the min and max from the average
554 durationSum -= minDuration + maxDuration;
555 mPeriod = durationSum / (mNumResyncSamples - 3);
556
557 ALOGV("[%s] mPeriod = %" PRId64, mName, ns2us(mPeriod));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700558
559 double sampleAvgX = 0;
560 double sampleAvgY = 0;
561 double scale = 2.0 * M_PI / double(mPeriod);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000562 // Intentionally skip the first sample
563 for (size_t i = 1; i < mNumResyncSamples; i++) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700564 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
Haixia Shi676b1f62015-10-28 16:19:01 -0700565 nsecs_t sample = mResyncSamples[idx] - mReferenceTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700566 double samplePhase = double(sample % mPeriod) * scale;
567 sampleAvgX += cos(samplePhase);
568 sampleAvgY += sin(samplePhase);
569 }
570
Tim Murray4a4e4a22016-04-19 16:29:23 +0000571 sampleAvgX /= double(mNumResyncSamples - 1);
572 sampleAvgY /= double(mNumResyncSamples - 1);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700573
574 mPhase = nsecs_t(atan2(sampleAvgY, sampleAvgX) / scale);
575
Tim Murray4a4e4a22016-04-19 16:29:23 +0000576 ALOGV("[%s] mPhase = %" PRId64, mName, ns2us(mPhase));
577
578 if (mPhase < -(mPeriod / 2)) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700579 mPhase += mPeriod;
Tim Murray4a4e4a22016-04-19 16:29:23 +0000580 ALOGV("[%s] Adjusting mPhase -> %" PRId64, mName, ns2us(mPhase));
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700581 }
582
Andy McFadden5167ec62014-05-22 13:08:43 -0700583 if (kTraceDetailedInfo) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700584 ATRACE_INT64("DispSync:Period", mPeriod);
Tim Murray4a4e4a22016-04-19 16:29:23 +0000585 ATRACE_INT64("DispSync:Phase", mPhase + mPeriod / 2);
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700586 }
587
Andy McFadden645b1f72014-06-10 14:43:32 -0700588 // Artificially inflate the period if requested.
589 mPeriod += mPeriod * mRefreshSkipCount;
590
Haixia Shi676b1f62015-10-28 16:19:01 -0700591 mThread->updateModel(mPeriod, mPhase, mReferenceTime);
592 mModelUpdated = true;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700593 }
594}
595
596void DispSync::updateErrorLocked() {
Haixia Shi676b1f62015-10-28 16:19:01 -0700597 if (!mModelUpdated) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700598 return;
599 }
600
Andy McFadden645b1f72014-06-10 14:43:32 -0700601 // Need to compare present fences against the un-adjusted refresh period,
602 // since they might arrive between two events.
603 nsecs_t period = mPeriod / (1 + mRefreshSkipCount);
604
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700605 int numErrSamples = 0;
606 nsecs_t sqErrSum = 0;
607
608 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700609 // Only check for the cached value of signal time to avoid unecessary
610 // syscalls. It is the responsibility of the DispSync owner to
611 // call getSignalTime() periodically so the cache is updated when the
612 // fence signals.
613 nsecs_t time = mPresentFences[i]->getCachedSignalTime();
Lloyd Pique78ce4182018-01-31 16:39:51 -0800614 if (time == Fence::SIGNAL_TIME_PENDING || time == Fence::SIGNAL_TIME_INVALID) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700615 continue;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700616 }
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700617
618 nsecs_t sample = time - mReferenceTime;
619 if (sample <= mPhase) {
620 continue;
621 }
622
623 nsecs_t sampleErr = (sample - mPhase) % period;
624 if (sampleErr > period / 2) {
625 sampleErr -= period;
626 }
627 sqErrSum += sampleErr * sampleErr;
628 numErrSamples++;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700629 }
630
631 if (numErrSamples > 0) {
632 mError = sqErrSum / numErrSamples;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700633 mZeroErrSamplesCount = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700634 } else {
635 mError = 0;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700636 // Use mod ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT to avoid log spam.
637 mZeroErrSamplesCount++;
Lloyd Pique78ce4182018-01-31 16:39:51 -0800638 ALOGE_IF((mZeroErrSamplesCount % ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT) == 0,
639 "No present times for model error.");
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700640 }
641
Andy McFadden5167ec62014-05-22 13:08:43 -0700642 if (kTraceDetailedInfo) {
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700643 ATRACE_INT64("DispSync:Error", mError);
644 }
645}
646
647void DispSync::resetErrorLocked() {
648 mPresentSampleOffset = 0;
649 mError = 0;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700650 mZeroErrSamplesCount = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700651 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700652 mPresentFences[i] = FenceTime::NO_FENCE;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700653 }
654}
655
Andy McFadden41d67d72014-04-25 16:58:34 -0700656nsecs_t DispSync::computeNextRefresh(int periodOffset) const {
Andy McFadden150ecd82014-05-08 14:56:50 -0700657 Mutex::Autolock lock(mMutex);
Andy McFadden41d67d72014-04-25 16:58:34 -0700658 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
Haixia Shi676b1f62015-10-28 16:19:01 -0700659 nsecs_t phase = mReferenceTime + mPhase;
660 return (((now - phase) / mPeriod) + periodOffset + 1) * mPeriod + phase;
Andy McFadden41d67d72014-04-25 16:58:34 -0700661}
662
Andy McFaddenc751e922014-05-08 14:53:26 -0700663void DispSync::dump(String8& result) const {
664 Mutex::Autolock lock(mMutex);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800665 result.appendFormat("present fences are %s\n", mIgnorePresentFences ? "ignored" : "used");
666 result.appendFormat("mPeriod: %" PRId64 " ns (%.3f fps; skipCount=%d)\n", mPeriod,
667 1000000000.0 / mPeriod, mRefreshSkipCount);
Andy McFadden5167ec62014-05-22 13:08:43 -0700668 result.appendFormat("mPhase: %" PRId64 " ns\n", mPhase);
Lloyd Pique78ce4182018-01-31 16:39:51 -0800669 result.appendFormat("mError: %" PRId64 " ns (sqrt=%.1f)\n", mError, sqrt(mError));
Andy McFadden5167ec62014-05-22 13:08:43 -0700670 result.appendFormat("mNumResyncSamplesSincePresent: %d (limit %d)\n",
Lloyd Pique78ce4182018-01-31 16:39:51 -0800671 mNumResyncSamplesSincePresent, MAX_RESYNC_SAMPLES_WITHOUT_PRESENT);
672 result.appendFormat("mNumResyncSamples: %zd (max %d)\n", mNumResyncSamples, MAX_RESYNC_SAMPLES);
Andy McFaddenc751e922014-05-08 14:53:26 -0700673
674 result.appendFormat("mResyncSamples:\n");
675 nsecs_t previous = -1;
676 for (size_t i = 0; i < mNumResyncSamples; i++) {
677 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES;
678 nsecs_t sampleTime = mResyncSamples[idx];
679 if (i == 0) {
Andy McFadden5167ec62014-05-22 13:08:43 -0700680 result.appendFormat(" %" PRId64 "\n", sampleTime);
Andy McFaddenc751e922014-05-08 14:53:26 -0700681 } else {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800682 result.appendFormat(" %" PRId64 " (+%" PRId64 ")\n", sampleTime,
683 sampleTime - previous);
Andy McFaddenc751e922014-05-08 14:53:26 -0700684 }
685 previous = sampleTime;
686 }
687
Lloyd Pique78ce4182018-01-31 16:39:51 -0800688 result.appendFormat("mPresentFences [%d]:\n", NUM_PRESENT_SAMPLES);
Andy McFadden5167ec62014-05-22 13:08:43 -0700689 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700690 previous = Fence::SIGNAL_TIME_INVALID;
Andy McFaddenc751e922014-05-08 14:53:26 -0700691 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
692 size_t idx = (i + mPresentSampleOffset) % NUM_PRESENT_SAMPLES;
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700693 nsecs_t presentTime = mPresentFences[idx]->getSignalTime();
694 if (presentTime == Fence::SIGNAL_TIME_PENDING) {
Andy McFaddenc751e922014-05-08 14:53:26 -0700695 result.appendFormat(" [unsignaled fence]\n");
Lloyd Pique78ce4182018-01-31 16:39:51 -0800696 } else if (presentTime == Fence::SIGNAL_TIME_INVALID) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -0700697 result.appendFormat(" [invalid fence]\n");
698 } else if (previous == Fence::SIGNAL_TIME_PENDING ||
Lloyd Pique78ce4182018-01-31 16:39:51 -0800699 previous == Fence::SIGNAL_TIME_INVALID) {
Andy McFadden5167ec62014-05-22 13:08:43 -0700700 result.appendFormat(" %" PRId64 " (%.3f ms ago)\n", presentTime,
Lloyd Pique78ce4182018-01-31 16:39:51 -0800701 (now - presentTime) / 1000000.0);
Andy McFaddenc751e922014-05-08 14:53:26 -0700702 } else {
Lloyd Pique78ce4182018-01-31 16:39:51 -0800703 result.appendFormat(" %" PRId64 " (+%" PRId64 " / %.3f) (%.3f ms ago)\n", presentTime,
704 presentTime - previous, (presentTime - previous) / (double)mPeriod,
705 (now - presentTime) / 1000000.0);
Andy McFaddenc751e922014-05-08 14:53:26 -0700706 }
707 previous = presentTime;
708 }
Andy McFadden5167ec62014-05-22 13:08:43 -0700709
710 result.appendFormat("current monotonic time: %" PRId64 "\n", now);
Andy McFaddenc751e922014-05-08 14:53:26 -0700711}
712
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700713} // namespace android