DispSync.cpp revision 78ce418ea76033a19663dcc0905e0390d21e5baf
1d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt/* 2d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * Copyright (C) 2013 The Android Open Source Project 3d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * 4d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * Licensed under the Apache License, Version 2.0 (the "License"); 5d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * you may not use this file except in compliance with the License. 6d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * You may obtain a copy of the License at 7d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * 8d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * http://www.apache.org/licenses/LICENSE-2.0 9d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * 10d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * Unless required by applicable law or agreed to in writing, software 11d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * distributed under the License is distributed on an "AS IS" BASIS, 12d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * See the License for the specific language governing permissions and 14d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt * limitations under the License. 15d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt */ 16d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 17d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#define ATRACE_TAG ATRACE_TAG_GRAPHICS 18d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt//#define LOG_NDEBUG 0 19d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 20d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// This is needed for stdint.h to define INT64_MAX in C++ 21d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#define __STDC_LIMIT_MACROS 22d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 23d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <math.h> 24d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 25d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <algorithm> 26d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 27d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <log/log.h> 28d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <utils/String8.h> 29d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <utils/Thread.h> 30d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <utils/Trace.h> 31d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <utils/Vector.h> 32d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 33d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include <ui/FenceTime.h> 34d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 35d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include "DispSync.h" 36d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include "EventLog/EventLog.h" 37d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt#include "SurfaceFlinger.h" 38d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 39d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidtusing std::max; 40d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidtusing std::min; 41d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 42d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidtnamespace android { 43d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 44d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// Setting this to true enables verbose tracing that can be used to debug 45d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// vsync event model or phase issues. 46d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidtstatic const bool kTraceDetailedInfo = false; 47d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 48d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// Setting this to true adds a zero-phase tracer for correlating with hardware 49d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// vsync events 50d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidtstatic const bool kEnableZeroPhaseTracer = false; 51d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt 52d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// This is the threshold used to determine when hardware vsync events are 53d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// needed to re-synchronize the software vsync model with the hardware. The 54d5e4923d04122f81300fa68fb07d64ede28fd44dDmitry Shmidt// error metric used is the mean of the squared difference between each 55// present time and the nearest software-predicted vsync. 56static const nsecs_t kErrorThreshold = 160000000000; // 400 usec squared 57 58#undef LOG_TAG 59#define LOG_TAG "DispSyncThread" 60class DispSyncThread : public Thread { 61public: 62 explicit DispSyncThread(const char* name) 63 : mName(name), 64 mStop(false), 65 mPeriod(0), 66 mPhase(0), 67 mReferenceTime(0), 68 mWakeupLatency(0), 69 mFrameNumber(0) {} 70 71 virtual ~DispSyncThread() {} 72 73 void updateModel(nsecs_t period, nsecs_t phase, nsecs_t referenceTime) { 74 if (kTraceDetailedInfo) ATRACE_CALL(); 75 Mutex::Autolock lock(mMutex); 76 mPeriod = period; 77 mPhase = phase; 78 mReferenceTime = referenceTime; 79 ALOGV("[%s] updateModel: mPeriod = %" PRId64 ", mPhase = %" PRId64 80 " mReferenceTime = %" PRId64, 81 mName, ns2us(mPeriod), ns2us(mPhase), ns2us(mReferenceTime)); 82 mCond.signal(); 83 } 84 85 void stop() { 86 if (kTraceDetailedInfo) ATRACE_CALL(); 87 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); 95 96 while (true) { 97 Vector<CallbackInvocation> callbackInvocations; 98 99 nsecs_t targetTime = 0; 100 101 { // Scope for lock 102 Mutex::Autolock lock(mMutex); 103 104 if (kTraceDetailedInfo) { 105 ATRACE_INT64("DispSync:Frame", mFrameNumber); 106 } 107 ALOGV("[%s] Frame %" PRId64, mName, mFrameNumber); 108 ++mFrameNumber; 109 110 if (mStop) { 111 return false; 112 } 113 114 if (mPeriod == 0) { 115 err = mCond.wait(mMutex); 116 if (err != NO_ERROR) { 117 ALOGE("error waiting for new events: %s (%d)", strerror(-err), err); 118 return false; 119 } 120 continue; 121 } 122 123 targetTime = computeNextEventTimeLocked(now); 124 125 bool isWakeup = false; 126 127 if (now < targetTime) { 128 if (kTraceDetailedInfo) ATRACE_NAME("DispSync waiting"); 129 130 if (targetTime == INT64_MAX) { 131 ALOGV("[%s] Waiting forever", mName); 132 err = mCond.wait(mMutex); 133 } else { 134 ALOGV("[%s] Waiting until %" PRId64, mName, ns2us(targetTime)); 135 err = mCond.waitRelative(mMutex, targetTime - now); 136 } 137 138 if (err == TIMED_OUT) { 139 isWakeup = true; 140 } else if (err != NO_ERROR) { 141 ALOGE("error waiting for next event: %s (%d)", strerror(-err), err); 142 return false; 143 } 144 } 145 146 now = systemTime(SYSTEM_TIME_MONOTONIC); 147 148 // Don't correct by more than 1.5 ms 149 static const nsecs_t kMaxWakeupLatency = us2ns(1500); 150 151 if (isWakeup) { 152 mWakeupLatency = ((mWakeupLatency * 63) + (now - targetTime)) / 64; 153 mWakeupLatency = min(mWakeupLatency, kMaxWakeupLatency); 154 if (kTraceDetailedInfo) { 155 ATRACE_INT64("DispSync:WakeupLat", now - targetTime); 156 ATRACE_INT64("DispSync:AvgWakeupLat", mWakeupLatency); 157 } 158 } 159 160 callbackInvocations = gatherCallbackInvocationsLocked(now); 161 } 162 163 if (callbackInvocations.size() > 0) { 164 fireCallbackInvocations(callbackInvocations); 165 } 166 } 167 168 return false; 169 } 170 171 status_t addEventListener(const char* name, nsecs_t phase, 172 const sp<DispSync::Callback>& callback) { 173 if (kTraceDetailedInfo) ATRACE_CALL(); 174 Mutex::Autolock lock(mMutex); 175 176 for (size_t i = 0; i < mEventListeners.size(); i++) { 177 if (mEventListeners[i].mCallback == callback) { 178 return BAD_VALUE; 179 } 180 } 181 182 EventListener listener; 183 listener.mName = name; 184 listener.mPhase = phase; 185 listener.mCallback = callback; 186 187 // We want to allow the firstmost future event to fire without 188 // allowing any past events to fire 189 listener.mLastEventTime = systemTime() - mPeriod / 2 + mPhase - mWakeupLatency; 190 191 mEventListeners.push(listener); 192 193 mCond.signal(); 194 195 return NO_ERROR; 196 } 197 198 status_t removeEventListener(const sp<DispSync::Callback>& callback) { 199 if (kTraceDetailedInfo) ATRACE_CALL(); 200 Mutex::Autolock lock(mMutex); 201 202 for (size_t i = 0; i < mEventListeners.size(); i++) { 203 if (mEventListeners[i].mCallback == callback) { 204 mEventListeners.removeAt(i); 205 mCond.signal(); 206 return NO_ERROR; 207 } 208 } 209 210 return BAD_VALUE; 211 } 212 213 // This method is only here to handle the !SurfaceFlinger::hasSyncFramework 214 // case. 215 bool hasAnyEventListeners() { 216 if (kTraceDetailedInfo) ATRACE_CALL(); 217 Mutex::Autolock lock(mMutex); 218 return !mEventListeners.empty(); 219 } 220 221private: 222 struct EventListener { 223 const char* mName; 224 nsecs_t mPhase; 225 nsecs_t mLastEventTime; 226 sp<DispSync::Callback> mCallback; 227 }; 228 229 struct CallbackInvocation { 230 sp<DispSync::Callback> mCallback; 231 nsecs_t mEventTime; 232 }; 233 234 nsecs_t computeNextEventTimeLocked(nsecs_t now) { 235 if (kTraceDetailedInfo) ATRACE_CALL(); 236 ALOGV("[%s] computeNextEventTimeLocked", mName); 237 nsecs_t nextEventTime = INT64_MAX; 238 for (size_t i = 0; i < mEventListeners.size(); i++) { 239 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], now); 240 241 if (t < nextEventTime) { 242 nextEventTime = t; 243 } 244 } 245 246 ALOGV("[%s] nextEventTime = %" PRId64, mName, ns2us(nextEventTime)); 247 return nextEventTime; 248 } 249 250 Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) { 251 if (kTraceDetailedInfo) ATRACE_CALL(); 252 ALOGV("[%s] gatherCallbackInvocationsLocked @ %" PRId64, mName, ns2us(now)); 253 254 Vector<CallbackInvocation> callbackInvocations; 255 nsecs_t onePeriodAgo = now - mPeriod; 256 257 for (size_t i = 0; i < mEventListeners.size(); i++) { 258 nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], onePeriodAgo); 259 260 if (t < now) { 261 CallbackInvocation ci; 262 ci.mCallback = mEventListeners[i].mCallback; 263 ci.mEventTime = t; 264 ALOGV("[%s] [%s] Preparing to fire", mName, mEventListeners[i].mName); 265 callbackInvocations.push(ci); 266 mEventListeners.editItemAt(i).mLastEventTime = t; 267 } 268 } 269 270 return callbackInvocations; 271 } 272 273 nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener, nsecs_t baseTime) { 274 if (kTraceDetailedInfo) ATRACE_CALL(); 275 ALOGV("[%s] [%s] computeListenerNextEventTimeLocked(%" PRId64 ")", mName, listener.mName, 276 ns2us(baseTime)); 277 278 nsecs_t lastEventTime = listener.mLastEventTime + mWakeupLatency; 279 ALOGV("[%s] lastEventTime: %" PRId64, mName, ns2us(lastEventTime)); 280 if (baseTime < lastEventTime) { 281 baseTime = lastEventTime; 282 ALOGV("[%s] Clamping baseTime to lastEventTime -> %" PRId64, mName, ns2us(baseTime)); 283 } 284 285 baseTime -= mReferenceTime; 286 ALOGV("[%s] Relative baseTime = %" PRId64, mName, ns2us(baseTime)); 287 nsecs_t phase = mPhase + listener.mPhase; 288 ALOGV("[%s] Phase = %" PRId64, mName, ns2us(phase)); 289 baseTime -= phase; 290 ALOGV("[%s] baseTime - phase = %" PRId64, mName, ns2us(baseTime)); 291 292 // If our previous time is before the reference (because the reference 293 // has since been updated), the division by mPeriod will truncate 294 // towards zero instead of computing the floor. Since in all cases 295 // before the reference we want the next time to be effectively now, we 296 // set baseTime to -mPeriod so that numPeriods will be -1. 297 // When we add 1 and the phase, we will be at the correct event time for 298 // this period. 299 if (baseTime < 0) { 300 ALOGV("[%s] Correcting negative baseTime", mName); 301 baseTime = -mPeriod; 302 } 303 304 nsecs_t numPeriods = baseTime / mPeriod; 305 ALOGV("[%s] numPeriods = %" PRId64, mName, numPeriods); 306 nsecs_t t = (numPeriods + 1) * mPeriod + phase; 307 ALOGV("[%s] t = %" PRId64, mName, ns2us(t)); 308 t += mReferenceTime; 309 ALOGV("[%s] Absolute t = %" PRId64, mName, ns2us(t)); 310 311 // Check that it's been slightly more than half a period since the last 312 // event so that we don't accidentally fall into double-rate vsyncs 313 if (t - listener.mLastEventTime < (3 * mPeriod / 5)) { 314 t += mPeriod; 315 ALOGV("[%s] Modifying t -> %" PRId64, mName, ns2us(t)); 316 } 317 318 t -= mWakeupLatency; 319 ALOGV("[%s] Corrected for wakeup latency -> %" PRId64, mName, ns2us(t)); 320 321 return t; 322 } 323 324 void fireCallbackInvocations(const Vector<CallbackInvocation>& callbacks) { 325 if (kTraceDetailedInfo) ATRACE_CALL(); 326 for (size_t i = 0; i < callbacks.size(); i++) { 327 callbacks[i].mCallback->onDispSyncEvent(callbacks[i].mEventTime); 328 } 329 } 330 331 const char* const mName; 332 333 bool mStop; 334 335 nsecs_t mPeriod; 336 nsecs_t mPhase; 337 nsecs_t mReferenceTime; 338 nsecs_t mWakeupLatency; 339 340 int64_t mFrameNumber; 341 342 Vector<EventListener> mEventListeners; 343 344 Mutex mMutex; 345 Condition mCond; 346}; 347 348#undef LOG_TAG 349#define LOG_TAG "DispSync" 350 351class ZeroPhaseTracer : public DispSync::Callback { 352public: 353 ZeroPhaseTracer() : mParity(false) {} 354 355 virtual void onDispSyncEvent(nsecs_t /*when*/) { 356 mParity = !mParity; 357 ATRACE_INT("ZERO_PHASE_VSYNC", mParity ? 1 : 0); 358 } 359 360private: 361 bool mParity; 362}; 363 364DispSync::DispSync(const char* name) 365 : mName(name), mRefreshSkipCount(0), mThread(new DispSyncThread(name)) {} 366 367DispSync::~DispSync() {} 368 369void DispSync::init(bool hasSyncFramework, int64_t dispSyncPresentTimeOffset) { 370 mIgnorePresentFences = !hasSyncFramework; 371 mPresentTimeOffset = dispSyncPresentTimeOffset; 372 mThread->run("DispSync", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE); 373 374 // set DispSync to SCHED_FIFO to minimize jitter 375 struct sched_param param = {0}; 376 param.sched_priority = 2; 377 if (sched_setscheduler(mThread->getTid(), SCHED_FIFO, ¶m) != 0) { 378 ALOGE("Couldn't set SCHED_FIFO for DispSyncThread"); 379 } 380 381 reset(); 382 beginResync(); 383 384 if (kTraceDetailedInfo) { 385 // If we're not getting present fences then the ZeroPhaseTracer 386 // would prevent HW vsync event from ever being turned off. 387 // Even if we're just ignoring the fences, the zero-phase tracing is 388 // not needed because any time there is an event registered we will 389 // turn on the HW vsync events. 390 if (!mIgnorePresentFences && kEnableZeroPhaseTracer) { 391 addEventListener("ZeroPhaseTracer", 0, new ZeroPhaseTracer()); 392 } 393 } 394} 395 396void DispSync::reset() { 397 Mutex::Autolock lock(mMutex); 398 399 mPhase = 0; 400 mReferenceTime = 0; 401 mModelUpdated = false; 402 mNumResyncSamples = 0; 403 mFirstResyncSample = 0; 404 mNumResyncSamplesSincePresent = 0; 405 resetErrorLocked(); 406} 407 408bool DispSync::addPresentFence(const std::shared_ptr<FenceTime>& fenceTime) { 409 Mutex::Autolock lock(mMutex); 410 411 mPresentFences[mPresentSampleOffset] = fenceTime; 412 mPresentSampleOffset = (mPresentSampleOffset + 1) % NUM_PRESENT_SAMPLES; 413 mNumResyncSamplesSincePresent = 0; 414 415 updateErrorLocked(); 416 417 return !mModelUpdated || mError > kErrorThreshold; 418} 419 420void DispSync::beginResync() { 421 Mutex::Autolock lock(mMutex); 422 ALOGV("[%s] beginResync", mName); 423 mModelUpdated = false; 424 mNumResyncSamples = 0; 425} 426 427bool DispSync::addResyncSample(nsecs_t timestamp) { 428 Mutex::Autolock lock(mMutex); 429 430 ALOGV("[%s] addResyncSample(%" PRId64 ")", mName, ns2us(timestamp)); 431 432 size_t idx = (mFirstResyncSample + mNumResyncSamples) % MAX_RESYNC_SAMPLES; 433 mResyncSamples[idx] = timestamp; 434 if (mNumResyncSamples == 0) { 435 mPhase = 0; 436 mReferenceTime = timestamp; 437 ALOGV("[%s] First resync sample: mPeriod = %" PRId64 ", mPhase = 0, " 438 "mReferenceTime = %" PRId64, 439 mName, ns2us(mPeriod), ns2us(mReferenceTime)); 440 mThread->updateModel(mPeriod, mPhase, mReferenceTime); 441 } 442 443 if (mNumResyncSamples < MAX_RESYNC_SAMPLES) { 444 mNumResyncSamples++; 445 } else { 446 mFirstResyncSample = (mFirstResyncSample + 1) % MAX_RESYNC_SAMPLES; 447 } 448 449 updateModelLocked(); 450 451 if (mNumResyncSamplesSincePresent++ > MAX_RESYNC_SAMPLES_WITHOUT_PRESENT) { 452 resetErrorLocked(); 453 } 454 455 if (mIgnorePresentFences) { 456 // If we don't have the sync framework we will never have 457 // addPresentFence called. This means we have no way to know whether 458 // or not we're synchronized with the HW vsyncs, so we just request 459 // that the HW vsync events be turned on whenever we need to generate 460 // SW vsync events. 461 return mThread->hasAnyEventListeners(); 462 } 463 464 // Check against kErrorThreshold / 2 to add some hysteresis before having to 465 // resync again 466 bool modelLocked = mModelUpdated && mError < (kErrorThreshold / 2); 467 ALOGV("[%s] addResyncSample returning %s", mName, modelLocked ? "locked" : "unlocked"); 468 return !modelLocked; 469} 470 471void DispSync::endResync() {} 472 473status_t DispSync::addEventListener(const char* name, nsecs_t phase, const sp<Callback>& callback) { 474 Mutex::Autolock lock(mMutex); 475 return mThread->addEventListener(name, phase, callback); 476} 477 478void DispSync::setRefreshSkipCount(int count) { 479 Mutex::Autolock lock(mMutex); 480 ALOGD("setRefreshSkipCount(%d)", count); 481 mRefreshSkipCount = count; 482 updateModelLocked(); 483} 484 485status_t DispSync::removeEventListener(const sp<Callback>& callback) { 486 Mutex::Autolock lock(mMutex); 487 return mThread->removeEventListener(callback); 488} 489 490void DispSync::setPeriod(nsecs_t period) { 491 Mutex::Autolock lock(mMutex); 492 mPeriod = period; 493 mPhase = 0; 494 mReferenceTime = 0; 495 mThread->updateModel(mPeriod, mPhase, mReferenceTime); 496} 497 498nsecs_t DispSync::getPeriod() { 499 // lock mutex as mPeriod changes multiple times in updateModelLocked 500 Mutex::Autolock lock(mMutex); 501 return mPeriod; 502} 503 504void DispSync::updateModelLocked() { 505 ALOGV("[%s] updateModelLocked %zu", mName, mNumResyncSamples); 506 if (mNumResyncSamples >= MIN_RESYNC_SAMPLES_FOR_UPDATE) { 507 ALOGV("[%s] Computing...", mName); 508 nsecs_t durationSum = 0; 509 nsecs_t minDuration = INT64_MAX; 510 nsecs_t maxDuration = 0; 511 for (size_t i = 1; i < mNumResyncSamples; i++) { 512 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES; 513 size_t prev = (idx + MAX_RESYNC_SAMPLES - 1) % MAX_RESYNC_SAMPLES; 514 nsecs_t duration = mResyncSamples[idx] - mResyncSamples[prev]; 515 durationSum += duration; 516 minDuration = min(minDuration, duration); 517 maxDuration = max(maxDuration, duration); 518 } 519 520 // Exclude the min and max from the average 521 durationSum -= minDuration + maxDuration; 522 mPeriod = durationSum / (mNumResyncSamples - 3); 523 524 ALOGV("[%s] mPeriod = %" PRId64, mName, ns2us(mPeriod)); 525 526 double sampleAvgX = 0; 527 double sampleAvgY = 0; 528 double scale = 2.0 * M_PI / double(mPeriod); 529 // Intentionally skip the first sample 530 for (size_t i = 1; i < mNumResyncSamples; i++) { 531 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES; 532 nsecs_t sample = mResyncSamples[idx] - mReferenceTime; 533 double samplePhase = double(sample % mPeriod) * scale; 534 sampleAvgX += cos(samplePhase); 535 sampleAvgY += sin(samplePhase); 536 } 537 538 sampleAvgX /= double(mNumResyncSamples - 1); 539 sampleAvgY /= double(mNumResyncSamples - 1); 540 541 mPhase = nsecs_t(atan2(sampleAvgY, sampleAvgX) / scale); 542 543 ALOGV("[%s] mPhase = %" PRId64, mName, ns2us(mPhase)); 544 545 if (mPhase < -(mPeriod / 2)) { 546 mPhase += mPeriod; 547 ALOGV("[%s] Adjusting mPhase -> %" PRId64, mName, ns2us(mPhase)); 548 } 549 550 if (kTraceDetailedInfo) { 551 ATRACE_INT64("DispSync:Period", mPeriod); 552 ATRACE_INT64("DispSync:Phase", mPhase + mPeriod / 2); 553 } 554 555 // Artificially inflate the period if requested. 556 mPeriod += mPeriod * mRefreshSkipCount; 557 558 mThread->updateModel(mPeriod, mPhase, mReferenceTime); 559 mModelUpdated = true; 560 } 561} 562 563void DispSync::updateErrorLocked() { 564 if (!mModelUpdated) { 565 return; 566 } 567 568 // Need to compare present fences against the un-adjusted refresh period, 569 // since they might arrive between two events. 570 nsecs_t period = mPeriod / (1 + mRefreshSkipCount); 571 572 int numErrSamples = 0; 573 nsecs_t sqErrSum = 0; 574 575 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) { 576 // Only check for the cached value of signal time to avoid unecessary 577 // syscalls. It is the responsibility of the DispSync owner to 578 // call getSignalTime() periodically so the cache is updated when the 579 // fence signals. 580 nsecs_t time = mPresentFences[i]->getCachedSignalTime(); 581 if (time == Fence::SIGNAL_TIME_PENDING || time == Fence::SIGNAL_TIME_INVALID) { 582 continue; 583 } 584 585 nsecs_t sample = time - mReferenceTime; 586 if (sample <= mPhase) { 587 continue; 588 } 589 590 nsecs_t sampleErr = (sample - mPhase) % period; 591 if (sampleErr > period / 2) { 592 sampleErr -= period; 593 } 594 sqErrSum += sampleErr * sampleErr; 595 numErrSamples++; 596 } 597 598 if (numErrSamples > 0) { 599 mError = sqErrSum / numErrSamples; 600 mZeroErrSamplesCount = 0; 601 } else { 602 mError = 0; 603 // Use mod ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT to avoid log spam. 604 mZeroErrSamplesCount++; 605 ALOGE_IF((mZeroErrSamplesCount % ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT) == 0, 606 "No present times for model error."); 607 } 608 609 if (kTraceDetailedInfo) { 610 ATRACE_INT64("DispSync:Error", mError); 611 } 612} 613 614void DispSync::resetErrorLocked() { 615 mPresentSampleOffset = 0; 616 mError = 0; 617 mZeroErrSamplesCount = 0; 618 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) { 619 mPresentFences[i] = FenceTime::NO_FENCE; 620 } 621} 622 623nsecs_t DispSync::computeNextRefresh(int periodOffset) const { 624 Mutex::Autolock lock(mMutex); 625 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 626 nsecs_t phase = mReferenceTime + mPhase; 627 return (((now - phase) / mPeriod) + periodOffset + 1) * mPeriod + phase; 628} 629 630void DispSync::dump(String8& result) const { 631 Mutex::Autolock lock(mMutex); 632 result.appendFormat("present fences are %s\n", mIgnorePresentFences ? "ignored" : "used"); 633 result.appendFormat("mPeriod: %" PRId64 " ns (%.3f fps; skipCount=%d)\n", mPeriod, 634 1000000000.0 / mPeriod, mRefreshSkipCount); 635 result.appendFormat("mPhase: %" PRId64 " ns\n", mPhase); 636 result.appendFormat("mError: %" PRId64 " ns (sqrt=%.1f)\n", mError, sqrt(mError)); 637 result.appendFormat("mNumResyncSamplesSincePresent: %d (limit %d)\n", 638 mNumResyncSamplesSincePresent, MAX_RESYNC_SAMPLES_WITHOUT_PRESENT); 639 result.appendFormat("mNumResyncSamples: %zd (max %d)\n", mNumResyncSamples, MAX_RESYNC_SAMPLES); 640 641 result.appendFormat("mResyncSamples:\n"); 642 nsecs_t previous = -1; 643 for (size_t i = 0; i < mNumResyncSamples; i++) { 644 size_t idx = (mFirstResyncSample + i) % MAX_RESYNC_SAMPLES; 645 nsecs_t sampleTime = mResyncSamples[idx]; 646 if (i == 0) { 647 result.appendFormat(" %" PRId64 "\n", sampleTime); 648 } else { 649 result.appendFormat(" %" PRId64 " (+%" PRId64 ")\n", sampleTime, 650 sampleTime - previous); 651 } 652 previous = sampleTime; 653 } 654 655 result.appendFormat("mPresentFences [%d]:\n", NUM_PRESENT_SAMPLES); 656 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 657 previous = Fence::SIGNAL_TIME_INVALID; 658 for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) { 659 size_t idx = (i + mPresentSampleOffset) % NUM_PRESENT_SAMPLES; 660 nsecs_t presentTime = mPresentFences[idx]->getSignalTime(); 661 if (presentTime == Fence::SIGNAL_TIME_PENDING) { 662 result.appendFormat(" [unsignaled fence]\n"); 663 } else if (presentTime == Fence::SIGNAL_TIME_INVALID) { 664 result.appendFormat(" [invalid fence]\n"); 665 } else if (previous == Fence::SIGNAL_TIME_PENDING || 666 previous == Fence::SIGNAL_TIME_INVALID) { 667 result.appendFormat(" %" PRId64 " (%.3f ms ago)\n", presentTime, 668 (now - presentTime) / 1000000.0); 669 } else { 670 result.appendFormat(" %" PRId64 " (+%" PRId64 " / %.3f) (%.3f ms ago)\n", presentTime, 671 presentTime - previous, (presentTime - previous) / (double)mPeriod, 672 (now - presentTime) / 1000000.0); 673 } 674 previous = presentTime; 675 } 676 677 result.appendFormat("current monotonic time: %" PRId64 "\n", now); 678} 679 680} // namespace android 681