Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [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 | |
| 19 | #include <algorithm> |
| 20 | #include <numeric> |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 21 | #include <optional> |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 22 | #include <type_traits> |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 23 | #include <utility> |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 24 | #include <variant> |
Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [diff] [blame] | 25 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 26 | #include <ftl/concat.h> |
Dominik Laskowski | f6b4ba6 | 2021-11-09 12:46:10 -0800 | [diff] [blame] | 27 | #include <gui/DisplayEventReceiver.h> |
| 28 | |
| 29 | #include <scheduler/Fps.h> |
| 30 | #include <scheduler/Seamlessness.h> |
| 31 | |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 32 | #include "DisplayHardware/DisplayMode.h" |
Ana Krulec | 4593b69 | 2019-01-11 22:07:25 -0800 | [diff] [blame] | 33 | #include "DisplayHardware/HWComposer.h" |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 34 | #include "Scheduler/OneShotTimer.h" |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 35 | #include "Scheduler/StrongTyping.h" |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 36 | #include "ThreadContext.h" |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 37 | #include "Utils/Dumper.h" |
Ana Krulec | 4593b69 | 2019-01-11 22:07:25 -0800 | [diff] [blame] | 38 | |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 39 | namespace android::scheduler { |
Ady Abraham | abc2760 | 2020-04-08 17:20:29 -0700 | [diff] [blame] | 40 | |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 41 | using namespace std::chrono_literals; |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 42 | |
Dominik Laskowski | 068173d | 2021-08-11 17:22:59 -0700 | [diff] [blame] | 43 | enum class DisplayModeEvent : unsigned { None = 0b0, Changed = 0b1 }; |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 44 | |
Dominik Laskowski | 068173d | 2021-08-11 17:22:59 -0700 | [diff] [blame] | 45 | inline DisplayModeEvent operator|(DisplayModeEvent lhs, DisplayModeEvent rhs) { |
| 46 | using T = std::underlying_type_t<DisplayModeEvent>; |
| 47 | return static_cast<DisplayModeEvent>(static_cast<T>(lhs) | static_cast<T>(rhs)); |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 48 | } |
Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [diff] [blame] | 49 | |
Ady Abraham | 62f216c | 2020-10-13 19:07:23 -0700 | [diff] [blame] | 50 | using FrameRateOverride = DisplayEventReceiver::Event::FrameRateOverride; |
| 51 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 52 | // Selects the refresh rate of a display by ranking its `DisplayModes` in accordance with |
| 53 | // the DisplayManager (or override) `Policy`, the `LayerRequirement` of each active layer, |
| 54 | // and `GlobalSignals`. |
| 55 | class RefreshRateSelector { |
Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [diff] [blame] | 56 | public: |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 57 | // Margin used when matching refresh rates to the content desired ones. |
| 58 | static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION = |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 59 | std::chrono::nanoseconds(800us).count(); |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 60 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 61 | class Policy { |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 62 | static constexpr int kAllowGroupSwitchingDefault = false; |
| 63 | |
| 64 | public: |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 65 | // The default mode, used to ensure we only initiate display mode switches within the |
| 66 | // same mode group as defaultMode's group. |
| 67 | DisplayModeId defaultMode; |
| 68 | // Whether or not we switch mode groups to get the best frame rate. |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 69 | bool allowGroupSwitching = kAllowGroupSwitchingDefault; |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame^] | 70 | // The primary refresh rate ranges. @see DisplayModeSpecs.aidl for details. |
| 71 | // TODO(b/257072060): use the render range when selecting SF render rate |
| 72 | // or the app override frame rate |
| 73 | FpsRanges primaryRanges; |
| 74 | // The app request refresh rate ranges. @see DisplayModeSpecs.aidl for details. |
| 75 | FpsRanges appRequestRanges; |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 76 | |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 77 | Policy() = default; |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 78 | |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame^] | 79 | Policy(DisplayModeId defaultMode, FpsRange range, |
| 80 | bool allowGroupSwitching = kAllowGroupSwitchingDefault) |
| 81 | : Policy(defaultMode, FpsRanges{range, range}, FpsRanges{range, range}, |
| 82 | allowGroupSwitching) {} |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 83 | |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame^] | 84 | Policy(DisplayModeId defaultMode, FpsRanges primaryRanges, FpsRanges appRequestRanges, |
| 85 | bool allowGroupSwitching = kAllowGroupSwitchingDefault) |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 86 | : defaultMode(defaultMode), |
Marin Shalamanov | 30b0b3c | 2020-10-13 19:15:06 +0200 | [diff] [blame] | 87 | allowGroupSwitching(allowGroupSwitching), |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame^] | 88 | primaryRanges(primaryRanges), |
| 89 | appRequestRanges(appRequestRanges) {} |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 90 | |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 91 | bool operator==(const Policy& other) const { |
Dominik Laskowski | 953b7fd | 2022-01-08 19:34:59 -0800 | [diff] [blame] | 92 | using namespace fps_approx_ops; |
Ady Abraham | 285f8c1 | 2022-10-11 17:12:14 -0700 | [diff] [blame^] | 93 | return defaultMode == other.defaultMode && primaryRanges == other.primaryRanges && |
| 94 | appRequestRanges == other.appRequestRanges && |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 95 | allowGroupSwitching == other.allowGroupSwitching; |
| 96 | } |
| 97 | |
| 98 | bool operator!=(const Policy& other) const { return !(*this == other); } |
Marin Shalamanov | b6674e7 | 2020-11-06 13:05:57 +0100 | [diff] [blame] | 99 | std::string toString() const; |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 100 | }; |
| 101 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 102 | enum class SetPolicyResult { Invalid, Unchanged, Changed }; |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 103 | |
| 104 | // We maintain the display manager policy and the override policy separately. The override |
| 105 | // policy is used by CTS tests to get a consistent device state for testing. While the override |
| 106 | // policy is set, it takes precedence over the display manager policy. Once the override policy |
| 107 | // is cleared, we revert to using the display manager policy. |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 108 | struct DisplayManagerPolicy : Policy { |
| 109 | using Policy::Policy; |
| 110 | }; |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 111 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 112 | struct OverridePolicy : Policy { |
| 113 | using Policy::Policy; |
| 114 | }; |
| 115 | |
| 116 | struct NoOverridePolicy {}; |
| 117 | |
| 118 | using PolicyVariant = std::variant<DisplayManagerPolicy, OverridePolicy, NoOverridePolicy>; |
| 119 | |
| 120 | SetPolicyResult setPolicy(const PolicyVariant&) EXCLUDES(mLock) REQUIRES(kMainThreadContext); |
| 121 | |
| 122 | void onModeChangeInitiated() REQUIRES(kMainThreadContext) { mNumModeSwitchesInPolicy++; } |
| 123 | |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 124 | // Gets the current policy, which will be the override policy if active, and the display manager |
| 125 | // policy otherwise. |
| 126 | Policy getCurrentPolicy() const EXCLUDES(mLock); |
| 127 | // Gets the display manager policy, regardless of whether an override policy is active. |
| 128 | Policy getDisplayManagerPolicy() const EXCLUDES(mLock); |
Ana Krulec | ed3a8cc | 2019-11-14 00:55:07 +0100 | [diff] [blame] | 129 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 130 | // Returns true if mode is allowed by the current policy. |
| 131 | bool isModeAllowed(DisplayModeId) const EXCLUDES(mLock); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 132 | |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 133 | // Describes the different options the layer voted for refresh rate |
| 134 | enum class LayerVoteType { |
Ady Abraham | 71c437d | 2020-01-31 15:56:57 -0800 | [diff] [blame] | 135 | NoVote, // Doesn't care about the refresh rate |
| 136 | Min, // Minimal refresh rate available |
| 137 | Max, // Maximal refresh rate available |
| 138 | Heuristic, // Specific refresh rate that was calculated by platform using a heuristic |
| 139 | ExplicitDefault, // Specific refresh rate that was provided by the app with Default |
| 140 | // compatibility |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 141 | ExplicitExactOrMultiple, // Specific refresh rate that was provided by the app with |
| 142 | // ExactOrMultiple compatibility |
| 143 | ExplicitExact, // Specific refresh rate that was provided by the app with |
| 144 | // Exact compatibility |
| 145 | |
Dominik Laskowski | f5d0ea5 | 2021-09-26 17:27:01 -0700 | [diff] [blame] | 146 | ftl_last = ExplicitExact |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 147 | }; |
| 148 | |
| 149 | // Captures the layer requirements for a refresh rate. This will be used to determine the |
| 150 | // display refresh rate. |
| 151 | struct LayerRequirement { |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 152 | // Layer's name. Used for debugging purposes. |
| 153 | std::string name; |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 154 | // Layer's owner uid |
| 155 | uid_t ownerUid = static_cast<uid_t>(-1); |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 156 | // Layer vote type. |
| 157 | LayerVoteType vote = LayerVoteType::NoVote; |
| 158 | // Layer's desired refresh rate, if applicable. |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 159 | Fps desiredRefreshRate; |
Marin Shalamanov | 4608442 | 2020-10-13 12:33:42 +0200 | [diff] [blame] | 160 | // If a seamless mode switch is required. |
Marin Shalamanov | 53fc11d | 2020-11-20 14:00:13 +0100 | [diff] [blame] | 161 | Seamlessness seamlessness = Seamlessness::Default; |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 162 | // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer |
| 163 | // would have on choosing the refresh rate. |
| 164 | float weight = 0.0f; |
| 165 | // Whether layer is in focus or not based on WindowManager's state |
| 166 | bool focused = false; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 167 | |
| 168 | bool operator==(const LayerRequirement& other) const { |
| 169 | return name == other.name && vote == other.vote && |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 170 | isApproxEqual(desiredRefreshRate, other.desiredRefreshRate) && |
Marin Shalamanov | be97cfa | 2020-12-01 16:02:07 +0100 | [diff] [blame] | 171 | seamlessness == other.seamlessness && weight == other.weight && |
Ady Abraham | aae5ed5 | 2020-06-26 09:32:43 -0700 | [diff] [blame] | 172 | focused == other.focused; |
Ady Abraham | 8a82ba6 | 2020-01-17 12:43:17 -0800 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | bool operator!=(const LayerRequirement& other) const { return !(*this == other); } |
| 176 | }; |
| 177 | |
Ady Abraham | dfd6216 | 2020-06-10 16:11:56 -0700 | [diff] [blame] | 178 | // Global state describing signals that affect refresh rate choice. |
| 179 | struct GlobalSignals { |
| 180 | // Whether the user touched the screen recently. Used to apply touch boost. |
| 181 | bool touch = false; |
| 182 | // True if the system hasn't seen any buffers posted to layers recently. |
| 183 | bool idle = false; |
ramindani | 38c8498 | 2022-08-29 18:02:57 +0000 | [diff] [blame] | 184 | // Whether the display is about to be powered on, or has been in PowerMode::ON |
| 185 | // within the timeout of DisplayPowerTimer. |
| 186 | bool powerOnImminent = false; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 187 | |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 188 | bool operator==(GlobalSignals other) const { |
ramindani | 38c8498 | 2022-08-29 18:02:57 +0000 | [diff] [blame] | 189 | return touch == other.touch && idle == other.idle && |
| 190 | powerOnImminent == other.powerOnImminent; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 191 | } |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 192 | |
| 193 | auto toString() const { |
| 194 | return ftl::Concat("{touch=", touch, ", idle=", idle, |
| 195 | ", powerOnImminent=", powerOnImminent, '}'); |
| 196 | } |
Ady Abraham | dfd6216 | 2020-06-10 16:11:56 -0700 | [diff] [blame] | 197 | }; |
| 198 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 199 | struct ScoredRefreshRate { |
| 200 | DisplayModePtr modePtr; |
| 201 | float score = 0.0f; |
| 202 | |
| 203 | bool operator==(const ScoredRefreshRate& other) const { |
| 204 | return modePtr == other.modePtr && score == other.score; |
| 205 | } |
| 206 | |
| 207 | static bool scoresEqual(float lhs, float rhs) { |
| 208 | constexpr float kEpsilon = 0.0001f; |
| 209 | return std::abs(lhs - rhs) <= kEpsilon; |
| 210 | } |
| 211 | |
| 212 | struct DescendingScore { |
| 213 | bool operator()(const ScoredRefreshRate& lhs, const ScoredRefreshRate& rhs) const { |
| 214 | return lhs.score > rhs.score && !scoresEqual(lhs.score, rhs.score); |
| 215 | } |
| 216 | }; |
| 217 | }; |
| 218 | |
| 219 | using RefreshRateRanking = std::vector<ScoredRefreshRate>; |
| 220 | |
| 221 | struct RankedRefreshRates { |
| 222 | RefreshRateRanking ranking; // Ordered by descending score. |
| 223 | GlobalSignals consideredSignals; |
| 224 | |
| 225 | bool operator==(const RankedRefreshRates& other) const { |
| 226 | return ranking == other.ranking && consideredSignals == other.consideredSignals; |
| 227 | } |
| 228 | }; |
| 229 | |
| 230 | RankedRefreshRates getRankedRefreshRates(const std::vector<LayerRequirement>&, |
| 231 | GlobalSignals) const EXCLUDES(mLock); |
Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [diff] [blame] | 232 | |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 233 | FpsRange getSupportedRefreshRateRange() const EXCLUDES(mLock) { |
| 234 | std::lock_guard lock(mLock); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 235 | return {mMinRefreshRateModeIt->second->getFps(), mMaxRefreshRateModeIt->second->getFps()}; |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 236 | } |
Steven Thomas | 2bbaabe | 2019-08-28 16:08:35 -0700 | [diff] [blame] | 237 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 238 | std::optional<Fps> onKernelTimerChanged(std::optional<DisplayModeId> desiredActiveModeId, |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 239 | bool timerExpired) const EXCLUDES(mLock); |
Steven Thomas | 2bbaabe | 2019-08-28 16:08:35 -0700 | [diff] [blame] | 240 | |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 241 | void setActiveModeId(DisplayModeId) EXCLUDES(mLock) REQUIRES(kMainThreadContext); |
| 242 | |
| 243 | // See mActiveModeIt for thread safety. |
| 244 | DisplayModePtr getActiveModePtr() const EXCLUDES(mLock); |
| 245 | const DisplayMode& getActiveMode() const REQUIRES(kMainThreadContext); |
Dominik Laskowski | 22488f6 | 2019-03-28 09:53:04 -0700 | [diff] [blame] | 246 | |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 247 | // Returns a known frame rate that is the closest to frameRate |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 248 | Fps findClosestKnownFrameRate(Fps frameRate) const; |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 249 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 250 | enum class KernelIdleTimerController { Sysprop, HwcApi, ftl_last = HwcApi }; |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 251 | |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 252 | // Configuration flags. |
| 253 | struct Config { |
| 254 | bool enableFrameRateOverride = false; |
| 255 | |
| 256 | // Specifies the upper refresh rate threshold (inclusive) for layer vote types of multiple |
| 257 | // or heuristic, such that refresh rates higher than this value will not be voted for. 0 if |
| 258 | // no threshold is set. |
| 259 | int frameRateMultipleThreshold = 0; |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 260 | |
Ady Abraham | 6d88593 | 2021-09-03 18:05:48 -0700 | [diff] [blame] | 261 | // The Idle Timer timeout. 0 timeout means no idle timer. |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 262 | std::chrono::milliseconds idleTimerTimeout = 0ms; |
Ady Abraham | 6d88593 | 2021-09-03 18:05:48 -0700 | [diff] [blame] | 263 | |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 264 | // The controller representing how the kernel idle timer will be configured |
| 265 | // either on the HWC api or sysprop. |
| 266 | std::optional<KernelIdleTimerController> kernelIdleTimerController; |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 267 | }; |
| 268 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 269 | RefreshRateSelector(DisplayModes, DisplayModeId activeModeId, |
| 270 | Config config = {.enableFrameRateOverride = false, |
| 271 | .frameRateMultipleThreshold = 0, |
| 272 | .idleTimerTimeout = 0ms, |
| 273 | .kernelIdleTimerController = {}}); |
Ana Krulec | 4593b69 | 2019-01-11 22:07:25 -0800 | [diff] [blame] | 274 | |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 275 | RefreshRateSelector(const RefreshRateSelector&) = delete; |
| 276 | RefreshRateSelector& operator=(const RefreshRateSelector&) = delete; |
Dominik Laskowski | 0c25270 | 2021-12-20 20:32:09 -0800 | [diff] [blame] | 277 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 278 | // Returns whether switching modes (refresh rate or resolution) is possible. |
| 279 | // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the modes only |
Dominik Laskowski | 983f2b5 | 2020-06-25 16:54:06 -0700 | [diff] [blame] | 280 | // differ in resolution. |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 281 | bool canSwitch() const EXCLUDES(mLock) { |
| 282 | std::lock_guard lock(mLock); |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 283 | return mDisplayModes.size() > 1; |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 284 | } |
Dominik Laskowski | 983f2b5 | 2020-06-25 16:54:06 -0700 | [diff] [blame] | 285 | |
TreeHugger Robot | 758ab61 | 2021-06-22 19:17:29 +0000 | [diff] [blame] | 286 | // Class to enumerate options around toggling the kernel timer on and off. |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 287 | enum class KernelIdleTimerAction { |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 288 | TurnOff, // Turn off the idle timer. |
| 289 | TurnOn // Turn on the idle timer. |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 290 | }; |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 291 | |
Ana Krulec | b9afd79 | 2020-06-11 13:16:15 -0700 | [diff] [blame] | 292 | // Checks whether kernel idle timer should be active depending the policy decisions around |
| 293 | // refresh rates. |
| 294 | KernelIdleTimerAction getIdleTimerAction() const; |
| 295 | |
Andy Yu | 2ae6b6b | 2021-11-18 14:51:06 -0800 | [diff] [blame] | 296 | bool supportsFrameRateOverrideByContent() const { return mSupportsFrameRateOverrideByContent; } |
Ady Abraham | 64c2fc0 | 2020-12-29 12:07:50 -0800 | [diff] [blame] | 297 | |
Ady Abraham | cc31549 | 2022-02-17 17:06:39 -0800 | [diff] [blame] | 298 | // Return the display refresh rate divisor to match the layer |
Ady Abraham | 5cc2e26 | 2021-03-25 13:09:17 -0700 | [diff] [blame] | 299 | // frame rate, or 0 if the display refresh rate is not a multiple of the |
| 300 | // layer refresh rate. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 301 | static int getFrameRateDivisor(Fps displayRefreshRate, Fps layerFrameRate); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 302 | |
Marin Shalamanov | 15a0fc6 | 2021-08-16 18:20:21 +0200 | [diff] [blame] | 303 | // Returns if the provided frame rates have a ratio t*1000/1001 or t*1001/1000 |
| 304 | // for an integer t. |
| 305 | static bool isFractionalPairOrMultiple(Fps, Fps); |
| 306 | |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 307 | using UidToFrameRateOverride = std::map<uid_t, Fps>; |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 308 | |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 309 | // Returns the frame rate override for each uid. |
Dominik Laskowski | 6eab42d | 2021-09-13 14:34:13 -0700 | [diff] [blame] | 310 | UidToFrameRateOverride getFrameRateOverrides(const std::vector<LayerRequirement>&, |
| 311 | Fps displayFrameRate, GlobalSignals) const |
Ady Abraham | dd5bfa9 | 2021-01-07 17:56:08 -0800 | [diff] [blame] | 312 | EXCLUDES(mLock); |
Ady Abraham | 0bb6a47 | 2020-10-12 10:22:13 -0700 | [diff] [blame] | 313 | |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 314 | std::optional<KernelIdleTimerController> kernelIdleTimerController() { |
| 315 | return mConfig.kernelIdleTimerController; |
| 316 | } |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 317 | |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 318 | struct IdleTimerCallbacks { |
| 319 | struct Callbacks { |
| 320 | std::function<void()> onReset; |
| 321 | std::function<void()> onExpired; |
| 322 | }; |
| 323 | |
| 324 | Callbacks platform; |
| 325 | Callbacks kernel; |
| 326 | }; |
| 327 | |
| 328 | void setIdleTimerCallbacks(IdleTimerCallbacks callbacks) EXCLUDES(mIdleTimerCallbacksMutex) { |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 329 | std::scoped_lock lock(mIdleTimerCallbacksMutex); |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 330 | mIdleTimerCallbacks = std::move(callbacks); |
| 331 | } |
| 332 | |
| 333 | void clearIdleTimerCallbacks() EXCLUDES(mIdleTimerCallbacksMutex) { |
| 334 | std::scoped_lock lock(mIdleTimerCallbacksMutex); |
| 335 | mIdleTimerCallbacks.reset(); |
Ady Abraham | 1166340 | 2021-11-10 19:46:09 -0800 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | void startIdleTimer() { |
| 339 | if (mIdleTimer) { |
| 340 | mIdleTimer->start(); |
| 341 | } |
| 342 | } |
| 343 | |
| 344 | void stopIdleTimer() { |
| 345 | if (mIdleTimer) { |
| 346 | mIdleTimer->stop(); |
| 347 | } |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 348 | } |
| 349 | |
| 350 | void resetIdleTimer(bool kernelOnly) { |
| 351 | if (!mIdleTimer) { |
| 352 | return; |
| 353 | } |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 354 | if (kernelOnly && !mConfig.kernelIdleTimerController.has_value()) { |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 355 | return; |
| 356 | } |
| 357 | mIdleTimer->reset(); |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 358 | } |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 359 | |
Dominik Laskowski | e70461a | 2022-08-30 14:42:01 -0700 | [diff] [blame] | 360 | void dump(utils::Dumper&) const EXCLUDES(mLock); |
Marin Shalamanov | ba421a8 | 2020-11-10 21:49:26 +0100 | [diff] [blame] | 361 | |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 362 | std::chrono::milliseconds getIdleTimerTimeout(); |
| 363 | |
Dominik Laskowski | 22488f6 | 2019-03-28 09:53:04 -0700 | [diff] [blame] | 364 | private: |
Dominik Laskowski | d82e0f0 | 2022-10-26 15:23:04 -0400 | [diff] [blame] | 365 | friend struct TestableRefreshRateSelector; |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 366 | |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 367 | void constructAvailableRefreshRates() REQUIRES(mLock); |
| 368 | |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 369 | // See mActiveModeIt for thread safety. |
| 370 | DisplayModeIterator getActiveModeItLocked() const REQUIRES(mLock); |
| 371 | |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 372 | RankedRefreshRates getRankedRefreshRatesLocked(const std::vector<LayerRequirement>&, |
| 373 | GlobalSignals) const REQUIRES(mLock); |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 374 | |
Ady Abraham | 4ccdcb4 | 2020-02-11 17:34:34 -0800 | [diff] [blame] | 375 | // Returns number of display frames and remainder when dividing the layer refresh period by |
| 376 | // display refresh period. |
| 377 | std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const; |
| 378 | |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 379 | // Returns the lowest refresh rate according to the current policy. May change at runtime. Only |
| 380 | // uses the primary range, not the app request range. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 381 | const DisplayModePtr& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock); |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 382 | |
| 383 | // Returns the highest refresh rate according to the current policy. May change at runtime. Only |
| 384 | // uses the primary range, not the app request range. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 385 | const DisplayModePtr& getMaxRefreshRateByPolicyLocked(int anchorGroup) const REQUIRES(mLock); |
Marin Shalamanov | 8cd8a99 | 2021-09-14 23:22:49 +0200 | [diff] [blame] | 386 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 387 | struct RefreshRateScoreComparator; |
| 388 | |
| 389 | enum class RefreshRateOrder { Ascending, Descending }; |
| 390 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 391 | // Only uses the primary range, not the app request range. |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 392 | RefreshRateRanking rankRefreshRates(std::optional<int> anchorGroupOpt, RefreshRateOrder, |
| 393 | std::optional<DisplayModeId> preferredDisplayModeOpt = |
| 394 | std::nullopt) const REQUIRES(mLock); |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 395 | |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 396 | const Policy* getCurrentPolicyLocked() const REQUIRES(mLock); |
Marin Shalamanov | eadf2e7 | 2020-12-10 15:35:28 +0100 | [diff] [blame] | 397 | bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock); |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 398 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 399 | // Returns the refresh rate score as a ratio to max refresh rate, which has a score of 1. |
| 400 | float calculateRefreshRateScoreForFps(Fps refreshRate) const REQUIRES(mLock); |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 401 | // calculates a score for a layer. Used to determine the display refresh rate |
| 402 | // and the frame rate override for certains applications. |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 403 | float calculateLayerScoreLocked(const LayerRequirement&, Fps refreshRate, |
Ady Abraham | 62a0be2 | 2020-12-08 16:54:10 -0800 | [diff] [blame] | 404 | bool isSeamlessSwitch) const REQUIRES(mLock); |
| 405 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 406 | float calculateNonExactMatchingLayerScoreLocked(const LayerRequirement&, Fps refreshRate) const |
| 407 | REQUIRES(mLock); |
Ady Abraham | 05243be | 2021-09-16 15:58:52 -0700 | [diff] [blame] | 408 | |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 409 | void updateDisplayModes(DisplayModes, DisplayModeId activeModeId) EXCLUDES(mLock) |
| 410 | REQUIRES(kMainThreadContext); |
Ady Abraham | 3efa394 | 2021-06-24 19:01:25 -0700 | [diff] [blame] | 411 | |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 412 | void initializeIdleTimer(); |
| 413 | |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 414 | std::optional<IdleTimerCallbacks::Callbacks> getIdleTimerCallbacks() const |
| 415 | REQUIRES(mIdleTimerCallbacksMutex) { |
| 416 | if (!mIdleTimerCallbacks) return {}; |
ramindani | 32cf060 | 2022-03-02 02:30:29 +0000 | [diff] [blame] | 417 | return mConfig.kernelIdleTimerController.has_value() ? mIdleTimerCallbacks->kernel |
| 418 | : mIdleTimerCallbacks->platform; |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 419 | } |
| 420 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 421 | // The display modes of the active display. The DisplayModeIterators below are pointers into |
| 422 | // this container, so must be invalidated whenever the DisplayModes change. The Policy below |
| 423 | // is also dependent, so must be reset as well. |
| 424 | DisplayModes mDisplayModes GUARDED_BY(mLock); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 425 | |
Dominik Laskowski | f8734e0 | 2022-08-26 09:06:59 -0700 | [diff] [blame] | 426 | // Written under mLock exclusively from kMainThreadContext, so reads from kMainThreadContext |
| 427 | // need not be under mLock. |
| 428 | DisplayModeIterator mActiveModeIt GUARDED_BY(mLock) GUARDED_BY(kMainThreadContext); |
| 429 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 430 | DisplayModeIterator mMinRefreshRateModeIt GUARDED_BY(mLock); |
| 431 | DisplayModeIterator mMaxRefreshRateModeIt GUARDED_BY(mLock); |
Steven Thomas | f734df4 | 2020-04-13 21:09:28 -0700 | [diff] [blame] | 432 | |
Dominik Laskowski | b0054a2 | 2022-03-03 09:03:06 -0800 | [diff] [blame] | 433 | // Display modes that satisfy the Policy's ranges, filtered and sorted by refresh rate. |
| 434 | std::vector<DisplayModeIterator> mPrimaryRefreshRates GUARDED_BY(mLock); |
| 435 | std::vector<DisplayModeIterator> mAppRequestRefreshRates GUARDED_BY(mLock); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 436 | |
Steven Thomas | d407190 | 2020-03-24 16:02:53 -0700 | [diff] [blame] | 437 | Policy mDisplayManagerPolicy GUARDED_BY(mLock); |
| 438 | std::optional<Policy> mOverridePolicy GUARDED_BY(mLock); |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 439 | |
Dominik Laskowski | 36dced8 | 2022-09-02 09:24:00 -0700 | [diff] [blame] | 440 | unsigned mNumModeSwitchesInPolicy GUARDED_BY(kMainThreadContext) = 0; |
| 441 | |
Ady Abraham | 2139f73 | 2019-11-13 18:56:40 -0800 | [diff] [blame] | 442 | mutable std::mutex mLock; |
Ady Abraham | b1b9d41 | 2020-06-01 19:53:52 -0700 | [diff] [blame] | 443 | |
| 444 | // A sorted list of known frame rates that a Heuristic layer will choose |
| 445 | // from based on the closest value. |
Marin Shalamanov | e8a663d | 2020-11-24 17:48:00 +0100 | [diff] [blame] | 446 | const std::vector<Fps> mKnownFrameRates; |
Ady Abraham | 64c2fc0 | 2020-12-29 12:07:50 -0800 | [diff] [blame] | 447 | |
rnlee | 3bd61066 | 2021-06-23 16:27:57 -0700 | [diff] [blame] | 448 | const Config mConfig; |
Andy Yu | 2ae6b6b | 2021-11-18 14:51:06 -0800 | [diff] [blame] | 449 | bool mSupportsFrameRateOverrideByContent; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 450 | |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 451 | struct GetRankedRefreshRatesCache { |
Dominik Laskowski | a8626ec | 2021-12-15 18:13:30 -0800 | [diff] [blame] | 452 | std::pair<std::vector<LayerRequirement>, GlobalSignals> arguments; |
Dominik Laskowski | 530d6bd | 2022-10-10 16:55:54 -0400 | [diff] [blame] | 453 | RankedRefreshRates result; |
Marin Shalamanov | 4c7831e | 2021-06-08 20:44:06 +0200 | [diff] [blame] | 454 | }; |
ramindani | d72ba16 | 2022-09-09 21:33:40 +0000 | [diff] [blame] | 455 | mutable std::optional<GetRankedRefreshRatesCache> mGetRankedRefreshRatesCache GUARDED_BY(mLock); |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 456 | |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 457 | // Declare mIdleTimer last to ensure its thread joins before the mutex/callbacks are destroyed. |
Ady Abraham | 9a2ea34 | 2021-09-03 17:32:34 -0700 | [diff] [blame] | 458 | std::mutex mIdleTimerCallbacksMutex; |
| 459 | std::optional<IdleTimerCallbacks> mIdleTimerCallbacks GUARDED_BY(mIdleTimerCallbacksMutex); |
Dominik Laskowski | 83bd771 | 2022-01-07 14:30:53 -0800 | [diff] [blame] | 460 | // Used to detect (lack of) frame activity. |
| 461 | std::optional<scheduler::OneShotTimer> mIdleTimer; |
Ana Krulec | b43429d | 2019-01-09 14:28:51 -0800 | [diff] [blame] | 462 | }; |
| 463 | |
Dominik Laskowski | 9804183 | 2019-08-01 18:35:59 -0700 | [diff] [blame] | 464 | } // namespace android::scheduler |