blob: 8a51b852073195b26b33811c5b6d1124e8c0f3c6 [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 {
198 std::string name; // Layer's name. Used for debugging purposes.
199 LayerVoteType vote; // Layer vote type.
200 float desiredRefreshRate; // Layer's desired refresh rate, if applicable.
201 float weight; // Layer's weight in the range of [0, 1]. The higher the weight the more
202 // impact this layer would have on choosing the refresh rate.
203
204 bool operator==(const LayerRequirement& other) const {
205 return name == other.name && vote == other.vote &&
206 desiredRefreshRate == other.desiredRefreshRate && weight == other.weight;
207 }
208
209 bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
210 };
211
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800212 // Returns the refresh rate that fits best to the given layers.
Ady Abraham8a82ba62020-01-17 12:43:17 -0800213 const RefreshRate& getRefreshRateForContent(const std::vector<LayerRequirement>& layers) const
214 EXCLUDES(mLock);
215
Ady Abrahamdfd62162020-06-10 16:11:56 -0700216 // Global state describing signals that affect refresh rate choice.
217 struct GlobalSignals {
218 // Whether the user touched the screen recently. Used to apply touch boost.
219 bool touch = false;
220 // True if the system hasn't seen any buffers posted to layers recently.
221 bool idle = false;
222 };
223
Steven Thomasbb374322020-04-28 22:47:16 -0700224 // Returns the refresh rate that fits best to the given layers.
225 // layers - The layer requirements to consider.
Ady Abrahamdfd62162020-06-10 16:11:56 -0700226 // globalSignals - global state of touch and idle
227 // outSignalsConsidered - An output param that tells the caller whether the refresh rate was
228 // chosen based on touch boost and/or idle timer.
Steven Thomasbb374322020-04-28 22:47:16 -0700229 const RefreshRate& getBestRefreshRate(const std::vector<LayerRequirement>& layers,
Ady Abrahamdfd62162020-06-10 16:11:56 -0700230 const GlobalSignals& globalSignals,
231 GlobalSignals* outSignalsConsidered = nullptr) const
Ady Abraham6fb599b2020-03-05 13:48:22 -0800232 EXCLUDES(mLock);
Ana Krulecb43429d2019-01-09 14:28:51 -0800233
Ady Abraham2139f732019-11-13 18:56:40 -0800234 // Returns all the refresh rates supported by the device. This won't change at runtime.
235 const AllRefreshRatesMapType& getAllRefreshRates() const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700236
Ady Abraham2139f732019-11-13 18:56:40 -0800237 // Returns the lowest refresh rate supported by the device. This won't change at runtime.
238 const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700239
Steven Thomasf734df42020-04-13 21:09:28 -0700240 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
241 // uses the primary range, not the app request range.
Ady Abraham2139f732019-11-13 18:56:40 -0800242 const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700243
Ady Abraham2139f732019-11-13 18:56:40 -0800244 // Returns the highest refresh rate supported by the device. This won't change at runtime.
245 const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700246
Steven Thomasf734df42020-04-13 21:09:28 -0700247 // Returns the highest 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& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);
250
251 // Returns the current refresh rate
252 const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);
253
Ana Krulec5d477912020-02-07 12:02:38 -0800254 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
255 // the policy.
256 const RefreshRate& getCurrentRefreshRateByPolicy() const;
257
Ady Abraham2139f732019-11-13 18:56:40 -0800258 // Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
259 // runtime.
260 const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
Ady Abraham2e1dd892020-03-05 13:48:36 -0800261 return *mRefreshRates.at(configId);
Ady Abraham2139f732019-11-13 18:56:40 -0800262 };
263
264 // Stores the current configId the device operates at
265 void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);
Dominik Laskowski22488f62019-03-28 09:53:04 -0700266
Ady Abrahama6b676e2020-05-27 14:29:09 -0700267 // Returns a string that represents the layer vote type
268 static std::string layerVoteTypeString(LayerVoteType vote);
269
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700270 // Returns a known frame rate that is the closest to frameRate
271 float findClosestKnownFrameRate(float frameRate) const;
272
Ana Krulec3f6a2062020-01-23 15:48:01 -0800273 RefreshRateConfigs(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
Ady Abraham2139f732019-11-13 18:56:40 -0800274 HwcConfigIndexType currentConfigId);
Ana Krulec4593b692019-01-11 22:07:25 -0800275
Ana Krulecb9afd792020-06-11 13:16:15 -0700276 // Class to enumerate options around toggling the kernel timer on and off. We have an option
277 // for no change to avoid extra calls to kernel.
278 enum class KernelIdleTimerAction {
279 NoChange, // Do not change the idle timer.
280 TurnOff, // Turn off the idle timer.
281 TurnOn // Turn on the idle timer.
282 };
283 // Checks whether kernel idle timer should be active depending the policy decisions around
284 // refresh rates.
285 KernelIdleTimerAction getIdleTimerAction() const;
286
Dominik Laskowski22488f62019-03-28 09:53:04 -0700287private:
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700288 friend class RefreshRateConfigsTest;
289
Ady Abraham2139f732019-11-13 18:56:40 -0800290 void constructAvailableRefreshRates() REQUIRES(mLock);
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700291 static std::vector<float> constructKnownFrameRates(
292 const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs);
Ady Abraham2139f732019-11-13 18:56:40 -0800293
294 void getSortedRefreshRateList(
295 const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
296 std::vector<const RefreshRate*>* outRefreshRates);
297
Ady Abraham34702102020-02-10 14:12:05 -0800298 // Returns the refresh rate with the highest score in the collection specified from begin
299 // to end. If there are more than one with the same highest refresh rate, the first one is
300 // returned.
301 template <typename Iter>
302 const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;
303
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800304 // Returns number of display frames and remainder when dividing the layer refresh period by
305 // display refresh period.
306 std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;
307
Steven Thomasf734df42020-04-13 21:09:28 -0700308 // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
309 // uses the primary range, not the app request range.
310 const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);
311
312 // Returns the highest refresh rate according to the current policy. May change at runtime. Only
313 // uses the primary range, not the app request range.
314 const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);
315
Ana Krulec3d367c82020-02-25 15:02:01 -0800316 // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
317 // the policy.
318 const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);
319
Steven Thomasd4071902020-03-24 16:02:53 -0700320 const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
321 bool isPolicyValid(const Policy& policy);
322
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700323 // The list of refresh rates, indexed by display config ID. This must not change after this
324 // object is initialized.
Ady Abraham2139f732019-11-13 18:56:40 -0800325 AllRefreshRatesMapType mRefreshRates;
326
Steven Thomasf734df42020-04-13 21:09:28 -0700327 // The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
328 // (the first element is the lowest refresh rate).
329 std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);
330
331 // The list of refresh rates in the app request range of the current policy, ordered by
332 // vsyncPeriod (the first element is the lowest refresh rate).
333 std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800334
335 // The current config. This will change at runtime. This is set by SurfaceFlinger on
336 // the main thread, and read by the Scheduler (and other objects) on other threads.
337 const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);
338
Steven Thomasd4071902020-03-24 16:02:53 -0700339 // The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
340 // and read by the Scheduler (and other objects) on other threads.
341 Policy mDisplayManagerPolicy GUARDED_BY(mLock);
342 std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
Ady Abraham2139f732019-11-13 18:56:40 -0800343
344 // The min and max refresh rates supported by the device.
345 // This will not change at runtime.
346 const RefreshRate* mMinSupportedRefreshRate;
347 const RefreshRate* mMaxSupportedRefreshRate;
348
Ady Abraham2139f732019-11-13 18:56:40 -0800349 mutable std::mutex mLock;
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700350
351 // A sorted list of known frame rates that a Heuristic layer will choose
352 // from based on the closest value.
353 const std::vector<float> mKnownFrameRates;
Ana Krulecb43429d2019-01-09 14:28:51 -0800354};
355
Dominik Laskowski98041832019-08-01 18:35:59 -0700356} // namespace android::scheduler