blob: a0e27852c9c9ce3653d6512218a0686ca2fe2b8c [file] [log] [blame]
Ana Krulecb43429d2019-01-09 14:28:51 -08001/*
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
Dominik Laskowski98041832019-08-01 18:35:59 -070019#include <type_traits>
Dominik Laskowskia8626ec2021-12-15 18:13:30 -080020#include <utility>
Dominik Laskowski36dced82022-09-02 09:24:00 -070021#include <variant>
Ana Krulecb43429d2019-01-09 14:28:51 -080022
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040023#include <ftl/concat.h>
Dominik Laskowski03cfce82022-11-02 12:13:29 -040024#include <ftl/optional.h>
Ady Abraham68636062022-11-16 17:07:25 -080025#include <ftl/unit.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080026#include <gui/DisplayEventReceiver.h>
27
28#include <scheduler/Fps.h>
Ady Abraham68636062022-11-16 17:07:25 -080029#include <scheduler/FrameRateMode.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080030#include <scheduler/Seamlessness.h>
31
Marin Shalamanov3ea1d602020-12-16 19:59:39 +010032#include "DisplayHardware/DisplayMode.h"
Ady Abraham9a2ea342021-09-03 17:32:34 -070033#include "Scheduler/OneShotTimer.h"
Dominik Laskowskif8734e02022-08-26 09:06:59 -070034#include "ThreadContext.h"
Dominik Laskowskie70461a2022-08-30 14:42:01 -070035#include "Utils/Dumper.h"
Ana Krulec4593b692019-01-11 22:07:25 -080036
Dominik Laskowski98041832019-08-01 18:35:59 -070037namespace android::scheduler {
Ady Abrahamabc27602020-04-08 17:20:29 -070038
Ady Abraham4ccdcb42020-02-11 17:34:34 -080039using namespace std::chrono_literals;
Dominik Laskowski98041832019-08-01 18:35:59 -070040
Ady Abraham62f216c2020-10-13 19:07:23 -070041using FrameRateOverride = DisplayEventReceiver::Event::FrameRateOverride;
42
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040043// Selects the refresh rate of a display by ranking its `DisplayModes` in accordance with
44// the DisplayManager (or override) `Policy`, the `LayerRequirement` of each active layer,
45// and `GlobalSignals`.
46class RefreshRateSelector {
Ana Krulecb43429d2019-01-09 14:28:51 -080047public:
Ady Abraham4ccdcb42020-02-11 17:34:34 -080048 // Margin used when matching refresh rates to the content desired ones.
49 static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =
rnlee3bd610662021-06-23 16:27:57 -070050 std::chrono::nanoseconds(800us).count();
Ady Abraham4ccdcb42020-02-11 17:34:34 -080051
Ady Abraham68636062022-11-16 17:07:25 -080052 // The lowest Render Frame Rate that will ever be selected
Ady Abraham1d173042023-01-04 23:24:47 +000053 static constexpr Fps kMinSupportedFrameRate = 20_Hz;
Ady Abraham68636062022-11-16 17:07:25 -080054
Dominik Laskowski36dced82022-09-02 09:24:00 -070055 class Policy {
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +020056 static constexpr int kAllowGroupSwitchingDefault = false;
57
58 public:
Marin Shalamanova7fe3042021-01-29 21:02:08 +010059 // The default mode, used to ensure we only initiate display mode switches within the
60 // same mode group as defaultMode's group.
61 DisplayModeId defaultMode;
62 // Whether or not we switch mode groups to get the best frame rate.
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +020063 bool allowGroupSwitching = kAllowGroupSwitchingDefault;
Ady Abraham285f8c12022-10-11 17:12:14 -070064 // The primary refresh rate ranges. @see DisplayModeSpecs.aidl for details.
65 // TODO(b/257072060): use the render range when selecting SF render rate
66 // or the app override frame rate
67 FpsRanges primaryRanges;
68 // The app request refresh rate ranges. @see DisplayModeSpecs.aidl for details.
69 FpsRanges appRequestRanges;
Steven Thomasd4071902020-03-24 16:02:53 -070070
Steven Thomasf734df42020-04-13 21:09:28 -070071 Policy() = default;
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +020072
Ady Abraham285f8c12022-10-11 17:12:14 -070073 Policy(DisplayModeId defaultMode, FpsRange range,
74 bool allowGroupSwitching = kAllowGroupSwitchingDefault)
75 : Policy(defaultMode, FpsRanges{range, range}, FpsRanges{range, range},
76 allowGroupSwitching) {}
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +020077
Ady Abraham285f8c12022-10-11 17:12:14 -070078 Policy(DisplayModeId defaultMode, FpsRanges primaryRanges, FpsRanges appRequestRanges,
79 bool allowGroupSwitching = kAllowGroupSwitchingDefault)
Marin Shalamanova7fe3042021-01-29 21:02:08 +010080 : defaultMode(defaultMode),
Marin Shalamanov30b0b3c2020-10-13 19:15:06 +020081 allowGroupSwitching(allowGroupSwitching),
Ady Abraham285f8c12022-10-11 17:12:14 -070082 primaryRanges(primaryRanges),
83 appRequestRanges(appRequestRanges) {}
Steven Thomasf734df42020-04-13 21:09:28 -070084
Steven Thomasd4071902020-03-24 16:02:53 -070085 bool operator==(const Policy& other) const {
Dominik Laskowski953b7fd2022-01-08 19:34:59 -080086 using namespace fps_approx_ops;
Ady Abraham285f8c12022-10-11 17:12:14 -070087 return defaultMode == other.defaultMode && primaryRanges == other.primaryRanges &&
88 appRequestRanges == other.appRequestRanges &&
Steven Thomasd4071902020-03-24 16:02:53 -070089 allowGroupSwitching == other.allowGroupSwitching;
90 }
91
92 bool operator!=(const Policy& other) const { return !(*this == other); }
Ady Abraham90f7fd22023-08-16 11:02:00 -070093
94 bool primaryRangeIsSingleRate() const {
95 return isApproxEqual(primaryRanges.physical.min, primaryRanges.physical.max);
96 }
97
Marin Shalamanovb6674e72020-11-06 13:05:57 +010098 std::string toString() const;
Steven Thomasd4071902020-03-24 16:02:53 -070099 };
100
Dominik Laskowski36dced82022-09-02 09:24:00 -0700101 enum class SetPolicyResult { Invalid, Unchanged, Changed };
Steven Thomasd4071902020-03-24 16:02:53 -0700102
103 // We maintain the display manager policy and the override policy separately. The override
104 // policy is used by CTS tests to get a consistent device state for testing. While the override
105 // policy is set, it takes precedence over the display manager policy. Once the override policy
106 // is cleared, we revert to using the display manager policy.
Dominik Laskowski36dced82022-09-02 09:24:00 -0700107 struct DisplayManagerPolicy : Policy {
108 using Policy::Policy;
109 };
Steven Thomasd4071902020-03-24 16:02:53 -0700110
Dominik Laskowski36dced82022-09-02 09:24:00 -0700111 struct OverridePolicy : Policy {
112 using Policy::Policy;
113 };
114
115 struct NoOverridePolicy {};
116
117 using PolicyVariant = std::variant<DisplayManagerPolicy, OverridePolicy, NoOverridePolicy>;
118
119 SetPolicyResult setPolicy(const PolicyVariant&) EXCLUDES(mLock) REQUIRES(kMainThreadContext);
120
121 void onModeChangeInitiated() REQUIRES(kMainThreadContext) { mNumModeSwitchesInPolicy++; }
122
Steven Thomasd4071902020-03-24 16:02:53 -0700123 // Gets the current policy, which will be the override policy if active, and the display manager
124 // policy otherwise.
125 Policy getCurrentPolicy() const EXCLUDES(mLock);
126 // Gets the display manager policy, regardless of whether an override policy is active.
127 Policy getDisplayManagerPolicy() const EXCLUDES(mLock);
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100128
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100129 // Returns true if mode is allowed by the current policy.
Ady Abrahamace3d052022-11-17 16:25:05 -0800130 bool isModeAllowed(const FrameRateMode&) const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800131
Ady Abraham8a82ba62020-01-17 12:43:17 -0800132 // Describes the different options the layer voted for refresh rate
133 enum class LayerVoteType {
Ady Abraham71c437d2020-01-31 15:56:57 -0800134 NoVote, // Doesn't care about the refresh rate
135 Min, // Minimal refresh rate available
136 Max, // Maximal refresh rate available
137 Heuristic, // Specific refresh rate that was calculated by platform using a heuristic
138 ExplicitDefault, // Specific refresh rate that was provided by the app with Default
139 // compatibility
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800140 ExplicitExactOrMultiple, // Specific refresh rate that was provided by the app with
141 // ExactOrMultiple compatibility
142 ExplicitExact, // Specific refresh rate that was provided by the app with
143 // Exact compatibility
Rachel Leee5514a72023-10-25 16:20:29 -0700144 ExplicitGte, // Greater than or equal to frame rate provided by the app
Rachel Leece6e0042023-06-27 11:22:54 -0700145 ExplicitCategory, // Specific frame rate category was provided by the app
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800146
Rachel Leece6e0042023-06-27 11:22:54 -0700147 ftl_last = ExplicitCategory
Ady Abraham8a82ba62020-01-17 12:43:17 -0800148 };
149
150 // Captures the layer requirements for a refresh rate. This will be used to determine the
151 // display refresh rate.
152 struct LayerRequirement {
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700153 // Layer's name. Used for debugging purposes.
154 std::string name;
Ady Abraham62a0be22020-12-08 16:54:10 -0800155 // Layer's owner uid
156 uid_t ownerUid = static_cast<uid_t>(-1);
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700157 // Layer vote type.
158 LayerVoteType vote = LayerVoteType::NoVote;
159 // Layer's desired refresh rate, if applicable.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700160 Fps desiredRefreshRate;
Marin Shalamanov46084422020-10-13 12:33:42 +0200161 // If a seamless mode switch is required.
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100162 Seamlessness seamlessness = Seamlessness::Default;
Rachel Lee67afbea2023-09-28 15:35:07 -0700163 // Layer frame rate category.
Rachel Leece6e0042023-06-27 11:22:54 -0700164 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
Rachel Lee67afbea2023-09-28 15:35:07 -0700165 // Goes together with frame rate category vote. Allow refresh rate changes only
166 // if there would be no jank.
167 bool frameRateCategorySmoothSwitchOnly = false;
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700168 // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
169 // would have on choosing the refresh rate.
170 float weight = 0.0f;
171 // Whether layer is in focus or not based on WindowManager's state
172 bool focused = false;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800173
174 bool operator==(const LayerRequirement& other) const {
175 return name == other.name && vote == other.vote &&
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700176 isApproxEqual(desiredRefreshRate, other.desiredRefreshRate) &&
Marin Shalamanovbe97cfa2020-12-01 16:02:07 +0100177 seamlessness == other.seamlessness && weight == other.weight &&
Rachel Leece6e0042023-06-27 11:22:54 -0700178 focused == other.focused && frameRateCategory == other.frameRateCategory;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800179 }
180
181 bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
Rachel Leece6e0042023-06-27 11:22:54 -0700182
Rachel Leed0694bc2023-09-12 14:57:58 -0700183 bool isNoVote() const { return RefreshRateSelector::isNoVote(vote); }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800184 };
185
Rachel Leece6e0042023-06-27 11:22:54 -0700186 // Returns true if the layer explicitly instructs to not contribute to refresh rate selection.
187 // In other words, true if the layer should be ignored.
Rachel Leed0694bc2023-09-12 14:57:58 -0700188 static bool isNoVote(LayerVoteType vote) { return vote == LayerVoteType::NoVote; }
Rachel Leece6e0042023-06-27 11:22:54 -0700189
Ady Abrahamdfd62162020-06-10 16:11:56 -0700190 // Global state describing signals that affect refresh rate choice.
191 struct GlobalSignals {
192 // Whether the user touched the screen recently. Used to apply touch boost.
193 bool touch = false;
194 // True if the system hasn't seen any buffers posted to layers recently.
195 bool idle = false;
ramindani38c84982022-08-29 18:02:57 +0000196 // Whether the display is about to be powered on, or has been in PowerMode::ON
197 // within the timeout of DisplayPowerTimer.
198 bool powerOnImminent = false;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200199
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700200 bool operator==(GlobalSignals other) const {
ramindani38c84982022-08-29 18:02:57 +0000201 return touch == other.touch && idle == other.idle &&
202 powerOnImminent == other.powerOnImminent;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200203 }
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400204
205 auto toString() const {
206 return ftl::Concat("{touch=", touch, ", idle=", idle,
207 ", powerOnImminent=", powerOnImminent, '}');
208 }
Ady Abrahamdfd62162020-06-10 16:11:56 -0700209 };
210
Ady Abraham68636062022-11-16 17:07:25 -0800211 struct ScoredFrameRate {
212 FrameRateMode frameRateMode;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400213 float score = 0.0f;
214
Ady Abraham68636062022-11-16 17:07:25 -0800215 bool operator==(const ScoredFrameRate& other) const {
216 return frameRateMode == other.frameRateMode && score == other.score;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400217 }
218
219 static bool scoresEqual(float lhs, float rhs) {
220 constexpr float kEpsilon = 0.0001f;
221 return std::abs(lhs - rhs) <= kEpsilon;
222 }
223
224 struct DescendingScore {
Ady Abraham68636062022-11-16 17:07:25 -0800225 bool operator()(const ScoredFrameRate& lhs, const ScoredFrameRate& rhs) const {
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400226 return lhs.score > rhs.score && !scoresEqual(lhs.score, rhs.score);
227 }
228 };
229 };
230
Ady Abraham68636062022-11-16 17:07:25 -0800231 using FrameRateRanking = std::vector<ScoredFrameRate>;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400232
Ady Abraham68636062022-11-16 17:07:25 -0800233 struct RankedFrameRates {
234 FrameRateRanking ranking; // Ordered by descending score.
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400235 GlobalSignals consideredSignals;
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500236 Fps pacesetterFps;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400237
Ady Abraham68636062022-11-16 17:07:25 -0800238 bool operator==(const RankedFrameRates& other) const {
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500239 return ranking == other.ranking && consideredSignals == other.consideredSignals &&
240 isApproxEqual(pacesetterFps, other.pacesetterFps);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400241 }
242 };
243
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500244 // If valid, `pacesetterFps` (used by follower displays) filters the ranking to modes matching
245 // that refresh rate.
246 RankedFrameRates getRankedFrameRates(const std::vector<LayerRequirement>&, GlobalSignals,
247 Fps pacesetterFps = {}) const EXCLUDES(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800248
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100249 FpsRange getSupportedRefreshRateRange() const EXCLUDES(mLock) {
250 std::lock_guard lock(mLock);
ramindania04b8a52023-08-07 18:49:47 -0700251 return {mMinRefreshRateModeIt->second->getPeakFps(),
252 mMaxRefreshRateModeIt->second->getPeakFps()};
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100253 }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700254
Dominik Laskowski59746512023-11-19 09:30:24 -0500255 ftl::Optional<FrameRateMode> onKernelTimerChanged(ftl::Optional<DisplayModeId> desiredModeIdOpt,
256 bool timerExpired) const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700257
Ady Abrahamace3d052022-11-17 16:25:05 -0800258 void setActiveMode(DisplayModeId, Fps renderFrameRate) EXCLUDES(mLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700259
Ady Abrahamace3d052022-11-17 16:25:05 -0800260 // See mActiveModeOpt for thread safety.
261 FrameRateMode getActiveMode() const EXCLUDES(mLock);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700262
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700263 // Returns a known frame rate that is the closest to frameRate
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100264 Fps findClosestKnownFrameRate(Fps frameRate) const;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700265
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800266 enum class KernelIdleTimerController { Sysprop, HwcApi, ftl_last = HwcApi };
ramindani32cf0602022-03-02 02:30:29 +0000267
rnlee3bd610662021-06-23 16:27:57 -0700268 // Configuration flags.
269 struct Config {
Ady Abraham8ca643a2022-10-18 18:26:47 -0700270 enum class FrameRateOverride {
271 // Do not override the frame rate for an app
272 Disabled,
273
274 // Override the frame rate for an app to a value which is also
275 // a display refresh rate
Ady Abraham68636062022-11-16 17:07:25 -0800276 AppOverrideNativeRefreshRates,
Ady Abraham8ca643a2022-10-18 18:26:47 -0700277
278 // Override the frame rate for an app to any value
Ady Abraham68636062022-11-16 17:07:25 -0800279 AppOverride,
280
281 // Override the frame rate for all apps and all values.
Ady Abraham8ca643a2022-10-18 18:26:47 -0700282 Enabled,
283
284 ftl_last = Enabled
285 };
286 FrameRateOverride enableFrameRateOverride = FrameRateOverride::Disabled;
rnlee3bd610662021-06-23 16:27:57 -0700287
288 // Specifies the upper refresh rate threshold (inclusive) for layer vote types of multiple
289 // or heuristic, such that refresh rates higher than this value will not be voted for. 0 if
290 // no threshold is set.
291 int frameRateMultipleThreshold = 0;
Ady Abraham9a2ea342021-09-03 17:32:34 -0700292
Ady Abraham6d885932021-09-03 18:05:48 -0700293 // The Idle Timer timeout. 0 timeout means no idle timer.
ramindani32cf0602022-03-02 02:30:29 +0000294 std::chrono::milliseconds idleTimerTimeout = 0ms;
Ady Abraham6d885932021-09-03 18:05:48 -0700295
ramindani32cf0602022-03-02 02:30:29 +0000296 // The controller representing how the kernel idle timer will be configured
297 // either on the HWC api or sysprop.
Dominik Laskowski03cfce82022-11-02 12:13:29 -0400298 ftl::Optional<KernelIdleTimerController> kernelIdleTimerController;
rnlee3bd610662021-06-23 16:27:57 -0700299 };
300
Ady Abraham8ca643a2022-10-18 18:26:47 -0700301 RefreshRateSelector(
302 DisplayModes, DisplayModeId activeModeId,
303 Config config = {.enableFrameRateOverride = Config::FrameRateOverride::Disabled,
304 .frameRateMultipleThreshold = 0,
305 .idleTimerTimeout = 0ms,
306 .kernelIdleTimerController = {}});
Ana Krulec4593b692019-01-11 22:07:25 -0800307
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400308 RefreshRateSelector(const RefreshRateSelector&) = delete;
309 RefreshRateSelector& operator=(const RefreshRateSelector&) = delete;
Dominik Laskowski0c252702021-12-20 20:32:09 -0800310
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500311 const DisplayModes& displayModes() const { return mDisplayModes; }
312
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100313 // Returns whether switching modes (refresh rate or resolution) is possible.
314 // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the modes only
Ady Abraham68636062022-11-16 17:07:25 -0800315 // differ in resolution. Once Config::FrameRateOverride::Enabled becomes the default,
316 // we can probably remove canSwitch altogether since all devices will be able
317 // to switch to a frame rate divisor.
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100318 bool canSwitch() const EXCLUDES(mLock) {
319 std::lock_guard lock(mLock);
Ady Abraham68636062022-11-16 17:07:25 -0800320 return mDisplayModes.size() > 1 ||
321 mFrameRateOverrideConfig == Config::FrameRateOverride::Enabled;
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100322 }
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700323
TreeHugger Robot758ab612021-06-22 19:17:29 +0000324 // Class to enumerate options around toggling the kernel timer on and off.
Ana Krulecb9afd792020-06-11 13:16:15 -0700325 enum class KernelIdleTimerAction {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400326 TurnOff, // Turn off the idle timer.
327 TurnOn // Turn on the idle timer.
Ana Krulecb9afd792020-06-11 13:16:15 -0700328 };
ramindani32cf0602022-03-02 02:30:29 +0000329
Ana Krulecb9afd792020-06-11 13:16:15 -0700330 // Checks whether kernel idle timer should be active depending the policy decisions around
331 // refresh rates.
332 KernelIdleTimerAction getIdleTimerAction() const;
333
Ady Abraham68636062022-11-16 17:07:25 -0800334 bool supportsAppFrameRateOverrideByContent() const {
Ady Abraham8ca643a2022-10-18 18:26:47 -0700335 return mFrameRateOverrideConfig != Config::FrameRateOverride::Disabled;
336 }
Ady Abraham64c2fc02020-12-29 12:07:50 -0800337
Ady Abraham68636062022-11-16 17:07:25 -0800338 bool supportsFrameRateOverride() const {
339 return mFrameRateOverrideConfig == Config::FrameRateOverride::Enabled;
340 }
341
Ady Abrahamcc315492022-02-17 17:06:39 -0800342 // Return the display refresh rate divisor to match the layer
Ady Abraham5cc2e262021-03-25 13:09:17 -0700343 // frame rate, or 0 if the display refresh rate is not a multiple of the
344 // layer refresh rate.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800345 static int getFrameRateDivisor(Fps displayRefreshRate, Fps layerFrameRate);
Ady Abraham62a0be22020-12-08 16:54:10 -0800346
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200347 // Returns if the provided frame rates have a ratio t*1000/1001 or t*1001/1000
348 // for an integer t.
349 static bool isFractionalPairOrMultiple(Fps, Fps);
350
Ady Abraham62a0be22020-12-08 16:54:10 -0800351 using UidToFrameRateOverride = std::map<uid_t, Fps>;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700352
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800353 // Returns the frame rate override for each uid.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700354 UidToFrameRateOverride getFrameRateOverrides(const std::vector<LayerRequirement>&,
355 Fps displayFrameRate, GlobalSignals) const
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800356 EXCLUDES(mLock);
Ady Abraham0bb6a472020-10-12 10:22:13 -0700357
Rachel Leece6e0042023-06-27 11:22:54 -0700358 // Gets the FpsRange that the FrameRateCategory represents.
359 static FpsRange getFrameRateCategoryRange(FrameRateCategory category);
360
ramindani32cf0602022-03-02 02:30:29 +0000361 std::optional<KernelIdleTimerController> kernelIdleTimerController() {
362 return mConfig.kernelIdleTimerController;
363 }
Ady Abraham9a2ea342021-09-03 17:32:34 -0700364
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800365 struct IdleTimerCallbacks {
366 struct Callbacks {
367 std::function<void()> onReset;
368 std::function<void()> onExpired;
369 };
370
371 Callbacks platform;
372 Callbacks kernel;
373 };
374
375 void setIdleTimerCallbacks(IdleTimerCallbacks callbacks) EXCLUDES(mIdleTimerCallbacksMutex) {
Ady Abraham9a2ea342021-09-03 17:32:34 -0700376 std::scoped_lock lock(mIdleTimerCallbacksMutex);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800377 mIdleTimerCallbacks = std::move(callbacks);
378 }
379
380 void clearIdleTimerCallbacks() EXCLUDES(mIdleTimerCallbacksMutex) {
381 std::scoped_lock lock(mIdleTimerCallbacksMutex);
382 mIdleTimerCallbacks.reset();
Ady Abraham11663402021-11-10 19:46:09 -0800383 }
384
385 void startIdleTimer() {
386 if (mIdleTimer) {
387 mIdleTimer->start();
388 }
389 }
390
391 void stopIdleTimer() {
392 if (mIdleTimer) {
393 mIdleTimer->stop();
394 }
Ady Abraham9a2ea342021-09-03 17:32:34 -0700395 }
396
Dominik Laskowski596a2562022-10-28 11:26:12 -0400397 void resetKernelIdleTimer() {
398 if (mIdleTimer && mConfig.kernelIdleTimerController) {
399 mIdleTimer->reset();
Ady Abraham9a2ea342021-09-03 17:32:34 -0700400 }
Dominik Laskowski596a2562022-10-28 11:26:12 -0400401 }
402
403 void resetIdleTimer() {
404 if (mIdleTimer) {
405 mIdleTimer->reset();
Ady Abraham9a2ea342021-09-03 17:32:34 -0700406 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800407 }
Ady Abraham9a2ea342021-09-03 17:32:34 -0700408
Dominik Laskowskie70461a2022-08-30 14:42:01 -0700409 void dump(utils::Dumper&) const EXCLUDES(mLock);
Marin Shalamanovba421a82020-11-10 21:49:26 +0100410
ramindani32cf0602022-03-02 02:30:29 +0000411 std::chrono::milliseconds getIdleTimerTimeout();
412
Rachel Lee45681982024-03-14 18:40:15 -0700413 bool isVrrDevice() const;
414
Dominik Laskowski22488f62019-03-28 09:53:04 -0700415private:
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400416 friend struct TestableRefreshRateSelector;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700417
Ady Abraham2139f732019-11-13 18:56:40 -0800418 void constructAvailableRefreshRates() REQUIRES(mLock);
419
Ady Abrahamace3d052022-11-17 16:25:05 -0800420 // See mActiveModeOpt for thread safety.
421 const FrameRateMode& getActiveModeLocked() const REQUIRES(mLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700422
Ady Abraham68636062022-11-16 17:07:25 -0800423 RankedFrameRates getRankedFrameRatesLocked(const std::vector<LayerRequirement>& layers,
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500424 GlobalSignals signals, Fps pacesetterFps) const
425 REQUIRES(mLock);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200426
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800427 // Returns number of display frames and remainder when dividing the layer refresh period by
428 // display refresh period.
429 std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;
430
Steven Thomasf734df42020-04-13 21:09:28 -0700431 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
432 // uses the primary range, not the app request range.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800433 const DisplayModePtr& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);
Steven Thomasf734df42020-04-13 21:09:28 -0700434
435 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
436 // uses the primary range, not the app request range.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800437 const DisplayModePtr& getMaxRefreshRateByPolicyLocked(int anchorGroup) const REQUIRES(mLock);
Marin Shalamanov8cd8a992021-09-14 23:22:49 +0200438
ramindanid72ba162022-09-09 21:33:40 +0000439 struct RefreshRateScoreComparator;
440
Ady Abraham68636062022-11-16 17:07:25 -0800441 enum class RefreshRateOrder {
442 Ascending,
443 Descending,
444
445 ftl_last = Descending
446 };
ramindanid72ba162022-09-09 21:33:40 +0000447
Rachel Lee67afbea2023-09-28 15:35:07 -0700448 typedef std::function<bool(const FrameRateMode)> RankFrameRatesPredicate;
449
450 // Rank the frame rates.
451 // Only modes in the primary range for which `predicate` is `true` will be scored.
452 // Does not use the app requested range.
Ady Abraham68636062022-11-16 17:07:25 -0800453 FrameRateRanking rankFrameRates(
454 std::optional<int> anchorGroupOpt, RefreshRateOrder refreshRateOrder,
Rachel Lee67afbea2023-09-28 15:35:07 -0700455 std::optional<DisplayModeId> preferredDisplayModeOpt = std::nullopt,
456 const RankFrameRatesPredicate& predicate = [](FrameRateMode) { return true; }) const
Ady Abraham68636062022-11-16 17:07:25 -0800457 REQUIRES(mLock);
ramindanid72ba162022-09-09 21:33:40 +0000458
Steven Thomasd4071902020-03-24 16:02:53 -0700459 const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100460 bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock);
Steven Thomasd4071902020-03-24 16:02:53 -0700461
ramindanid72ba162022-09-09 21:33:40 +0000462 // Returns the refresh rate score as a ratio to max refresh rate, which has a score of 1.
Rachel Leee5514a72023-10-25 16:20:29 -0700463 float calculateDistanceScoreFromMaxLocked(Fps refreshRate) const REQUIRES(mLock);
464
465 // Returns the refresh rate score based on its distance from the reference rate.
466 float calculateDistanceScoreLocked(Fps referenceRate, Fps refreshRate) const REQUIRES(mLock);
467
Ady Abraham62a0be22020-12-08 16:54:10 -0800468 // calculates a score for a layer. Used to determine the display refresh rate
469 // and the frame rate override for certains applications.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800470 float calculateLayerScoreLocked(const LayerRequirement&, Fps refreshRate,
Ady Abraham62a0be22020-12-08 16:54:10 -0800471 bool isSeamlessSwitch) const REQUIRES(mLock);
472
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800473 float calculateNonExactMatchingLayerScoreLocked(const LayerRequirement&, Fps refreshRate) const
474 REQUIRES(mLock);
Ady Abraham05243be2021-09-16 15:58:52 -0700475
Rachel Leece6e0042023-06-27 11:22:54 -0700476 // Calculates the score for non-exact matching layer that has LayerVoteType::ExplicitDefault.
477 float calculateNonExactMatchingDefaultLayerScoreLocked(nsecs_t displayPeriod,
478 nsecs_t layerPeriod) const
479 REQUIRES(mLock);
480
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700481 void updateDisplayModes(DisplayModes, DisplayModeId activeModeId) EXCLUDES(mLock)
482 REQUIRES(kMainThreadContext);
Ady Abraham3efa3942021-06-24 19:01:25 -0700483
Ady Abraham9a2ea342021-09-03 17:32:34 -0700484 void initializeIdleTimer();
485
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800486 std::optional<IdleTimerCallbacks::Callbacks> getIdleTimerCallbacks() const
487 REQUIRES(mIdleTimerCallbacksMutex) {
488 if (!mIdleTimerCallbacks) return {};
ramindani32cf0602022-03-02 02:30:29 +0000489 return mConfig.kernelIdleTimerController.has_value() ? mIdleTimerCallbacks->kernel
490 : mIdleTimerCallbacks->platform;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800491 }
492
Ady Abraham68636062022-11-16 17:07:25 -0800493 bool isNativeRefreshRate(Fps fps) const REQUIRES(mLock) {
494 LOG_ALWAYS_FATAL_IF(mConfig.enableFrameRateOverride !=
495 Config::FrameRateOverride::AppOverrideNativeRefreshRates,
496 "should only be called when "
497 "Config::FrameRateOverride::AppOverrideNativeRefreshRates is used");
498 return mAppOverrideNativeRefreshRates.contains(fps);
499 }
500
501 std::vector<FrameRateMode> createFrameRateModes(
Ady Abraham90f7fd22023-08-16 11:02:00 -0700502 const Policy&, std::function<bool(const DisplayMode&)>&& filterModes,
503 const FpsRange&) const REQUIRES(mLock);
Ady Abraham68636062022-11-16 17:07:25 -0800504
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800505 // The display modes of the active display. The DisplayModeIterators below are pointers into
506 // this container, so must be invalidated whenever the DisplayModes change. The Policy below
507 // is also dependent, so must be reset as well.
508 DisplayModes mDisplayModes GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800509
Ady Abraham68636062022-11-16 17:07:25 -0800510 // Set of supported display refresh rates for easy lookup
511 // when FrameRateOverride::AppOverrideNativeRefreshRates is in use.
512 ftl::SmallMap<Fps, ftl::Unit, 8, FpsApproxEqual> mAppOverrideNativeRefreshRates;
513
Ady Abrahamace3d052022-11-17 16:25:05 -0800514 ftl::Optional<FrameRateMode> mActiveModeOpt GUARDED_BY(mLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700515
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800516 DisplayModeIterator mMinRefreshRateModeIt GUARDED_BY(mLock);
517 DisplayModeIterator mMaxRefreshRateModeIt GUARDED_BY(mLock);
Steven Thomasf734df42020-04-13 21:09:28 -0700518
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800519 // Display modes that satisfy the Policy's ranges, filtered and sorted by refresh rate.
Ady Abraham68636062022-11-16 17:07:25 -0800520 std::vector<FrameRateMode> mPrimaryFrameRates GUARDED_BY(mLock);
521 std::vector<FrameRateMode> mAppRequestFrameRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800522
Rachel Lee45681982024-03-14 18:40:15 -0700523 // Caches whether the device is VRR-compatible based on the active display mode.
524 bool mIsVrrDevice GUARDED_BY(mLock) = false;
525
Steven Thomasd4071902020-03-24 16:02:53 -0700526 Policy mDisplayManagerPolicy GUARDED_BY(mLock);
527 std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800528
Dominik Laskowski36dced82022-09-02 09:24:00 -0700529 unsigned mNumModeSwitchesInPolicy GUARDED_BY(kMainThreadContext) = 0;
530
Ady Abraham2139f732019-11-13 18:56:40 -0800531 mutable std::mutex mLock;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700532
533 // A sorted list of known frame rates that a Heuristic layer will choose
534 // from based on the closest value.
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100535 const std::vector<Fps> mKnownFrameRates;
Ady Abraham64c2fc02020-12-29 12:07:50 -0800536
rnlee3bd610662021-06-23 16:27:57 -0700537 const Config mConfig;
Ady Abrahambd44e8a2023-07-24 11:30:06 -0700538
539 // A list of known frame rates that favors at least 60Hz if there is no exact match display
540 // refresh rate
541 const std::vector<Fps> mFrameRatesThatFavorsAtLeast60 = {23.976_Hz, 25_Hz, 29.97_Hz, 50_Hz,
542 59.94_Hz};
543
Ady Abraham8ca643a2022-10-18 18:26:47 -0700544 Config::FrameRateOverride mFrameRateOverrideConfig;
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200545
Ady Abraham68636062022-11-16 17:07:25 -0800546 struct GetRankedFrameRatesCache {
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500547 std::vector<LayerRequirement> layers;
548 GlobalSignals signals;
549 Fps pacesetterFps;
550
Ady Abraham68636062022-11-16 17:07:25 -0800551 RankedFrameRates result;
Dominik Laskowski9e88d622024-03-06 17:42:39 -0500552
553 bool matches(const GetRankedFrameRatesCache& other) const {
554 return layers == other.layers && signals == other.signals &&
555 isApproxEqual(pacesetterFps, other.pacesetterFps);
556 }
Marin Shalamanov4c7831e2021-06-08 20:44:06 +0200557 };
Ady Abraham68636062022-11-16 17:07:25 -0800558 mutable std::optional<GetRankedFrameRatesCache> mGetRankedFrameRatesCache GUARDED_BY(mLock);
Ady Abraham9a2ea342021-09-03 17:32:34 -0700559
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800560 // Declare mIdleTimer last to ensure its thread joins before the mutex/callbacks are destroyed.
Ady Abraham9a2ea342021-09-03 17:32:34 -0700561 std::mutex mIdleTimerCallbacksMutex;
562 std::optional<IdleTimerCallbacks> mIdleTimerCallbacks GUARDED_BY(mIdleTimerCallbacksMutex);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800563 // Used to detect (lack of) frame activity.
Dominik Laskowski03cfce82022-11-02 12:13:29 -0400564 ftl::Optional<scheduler::OneShotTimer> mIdleTimer;
Ana Krulecb43429d2019-01-09 14:28:51 -0800565};
566
Dominik Laskowski98041832019-08-01 18:35:59 -0700567} // namespace android::scheduler