Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2019 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 | #pragma once |
| 18 | |
Ady Abraham | e988303 | 2023-11-20 17:54:54 -0800 | [diff] [blame] | 19 | #include <deque> |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 20 | #include <mutex> |
| 21 | #include <unordered_map> |
| 22 | #include <vector> |
Dominik Laskowski | 62eff35 | 2021-12-06 09:59:41 -0800 | [diff] [blame] | 23 | |
| 24 | #include <android-base/thread_annotations.h> |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 25 | #include <scheduler/TimeKeeper.h> |
Leon Scroggins III | 6738862 | 2023-02-06 20:36:20 -0500 | [diff] [blame] | 26 | #include <ui/DisplayId.h> |
Dominik Laskowski | 62eff35 | 2021-12-06 09:59:41 -0800 | [diff] [blame] | 27 | |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 28 | #include "VSyncTracker.h" |
| 29 | |
| 30 | namespace android::scheduler { |
| 31 | |
| 32 | class VSyncPredictor : public VSyncTracker { |
| 33 | public: |
| 34 | /* |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 35 | * \param [in] Clock The clock abstraction. Useful for unit tests. |
Leon Scroggins III | 6738862 | 2023-02-06 20:36:20 -0500 | [diff] [blame] | 36 | * \param [in] PhysicalDisplayid The display this corresponds to. |
Ady Abraham | c585dba | 2023-11-15 18:41:35 -0800 | [diff] [blame] | 37 | * \param [in] modePtr The initial display mode |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 38 | * \param [in] historySize The internal amount of entries to store in the model. |
| 39 | * \param [in] minimumSamplesForPrediction The minimum number of samples to collect before |
| 40 | * predicting. \param [in] outlierTolerancePercent a number 0 to 100 that will be used to filter |
| 41 | * samples that fall outlierTolerancePercent from an anticipated vsync event. |
| 42 | */ |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 43 | VSyncPredictor(std::unique_ptr<Clock>, ftl::NonNull<DisplayModePtr> modePtr, size_t historySize, |
ramindani | ae64582 | 2024-01-11 10:57:29 -0800 | [diff] [blame] | 44 | size_t minimumSamplesForPrediction, uint32_t outlierTolerancePercent); |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 45 | ~VSyncPredictor(); |
| 46 | |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 47 | bool addVsyncTimestamp(nsecs_t timestamp) final EXCLUDES(mMutex); |
Ady Abraham | 4335afd | 2023-12-18 19:10:47 -0800 | [diff] [blame] | 48 | nsecs_t nextAnticipatedVSyncTimeFrom(nsecs_t timePoint, |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 49 | std::optional<nsecs_t> lastVsyncOpt = {}) final |
Ady Abraham | 4335afd | 2023-12-18 19:10:47 -0800 | [diff] [blame] | 50 | EXCLUDES(mMutex); |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 51 | nsecs_t currentPeriod() const final EXCLUDES(mMutex); |
Ady Abraham | 3db8a3c | 2023-11-20 17:53:47 -0800 | [diff] [blame] | 52 | Period minFramePeriod() const final EXCLUDES(mMutex); |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 53 | void resetModel() final EXCLUDES(mMutex); |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 54 | |
Kevin DuBois | b818bfa | 2020-07-10 14:29:36 -0700 | [diff] [blame] | 55 | /* Query if the model is in need of more samples to make a prediction. |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 56 | * \return True, if model would benefit from more samples, False if not. |
| 57 | */ |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 58 | bool needsMoreSamples() const final EXCLUDES(mMutex); |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 59 | |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 60 | struct Model { |
| 61 | nsecs_t slope; |
| 62 | nsecs_t intercept; |
| 63 | }; |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 64 | |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 65 | VSyncPredictor::Model getVSyncPredictionModel() const EXCLUDES(mMutex); |
| 66 | |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 67 | bool isVSyncInPhase(nsecs_t timePoint, Fps frameRate) final EXCLUDES(mMutex); |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 68 | |
Ady Abraham | c585dba | 2023-11-15 18:41:35 -0800 | [diff] [blame] | 69 | void setDisplayModePtr(ftl::NonNull<DisplayModePtr>) final EXCLUDES(mMutex); |
| 70 | |
ramindani | d17261e | 2024-03-27 17:50:25 -0700 | [diff] [blame^] | 71 | bool isCurrentMode(const ftl::NonNull<DisplayModePtr>& modePtr) const EXCLUDES(mMutex) { |
| 72 | std::lock_guard lock(mMutex); |
| 73 | return mDisplayModePtr->getId() == modePtr->getId() && |
| 74 | mDisplayModePtr->getVsyncRate().getPeriodNsecs() == |
| 75 | mRateMap.find(idealPeriod())->second.slope; |
| 76 | } |
| 77 | |
Ady Abraham | ee6365b | 2024-03-06 14:31:45 -0800 | [diff] [blame] | 78 | void setRenderRate(Fps, bool applyImmediately) final EXCLUDES(mMutex); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 79 | |
Ady Abraham | e988303 | 2023-11-20 17:54:54 -0800 | [diff] [blame] | 80 | void onFrameBegin(TimePoint expectedPresentTime, TimePoint lastConfirmedPresentTime) final |
| 81 | EXCLUDES(mMutex); |
| 82 | void onFrameMissed(TimePoint expectedPresentTime) final EXCLUDES(mMutex); |
| 83 | |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 84 | void dump(std::string& result) const final EXCLUDES(mMutex); |
Ady Abraham | 5e7371c | 2020-03-24 14:47:24 -0700 | [diff] [blame] | 85 | |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 86 | private: |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 87 | struct VsyncSequence { |
| 88 | nsecs_t vsyncTime; |
| 89 | int64_t seq; |
| 90 | }; |
| 91 | |
| 92 | struct MissedVsync { |
Ady Abraham | c5d7246 | 2024-03-23 23:56:33 +0000 | [diff] [blame] | 93 | TimePoint vsync = TimePoint::fromNs(0); |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 94 | Duration fixup = Duration::fromNs(0); |
| 95 | }; |
| 96 | |
| 97 | class VsyncTimeline { |
| 98 | public: |
Ady Abraham | 77b4fb1 | 2024-03-05 17:51:53 -0800 | [diff] [blame] | 99 | VsyncTimeline(TimePoint knownVsync, Period idealPeriod, std::optional<Fps> renderRateOpt); |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 100 | std::optional<TimePoint> nextAnticipatedVSyncTimeFrom( |
Ady Abraham | 940b7a6 | 2024-03-07 10:04:27 -0800 | [diff] [blame] | 101 | Model model, std::optional<Period> minFramePeriodOpt, nsecs_t vsyncTime, |
| 102 | MissedVsync lastMissedVsync, std::optional<nsecs_t> lastVsyncOpt = {}); |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 103 | void freeze(TimePoint lastVsync); |
| 104 | std::optional<TimePoint> validUntil() const { return mValidUntil; } |
| 105 | bool isVSyncInPhase(Model, nsecs_t vsync, Fps frameRate); |
| 106 | void shiftVsyncSequence(Duration phase); |
Ady Abraham | c5d7246 | 2024-03-23 23:56:33 +0000 | [diff] [blame] | 107 | void setRenderRate(std::optional<Fps> renderRateOpt) { mRenderRateOpt = renderRateOpt; } |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 108 | |
| 109 | private: |
| 110 | nsecs_t snapToVsyncAlignedWithRenderRate(Model model, nsecs_t vsync); |
| 111 | VsyncSequence getVsyncSequenceLocked(Model, nsecs_t vsync); |
Ady Abraham | 77b4fb1 | 2024-03-05 17:51:53 -0800 | [diff] [blame] | 112 | std::optional<VsyncSequence> makeVsyncSequence(TimePoint knownVsync); |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 113 | |
| 114 | const Period mIdealPeriod = Duration::fromNs(0); |
Ady Abraham | 4fc2fce | 2024-03-08 06:43:44 +0000 | [diff] [blame] | 115 | std::optional<Fps> mRenderRateOpt; |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 116 | std::optional<TimePoint> mValidUntil; |
| 117 | std::optional<VsyncSequence> mLastVsyncSequence; |
| 118 | }; |
| 119 | |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 120 | VSyncPredictor(VSyncPredictor const&) = delete; |
| 121 | VSyncPredictor& operator=(VSyncPredictor const&) = delete; |
Kevin DuBois | c3e9e8e | 2020-01-07 09:06:52 -0800 | [diff] [blame] | 122 | void clearTimestamps() REQUIRES(mMutex); |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 123 | |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 124 | const std::unique_ptr<Clock> mClock; |
Leon Scroggins III | 6738862 | 2023-02-06 20:36:20 -0500 | [diff] [blame] | 125 | const PhysicalDisplayId mId; |
| 126 | |
Kevin DuBois | ecb1f0d | 2019-12-12 10:47:41 -0800 | [diff] [blame] | 127 | inline void traceInt64If(const char* name, int64_t value) const; |
Ady Abraham | d9b9a04 | 2023-01-13 11:30:58 -0800 | [diff] [blame] | 128 | inline void traceInt64(const char* name, int64_t value) const; |
Kevin DuBois | ecb1f0d | 2019-12-12 10:47:41 -0800 | [diff] [blame] | 129 | |
Ady Abraham | f34a813 | 2023-02-13 20:49:48 -0800 | [diff] [blame] | 130 | size_t next(size_t i) const REQUIRES(mMutex); |
| 131 | bool validate(nsecs_t timestamp) const REQUIRES(mMutex); |
| 132 | Model getVSyncPredictionModelLocked() const REQUIRES(mMutex); |
Ady Abraham | 4335afd | 2023-12-18 19:10:47 -0800 | [diff] [blame] | 133 | nsecs_t snapToVsync(nsecs_t timePoint) const REQUIRES(mMutex); |
Ady Abraham | e988303 | 2023-11-20 17:54:54 -0800 | [diff] [blame] | 134 | Period minFramePeriodLocked() const REQUIRES(mMutex); |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 135 | Duration ensureMinFrameDurationIsKept(TimePoint, TimePoint) REQUIRES(mMutex); |
| 136 | void purgeTimelines(android::TimePoint now) REQUIRES(mMutex); |
Ady Abraham | f34a813 | 2023-02-13 20:49:48 -0800 | [diff] [blame] | 137 | |
Ady Abraham | c585dba | 2023-11-15 18:41:35 -0800 | [diff] [blame] | 138 | nsecs_t idealPeriod() const REQUIRES(mMutex); |
Ady Abraham | f34a813 | 2023-02-13 20:49:48 -0800 | [diff] [blame] | 139 | |
| 140 | bool const mTraceOn; |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 141 | size_t const kHistorySize; |
| 142 | size_t const kMinimumSamplesForPrediction; |
| 143 | size_t const kOutlierTolerancePercent; |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 144 | std::mutex mutable mMutex; |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 145 | |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 146 | std::optional<nsecs_t> mKnownTimestamp GUARDED_BY(mMutex); |
| 147 | |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 148 | // Map between ideal vsync period and the calculated model |
| 149 | std::unordered_map<nsecs_t, Model> mutable mRateMap GUARDED_BY(mMutex); |
| 150 | |
Ady Abraham | 9c53ee7 | 2020-07-22 21:16:18 -0700 | [diff] [blame] | 151 | size_t mLastTimestampIndex GUARDED_BY(mMutex) = 0; |
Ady Abraham | 92fa2f4 | 2020-02-11 15:33:56 -0800 | [diff] [blame] | 152 | std::vector<nsecs_t> mTimestamps GUARDED_BY(mMutex); |
Ady Abraham | ace3d05 | 2022-11-17 16:25:05 -0800 | [diff] [blame] | 153 | |
Ady Abraham | c585dba | 2023-11-15 18:41:35 -0800 | [diff] [blame] | 154 | ftl::NonNull<DisplayModePtr> mDisplayModePtr GUARDED_BY(mMutex); |
Ady Abraham | 940b7a6 | 2024-03-07 10:04:27 -0800 | [diff] [blame] | 155 | int mNumVsyncsForFrame GUARDED_BY(mMutex); |
Ady Abraham | e988303 | 2023-11-20 17:54:54 -0800 | [diff] [blame] | 156 | |
| 157 | std::deque<TimePoint> mPastExpectedPresentTimes GUARDED_BY(mMutex); |
Ady Abraham | 4335afd | 2023-12-18 19:10:47 -0800 | [diff] [blame] | 158 | |
Ady Abraham | 20024aa | 2024-03-05 01:32:49 +0000 | [diff] [blame] | 159 | MissedVsync mMissedVsync GUARDED_BY(mMutex); |
| 160 | |
| 161 | std::deque<VsyncTimeline> mTimelines GUARDED_BY(mMutex); |
| 162 | TimePoint mLastCommittedVsync GUARDED_BY(mMutex) = TimePoint::fromNs(0); |
| 163 | Period mIdealPeriod GUARDED_BY(mMutex) = Duration::fromNs(0); |
| 164 | std::optional<Fps> mRenderRateOpt GUARDED_BY(mMutex); |
Kevin DuBois | 1678e2c | 2019-08-22 12:26:24 -0700 | [diff] [blame] | 165 | }; |
| 166 | |
| 167 | } // namespace android::scheduler |