blob: eed8486c1c83ac4feb3de08c179118cc8849ec2f [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 <android-base/stringprintf.h>
20
Ana Krulecb43429d2019-01-09 14:28:51 -080021#include <algorithm>
22#include <numeric>
Steven Thomasd4071902020-03-24 16:02:53 -070023#include <optional>
Dominik Laskowski98041832019-08-01 18:35:59 -070024#include <type_traits>
Ana Krulecb43429d2019-01-09 14:28:51 -080025
Ana Krulec4593b692019-01-11 22:07:25 -080026#include "DisplayHardware/HWComposer.h"
Ady Abraham2139f732019-11-13 18:56:40 -080027#include "HwcStrongTypes.h"
Ana Krulec4593b692019-01-11 22:07:25 -080028#include "Scheduler/SchedulerUtils.h"
Ady Abraham2139f732019-11-13 18:56:40 -080029#include "Scheduler/StrongTyping.h"
Ana Krulec4593b692019-01-11 22:07:25 -080030
Dominik Laskowski98041832019-08-01 18:35:59 -070031namespace android::scheduler {
Ady Abrahamabc27602020-04-08 17:20:29 -070032
Ady Abraham4ccdcb42020-02-11 17:34:34 -080033using namespace std::chrono_literals;
Dominik Laskowski98041832019-08-01 18:35:59 -070034
35enum class RefreshRateConfigEvent : unsigned { None = 0b0, Changed = 0b1 };
36
37inline RefreshRateConfigEvent operator|(RefreshRateConfigEvent lhs, RefreshRateConfigEvent rhs) {
38 using T = std::underlying_type_t<RefreshRateConfigEvent>;
39 return static_cast<RefreshRateConfigEvent>(static_cast<T>(lhs) | static_cast<T>(rhs));
40}
Ana Krulecb43429d2019-01-09 14:28:51 -080041
42/**
Ady Abraham1902d072019-03-01 17:18:59 -080043 * This class is used to encapsulate configuration for refresh rates. It holds information
Ana Krulecb43429d2019-01-09 14:28:51 -080044 * about available refresh rates on the device, and the mapping between the numbers and human
45 * readable names.
46 */
47class RefreshRateConfigs {
48public:
Ady Abraham4ccdcb42020-02-11 17:34:34 -080049 // Margin used when matching refresh rates to the content desired ones.
50 static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =
51 std::chrono::nanoseconds(800us).count();
52
Ady Abrahamabc27602020-04-08 17:20:29 -070053 class RefreshRate {
54 private:
55 // Effectively making the constructor private while allowing
56 // std::make_unique to create the object
57 struct ConstructorTag {
58 explicit ConstructorTag(int) {}
59 };
Ana Krulec72f0d6e2020-01-06 15:24:47 -080060
Ady Abrahamabc27602020-04-08 17:20:29 -070061 public:
62 RefreshRate(HwcConfigIndexType configId,
63 std::shared_ptr<const HWC2::Display::Config> config, std::string name,
64 float fps, ConstructorTag)
65 : configId(configId), hwcConfig(config), name(std::move(name)), fps(fps) {}
Ady Abraham2e1dd892020-03-05 13:48:36 -080066
67 RefreshRate(const RefreshRate&) = delete;
Ady Abrahamabc27602020-04-08 17:20:29 -070068
69 HwcConfigIndexType getConfigId() const { return configId; }
70 nsecs_t getVsyncPeriod() const { return hwcConfig->getVsyncPeriod(); }
71 int32_t getConfigGroup() const { return hwcConfig->getConfigGroup(); }
72 const std::string& getName() const { return name; }
73 float getFps() const { return fps; }
Ady Abraham2139f732019-11-13 18:56:40 -080074
Ana Krulec72f0d6e2020-01-06 15:24:47 -080075 // Checks whether the fps of this RefreshRate struct is within a given min and max refresh
76 // rate passed in. FPS_EPSILON is applied to the boundaries for approximation.
77 bool inPolicy(float minRefreshRate, float maxRefreshRate) const {
78 return (fps >= (minRefreshRate - FPS_EPSILON) && fps <= (maxRefreshRate + FPS_EPSILON));
79 }
80
Ady Abraham2139f732019-11-13 18:56:40 -080081 bool operator!=(const RefreshRate& other) const {
Ady Abrahamabc27602020-04-08 17:20:29 -070082 return configId != other.configId || hwcConfig != other.hwcConfig;
Ady Abraham2139f732019-11-13 18:56:40 -080083 }
84
Ana Krulecb9afd792020-06-11 13:16:15 -070085 bool operator<(const RefreshRate& other) const { return getFps() < other.getFps(); }
86
Ady Abraham2139f732019-11-13 18:56:40 -080087 bool operator==(const RefreshRate& other) const { return !(*this != other); }
Ady Abrahamabc27602020-04-08 17:20:29 -070088
89 private:
90 friend RefreshRateConfigs;
Ady Abrahamb1b9d412020-06-01 19:53:52 -070091 friend class RefreshRateConfigsTest;
Ady Abrahamabc27602020-04-08 17:20:29 -070092
93 // The tolerance within which we consider FPS approximately equals.
94 static constexpr float FPS_EPSILON = 0.001f;
95
96 // This config ID corresponds to the position of the config in the vector that is stored
97 // on the device.
98 const HwcConfigIndexType configId;
99 // The config itself
100 std::shared_ptr<const HWC2::Display::Config> hwcConfig;
101 // Human readable name of the refresh rate.
102 const std::string name;
103 // Refresh rate in frames per second
104 const float fps = 0;
Ana Krulecb43429d2019-01-09 14:28:51 -0800105 };
106
Ady Abraham2e1dd892020-03-05 13:48:36 -0800107 using AllRefreshRatesMapType =
108 std::unordered_map<HwcConfigIndexType, std::unique_ptr<const RefreshRate>>;
Ady Abraham2139f732019-11-13 18:56:40 -0800109
Steven Thomasd4071902020-03-24 16:02:53 -0700110 struct Policy {
Steven Thomasf734df42020-04-13 21:09:28 -0700111 struct Range {
112 float min = 0;
113 float max = std::numeric_limits<float>::max();
114
115 bool operator==(const Range& other) const {
116 return min == other.min && max == other.max;
117 }
118
119 bool operator!=(const Range& other) const { return !(*this == other); }
120 };
121
Steven Thomasd4071902020-03-24 16:02:53 -0700122 // The default config, used to ensure we only initiate display config switches within the
123 // same config group as defaultConfigId's group.
124 HwcConfigIndexType defaultConfig;
Steven Thomasf734df42020-04-13 21:09:28 -0700125 // The primary refresh rate range represents display manager's general guidance on the
126 // display configs we'll consider when switching refresh rates. Unless we get an explicit
127 // signal from an app, we should stay within this range.
128 Range primaryRange;
129 // The app request refresh rate range allows us to consider more display configs when
130 // switching refresh rates. Although we should generally stay within the primary range,
131 // specific considerations, such as layer frame rate settings specified via the
132 // setFrameRate() api, may cause us to go outside the primary range. We never go outside the
133 // app request range. The app request range will be greater than or equal to the primary
134 // refresh rate range, never smaller.
135 Range appRequestRange;
Steven Thomasd4071902020-03-24 16:02:53 -0700136 // Whether or not we switch config groups to get the best frame rate. Only used by tests.
137 bool allowGroupSwitching = false;
138
Steven Thomasf734df42020-04-13 21:09:28 -0700139 Policy() = default;
140 Policy(HwcConfigIndexType defaultConfig, const Range& range)
141 : Policy(defaultConfig, range, range) {}
142 Policy(HwcConfigIndexType defaultConfig, const Range& primaryRange,
143 const Range& appRequestRange)
144 : defaultConfig(defaultConfig),
145 primaryRange(primaryRange),
146 appRequestRange(appRequestRange) {}
147
Steven Thomasd4071902020-03-24 16:02:53 -0700148 bool operator==(const Policy& other) const {
Steven Thomasf734df42020-04-13 21:09:28 -0700149 return defaultConfig == other.defaultConfig && primaryRange == other.primaryRange &&
150 appRequestRange == other.appRequestRange &&
Steven Thomasd4071902020-03-24 16:02:53 -0700151 allowGroupSwitching == other.allowGroupSwitching;
152 }
153
154 bool operator!=(const Policy& other) const { return !(*this == other); }
155 };
156
157 // Return code set*Policy() to indicate the current policy is unchanged.
158 static constexpr int CURRENT_POLICY_UNCHANGED = 1;
159
160 // We maintain the display manager policy and the override policy separately. The override
161 // policy is used by CTS tests to get a consistent device state for testing. While the override
162 // policy is set, it takes precedence over the display manager policy. Once the override policy
163 // is cleared, we revert to using the display manager policy.
164
165 // Sets the display manager policy to choose refresh rates. The return value will be:
166 // - A negative value if the policy is invalid or another error occurred.
167 // - NO_ERROR if the policy was successfully updated, and the current policy is different from
168 // what it was before the call.
169 // - CURRENT_POLICY_UNCHANGED if the policy was successfully updated, but the current policy
170 // is the same as it was before the call.
171 status_t setDisplayManagerPolicy(const Policy& policy) EXCLUDES(mLock);
172 // Sets the override policy. See setDisplayManagerPolicy() for the meaning of the return value.
173 status_t setOverridePolicy(const std::optional<Policy>& policy) EXCLUDES(mLock);
174 // Gets the current policy, which will be the override policy if active, and the display manager
175 // policy otherwise.
176 Policy getCurrentPolicy() const EXCLUDES(mLock);
177 // Gets the display manager policy, regardless of whether an override policy is active.
178 Policy getDisplayManagerPolicy() const EXCLUDES(mLock);
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100179
180 // Returns true if config is allowed by the current policy.
181 bool isConfigAllowed(HwcConfigIndexType config) const EXCLUDES(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800182
Ady Abraham8a82ba62020-01-17 12:43:17 -0800183 // Describes the different options the layer voted for refresh rate
184 enum class LayerVoteType {
Ady Abraham71c437d2020-01-31 15:56:57 -0800185 NoVote, // Doesn't care about the refresh rate
186 Min, // Minimal refresh rate available
187 Max, // Maximal refresh rate available
188 Heuristic, // Specific refresh rate that was calculated by platform using a heuristic
189 ExplicitDefault, // Specific refresh rate that was provided by the app with Default
190 // compatibility
191 ExplicitExactOrMultiple // Specific refresh rate that was provided by the app with
192 // ExactOrMultiple compatibility
Ady Abraham8a82ba62020-01-17 12:43:17 -0800193 };
194
195 // Captures the layer requirements for a refresh rate. This will be used to determine the
196 // display refresh rate.
197 struct LayerRequirement {
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700198 // Layer's name. Used for debugging purposes.
199 std::string name;
200 // Layer vote type.
201 LayerVoteType vote = LayerVoteType::NoVote;
202 // Layer's desired refresh rate, if applicable.
203 float desiredRefreshRate = 0.0f;
204 // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
205 // would have on choosing the refresh rate.
206 float weight = 0.0f;
207 // Whether layer is in focus or not based on WindowManager's state
208 bool focused = false;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800209
210 bool operator==(const LayerRequirement& other) const {
211 return name == other.name && vote == other.vote &&
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700212 desiredRefreshRate == other.desiredRefreshRate && weight == other.weight &&
213 focused == other.focused;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800214 }
215
216 bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
217 };
218
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800219 // Returns the refresh rate that fits best to the given layers.
Ady Abraham8a82ba62020-01-17 12:43:17 -0800220 const RefreshRate& getRefreshRateForContent(const std::vector<LayerRequirement>& layers) const
221 EXCLUDES(mLock);
222
Ady Abrahamdfd62162020-06-10 16:11:56 -0700223 // Global state describing signals that affect refresh rate choice.
224 struct GlobalSignals {
225 // Whether the user touched the screen recently. Used to apply touch boost.
226 bool touch = false;
227 // True if the system hasn't seen any buffers posted to layers recently.
228 bool idle = false;
229 };
230
Steven Thomasbb374322020-04-28 22:47:16 -0700231 // Returns the refresh rate that fits best to the given layers.
232 // layers - The layer requirements to consider.
Ady Abrahamdfd62162020-06-10 16:11:56 -0700233 // globalSignals - global state of touch and idle
234 // outSignalsConsidered - An output param that tells the caller whether the refresh rate was
235 // chosen based on touch boost and/or idle timer.
Steven Thomasbb374322020-04-28 22:47:16 -0700236 const RefreshRate& getBestRefreshRate(const std::vector<LayerRequirement>& layers,
Ady Abrahamdfd62162020-06-10 16:11:56 -0700237 const GlobalSignals& globalSignals,
238 GlobalSignals* outSignalsConsidered = nullptr) const
Ady Abraham6fb599b2020-03-05 13:48:22 -0800239 EXCLUDES(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800240
Ady Abraham2139f732019-11-13 18:56:40 -0800241 // Returns all the refresh rates supported by the device. This won't change at runtime.
242 const AllRefreshRatesMapType& getAllRefreshRates() const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700243
Ady Abraham2139f732019-11-13 18:56:40 -0800244 // Returns the lowest refresh rate supported by the device. This won't change at runtime.
245 const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700246
Steven Thomasf734df42020-04-13 21:09:28 -0700247 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
248 // uses the primary range, not the app request range.
Ady Abraham2139f732019-11-13 18:56:40 -0800249 const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700250
Ady Abraham2139f732019-11-13 18:56:40 -0800251 // Returns the highest refresh rate supported by the device. This won't change at runtime.
252 const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700253
Steven Thomasf734df42020-04-13 21:09:28 -0700254 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
255 // uses the primary range, not the app request range.
Ady Abraham2139f732019-11-13 18:56:40 -0800256 const RefreshRate& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);
257
258 // Returns the current refresh rate
259 const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);
260
Ana Krulec5d477912020-02-07 12:02:38 -0800261 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
262 // the policy.
263 const RefreshRate& getCurrentRefreshRateByPolicy() const;
264
Ady Abraham2139f732019-11-13 18:56:40 -0800265 // Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
266 // runtime.
267 const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
Ady Abraham2e1dd892020-03-05 13:48:36 -0800268 return *mRefreshRates.at(configId);
Ady Abraham2139f732019-11-13 18:56:40 -0800269 };
270
271 // Stores the current configId the device operates at
272 void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700273
Ady Abrahama6b676e2020-05-27 14:29:09 -0700274 // Returns a string that represents the layer vote type
275 static std::string layerVoteTypeString(LayerVoteType vote);
276
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700277 // Returns a known frame rate that is the closest to frameRate
278 float findClosestKnownFrameRate(float frameRate) const;
279
Ana Krulec3f6a2062020-01-23 15:48:01 -0800280 RefreshRateConfigs(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
Ady Abraham2139f732019-11-13 18:56:40 -0800281 HwcConfigIndexType currentConfigId);
Ana Krulec4593b692019-01-11 22:07:25 -0800282
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700283 // Returns whether switching configs (refresh rate or resolution) is possible.
284 // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the configs only
285 // differ in resolution.
286 bool canSwitch() const { return mRefreshRates.size() > 1; }
287
Ana Krulecb9afd792020-06-11 13:16:15 -0700288 // Class to enumerate options around toggling the kernel timer on and off. We have an option
289 // for no change to avoid extra calls to kernel.
290 enum class KernelIdleTimerAction {
291 NoChange, // Do not change the idle timer.
292 TurnOff, // Turn off the idle timer.
293 TurnOn // Turn on the idle timer.
294 };
295 // Checks whether kernel idle timer should be active depending the policy decisions around
296 // refresh rates.
297 KernelIdleTimerAction getIdleTimerAction() const;
298
Dominik Laskowski22488f62019-03-28 09:53:04 -0700299private:
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700300 friend class RefreshRateConfigsTest;
301
Ady Abraham2139f732019-11-13 18:56:40 -0800302 void constructAvailableRefreshRates() REQUIRES(mLock);
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700303 static std::vector<float> constructKnownFrameRates(
304 const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs);
Ady Abraham2139f732019-11-13 18:56:40 -0800305
306 void getSortedRefreshRateList(
307 const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
308 std::vector<const RefreshRate*>* outRefreshRates);
309
Ady Abraham34702102020-02-10 14:12:05 -0800310 // Returns the refresh rate with the highest score in the collection specified from begin
311 // to end. If there are more than one with the same highest refresh rate, the first one is
312 // returned.
313 template <typename Iter>
314 const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;
315
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800316 // Returns number of display frames and remainder when dividing the layer refresh period by
317 // display refresh period.
318 std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;
319
Steven Thomasf734df42020-04-13 21:09:28 -0700320 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
321 // uses the primary range, not the app request range.
322 const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);
323
324 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
325 // uses the primary range, not the app request range.
326 const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);
327
Ana Krulec3d367c82020-02-25 15:02:01 -0800328 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
329 // the policy.
330 const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);
331
Steven Thomasd4071902020-03-24 16:02:53 -0700332 const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
333 bool isPolicyValid(const Policy& policy);
334
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700335 // The list of refresh rates, indexed by display config ID. This must not change after this
336 // object is initialized.
Ady Abraham2139f732019-11-13 18:56:40 -0800337 AllRefreshRatesMapType mRefreshRates;
338
Steven Thomasf734df42020-04-13 21:09:28 -0700339 // The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
340 // (the first element is the lowest refresh rate).
341 std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);
342
343 // The list of refresh rates in the app request range of the current policy, ordered by
344 // vsyncPeriod (the first element is the lowest refresh rate).
345 std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800346
347 // The current config. This will change at runtime. This is set by SurfaceFlinger on
348 // the main thread, and read by the Scheduler (and other objects) on other threads.
349 const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);
350
Steven Thomasd4071902020-03-24 16:02:53 -0700351 // The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
352 // and read by the Scheduler (and other objects) on other threads.
353 Policy mDisplayManagerPolicy GUARDED_BY(mLock);
354 std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800355
356 // The min and max refresh rates supported by the device.
357 // This will not change at runtime.
358 const RefreshRate* mMinSupportedRefreshRate;
359 const RefreshRate* mMaxSupportedRefreshRate;
360
Ady Abraham2139f732019-11-13 18:56:40 -0800361 mutable std::mutex mLock;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700362
363 // A sorted list of known frame rates that a Heuristic layer will choose
364 // from based on the closest value.
365 const std::vector<float> mKnownFrameRates;
Ana Krulecb43429d2019-01-09 14:28:51 -0800366};
367
Dominik Laskowski98041832019-08-01 18:35:59 -0700368} // namespace android::scheduler