blob: 5d00a26031877fc798c1fdaf221e7c42cc4aa1b6 [file] [log] [blame]
Ady Abraham8a82ba62020-01-17 12:43:17 -08001/*
2 * Copyright 2020 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#undef LOG_TAG
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010018#define LOG_TAG "LayerHistory"
Ady Abraham8a82ba62020-01-17 12:43:17 -080019#define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
21#include "LayerHistory.h"
22
Dominik Laskowski983f2b52020-06-25 16:54:06 -070023#include <android-base/stringprintf.h>
Ady Abraham8a82ba62020-01-17 12:43:17 -080024#include <cutils/properties.h>
Ady Abraham73c3df52023-01-12 18:09:31 -080025#include <gui/TraceUtils.h>
Ady Abraham8a82ba62020-01-17 12:43:17 -080026#include <utils/Log.h>
27#include <utils/Timers.h>
Ady Abraham8a82ba62020-01-17 12:43:17 -080028
29#include <algorithm>
30#include <cmath>
31#include <string>
32#include <utility>
33
34#include "../Layer.h"
Rachel Lee2248f522023-01-27 16:45:23 -080035#include "EventThread.h"
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010036#include "LayerInfo.h"
Ady Abraham8a82ba62020-01-17 12:43:17 -080037
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010038namespace android::scheduler {
Ady Abraham8a82ba62020-01-17 12:43:17 -080039
40namespace {
41
Ady Abrahambdda8f02021-04-01 16:06:11 -070042bool isLayerActive(const LayerInfo& info, nsecs_t threshold) {
Ady Abraham89089c92020-04-15 18:24:41 -070043 // Layers with an explicit vote are always kept active
Ady Abrahambdda8f02021-04-01 16:06:11 -070044 if (info.getSetFrameRateVote().rate.isValid()) {
Ady Abraham89089c92020-04-15 18:24:41 -070045 return true;
Ady Abraham8a82ba62020-01-17 12:43:17 -080046 }
Ady Abraham89089c92020-04-15 18:24:41 -070047
Ady Abrahambdda8f02021-04-01 16:06:11 -070048 return info.isVisible() && info.getLastUpdatedTime() >= threshold;
Ady Abraham8a82ba62020-01-17 12:43:17 -080049}
50
51bool traceEnabled() {
52 return property_get_bool("debug.sf.layer_history_trace", false);
53}
54
55bool useFrameRatePriority() {
56 char value[PROPERTY_VALUE_MAX];
57 property_get("debug.sf.use_frame_rate_priority", value, "1");
58 return atoi(value);
59}
60
Ady Abrahambdda8f02021-04-01 16:06:11 -070061void trace(const LayerInfo& info, LayerHistory::LayerVoteType type, int fps) {
Ady Abraham0ccd79b2020-06-10 10:11:17 -070062 const auto traceType = [&](LayerHistory::LayerVoteType checkedType, int value) {
63 ATRACE_INT(info.getTraceTag(checkedType), type == checkedType ? value : 0);
Ady Abrahama6b676e2020-05-27 14:29:09 -070064 };
65
Ady Abraham0ccd79b2020-06-10 10:11:17 -070066 traceType(LayerHistory::LayerVoteType::NoVote, 1);
67 traceType(LayerHistory::LayerVoteType::Heuristic, fps);
68 traceType(LayerHistory::LayerVoteType::ExplicitDefault, fps);
69 traceType(LayerHistory::LayerVoteType::ExplicitExactOrMultiple, fps);
Ady Abrahamdd5bfa92021-01-07 17:56:08 -080070 traceType(LayerHistory::LayerVoteType::ExplicitExact, fps);
Ady Abraham0ccd79b2020-06-10 10:11:17 -070071 traceType(LayerHistory::LayerVoteType::Min, 1);
72 traceType(LayerHistory::LayerVoteType::Max, 1);
Ady Abraham8a82ba62020-01-17 12:43:17 -080073
Ady Abrahambdda8f02021-04-01 16:06:11 -070074 ALOGD("%s: %s @ %d Hz", __FUNCTION__, info.getName().c_str(), fps);
Ady Abraham8a82ba62020-01-17 12:43:17 -080075}
Andy Labrada096227e2022-06-15 16:58:11 +000076
77LayerHistory::LayerVoteType getVoteType(LayerInfo::FrameRateCompatibility compatibility,
78 bool contentDetectionEnabled) {
79 LayerHistory::LayerVoteType voteType;
80 if (!contentDetectionEnabled || compatibility == LayerInfo::FrameRateCompatibility::NoVote) {
81 voteType = LayerHistory::LayerVoteType::NoVote;
82 } else if (compatibility == LayerInfo::FrameRateCompatibility::Min) {
83 voteType = LayerHistory::LayerVoteType::Min;
84 } else {
85 voteType = LayerHistory::LayerVoteType::Heuristic;
86 }
87 return voteType;
88}
89
Ady Abraham8a82ba62020-01-17 12:43:17 -080090} // namespace
91
Ady Abraham3efa3942021-06-24 19:01:25 -070092LayerHistory::LayerHistory()
Ady Abrahamb1b9d412020-06-01 19:53:52 -070093 : mTraceEnabled(traceEnabled()), mUseFrameRatePriority(useFrameRatePriority()) {
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010094 LayerInfo::setTraceEnabled(mTraceEnabled);
Ady Abrahamb1b9d412020-06-01 19:53:52 -070095}
96
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +010097LayerHistory::~LayerHistory() = default;
Ady Abraham8a82ba62020-01-17 12:43:17 -080098
Andy Labrada096227e2022-06-15 16:58:11 +000099void LayerHistory::registerLayer(Layer* layer, bool contentDetectionEnabled) {
Ady Abraham8a82ba62020-01-17 12:43:17 -0800100 std::lock_guard lock(mLock);
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800101 LOG_ALWAYS_FATAL_IF(findLayer(layer->getSequence()).first != LayerStatus::NotFound,
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400102 "%s already registered", layer->getName().c_str());
Andy Labrada096227e2022-06-15 16:58:11 +0000103 LayerVoteType type =
104 getVoteType(layer->getDefaultFrameRateCompatibility(), contentDetectionEnabled);
Ady Abrahambe09aad2021-05-03 18:59:38 -0700105 auto info = std::make_unique<LayerInfo>(layer->getName(), layer->getOwnerUid(), type);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400106
107 // The layer can be placed on either map, it is assumed that partitionLayers() will be called
108 // to correct them.
109 mInactiveLayerInfos.insert({layer->getSequence(), std::make_pair(layer, std::move(info))});
Ady Abraham8a82ba62020-01-17 12:43:17 -0800110}
111
Ady Abrahambdda8f02021-04-01 16:06:11 -0700112void LayerHistory::deregisterLayer(Layer* layer) {
113 std::lock_guard lock(mLock);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400114 if (!mActiveLayerInfos.erase(layer->getSequence())) {
115 if (!mInactiveLayerInfos.erase(layer->getSequence())) {
116 LOG_ALWAYS_FATAL("%s: unknown layer %p", __FUNCTION__, layer);
117 }
Ady Abrahambdda8f02021-04-01 16:06:11 -0700118 }
Ady Abrahambdda8f02021-04-01 16:06:11 -0700119}
120
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000121void LayerHistory::record(int32_t id, const LayerProps& layerProps, nsecs_t presentTime,
122 nsecs_t now, LayerUpdateType updateType) {
Ady Abraham8a82ba62020-01-17 12:43:17 -0800123 std::lock_guard lock(mLock);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400124 auto [found, layerPair] = findLayer(id);
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800125 if (found == LayerStatus::NotFound) {
Ady Abrahambe09aad2021-05-03 18:59:38 -0700126 // Offscreen layer
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000127 ALOGV("%s: %d not registered", __func__, id);
Ady Abrahambe09aad2021-05-03 18:59:38 -0700128 return;
129 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800130
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400131 const auto& info = layerPair->second;
Ady Abrahambdda8f02021-04-01 16:06:11 -0700132 info->setLastPresentTime(presentTime, now, updateType, mModeChangePending, layerProps);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800133
134 // Activate layer if inactive.
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800135 if (found == LayerStatus::LayerInInactiveMap) {
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400136 mActiveLayerInfos.insert(
137 {id, std::make_pair(layerPair->first, std::move(layerPair->second))});
138 mInactiveLayerInfos.erase(id);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800139 }
140}
141
Andy Labrada096227e2022-06-15 16:58:11 +0000142void LayerHistory::setDefaultFrameRateCompatibility(Layer* layer, bool contentDetectionEnabled) {
143 std::lock_guard lock(mLock);
144 auto id = layer->getSequence();
145
146 auto [found, layerPair] = findLayer(id);
147 if (found == LayerStatus::NotFound) {
148 // Offscreen layer
149 ALOGV("%s: %s not registered", __func__, layer->getName().c_str());
150 return;
151 }
152
153 const auto& info = layerPair->second;
154 info->setDefaultLayerVote(
155 getVoteType(layer->getDefaultFrameRateCompatibility(), contentDetectionEnabled));
156}
157
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400158auto LayerHistory::summarize(const RefreshRateSelector& selector, nsecs_t now) -> Summary {
Ady Abraham73c3df52023-01-12 18:09:31 -0800159 ATRACE_CALL();
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800160 Summary summary;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800161
162 std::lock_guard lock(mLock);
163
164 partitionLayers(now);
165
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400166 for (const auto& [key, value] : mActiveLayerInfos) {
167 auto& info = value.second;
Ady Abrahambdda8f02021-04-01 16:06:11 -0700168 const auto frameRateSelectionPriority = info->getFrameRateSelectionPriority();
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700169 const auto layerFocused = Layer::isLayerFocusedBasedOnPriority(frameRateSelectionPriority);
Ady Abrahambdda8f02021-04-01 16:06:11 -0700170 ALOGV("%s has priority: %d %s focused", info->getName().c_str(), frameRateSelectionPriority,
171 layerFocused ? "" : "not");
Ana Krulec3803b8d2020-02-03 16:35:46 -0800172
Ady Abraham73c3df52023-01-12 18:09:31 -0800173 ATRACE_FORMAT("%s", info->getName().c_str());
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400174 const auto vote = info->getRefreshRateVote(selector, now);
Ady Abraham89089c92020-04-15 18:24:41 -0700175 // Skip NoVote layer as those don't have any requirements
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800176 if (vote.type == LayerVoteType::NoVote) {
Ady Abraham89089c92020-04-15 18:24:41 -0700177 continue;
178 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800179
Ady Abraham89089c92020-04-15 18:24:41 -0700180 // Compute the layer's position on the screen
Ady Abrahambdda8f02021-04-01 16:06:11 -0700181 const Rect bounds = Rect(info->getBounds());
182 const ui::Transform transform = info->getTransform();
Ady Abraham89089c92020-04-15 18:24:41 -0700183 constexpr bool roundOutwards = true;
184 Rect transformed = transform.transform(bounds, roundOutwards);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800185
Ady Abraham89089c92020-04-15 18:24:41 -0700186 const float layerArea = transformed.getWidth() * transformed.getHeight();
187 float weight = mDisplayArea ? layerArea / mDisplayArea : 0.0f;
Ady Abraham73c3df52023-01-12 18:09:31 -0800188 ATRACE_FORMAT_INSTANT("%s %s (%d%)", ftl::enum_string(vote.type).c_str(),
189 to_string(vote.fps).c_str(), weight * 100);
Ady Abrahambdda8f02021-04-01 16:06:11 -0700190 summary.push_back({info->getName(), info->getOwnerUid(), vote.type, vote.fps,
Ady Abraham62a0be22020-12-08 16:54:10 -0800191 vote.seamlessness, weight, layerFocused});
Ady Abraham8a82ba62020-01-17 12:43:17 -0800192
Ady Abraham89089c92020-04-15 18:24:41 -0700193 if (CC_UNLIKELY(mTraceEnabled)) {
Ady Abrahambdda8f02021-04-01 16:06:11 -0700194 trace(*info, vote.type, vote.fps.getIntValue());
Ady Abraham8a82ba62020-01-17 12:43:17 -0800195 }
196 }
197
198 return summary;
199}
200
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100201void LayerHistory::partitionLayers(nsecs_t now) {
Ady Abraham73c3df52023-01-12 18:09:31 -0800202 ATRACE_CALL();
Ady Abraham8a82ba62020-01-17 12:43:17 -0800203 const nsecs_t threshold = getActiveLayerThreshold(now);
204
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400205 // iterate over inactive map
206 LayerInfos::iterator it = mInactiveLayerInfos.begin();
207 while (it != mInactiveLayerInfos.end()) {
208 auto& [layerUnsafe, info] = it->second;
Ady Abrahambdda8f02021-04-01 16:06:11 -0700209 if (isLayerActive(*info, threshold)) {
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400210 // move this to the active map
211
212 mActiveLayerInfos.insert({it->first, std::move(it->second)});
213 it = mInactiveLayerInfos.erase(it);
214 } else {
215 if (CC_UNLIKELY(mTraceEnabled)) {
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800216 trace(*info, LayerVoteType::NoVote, 0);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400217 }
218 info->onLayerInactive(now);
219 it++;
220 }
221 }
222
223 // iterate over active map
224 it = mActiveLayerInfos.begin();
225 while (it != mActiveLayerInfos.end()) {
226 auto& [layerUnsafe, info] = it->second;
227 if (isLayerActive(*info, threshold)) {
Ady Abraham8a82ba62020-01-17 12:43:17 -0800228 // Set layer vote if set
Ady Abrahambdda8f02021-04-01 16:06:11 -0700229 const auto frameRate = info->getSetFrameRateVote();
Ady Abraham71c437d2020-01-31 15:56:57 -0800230 const auto voteType = [&]() {
231 switch (frameRate.type) {
232 case Layer::FrameRateCompatibility::Default:
233 return LayerVoteType::ExplicitDefault;
Andy Labrada096227e2022-06-15 16:58:11 +0000234 case Layer::FrameRateCompatibility::Min:
235 return LayerVoteType::Min;
Ady Abraham71c437d2020-01-31 15:56:57 -0800236 case Layer::FrameRateCompatibility::ExactOrMultiple:
237 return LayerVoteType::ExplicitExactOrMultiple;
238 case Layer::FrameRateCompatibility::NoVote:
239 return LayerVoteType::NoVote;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800240 case Layer::FrameRateCompatibility::Exact:
241 return LayerVoteType::ExplicitExact;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800242 }
Ady Abraham71c437d2020-01-31 15:56:57 -0800243 }();
Ady Abraham5dde5972020-05-13 10:50:54 -0700244
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100245 if (frameRate.rate.isValid() || voteType == LayerVoteType::NoVote) {
Ady Abrahambdda8f02021-04-01 16:06:11 -0700246 const auto type = info->isVisible() ? voteType : LayerVoteType::NoVote;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100247 info->setLayerVote({type, frameRate.rate, frameRate.seamlessness});
Ady Abraham8a82ba62020-01-17 12:43:17 -0800248 } else {
249 info->resetLayerVote();
250 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800251
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400252 it++;
253 } else {
254 if (CC_UNLIKELY(mTraceEnabled)) {
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800255 trace(*info, LayerVoteType::NoVote, 0);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400256 }
257 info->onLayerInactive(now);
258 // move this to the inactive map
259 mInactiveLayerInfos.insert({it->first, std::move(it->second)});
260 it = mActiveLayerInfos.erase(it);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800261 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800262 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800263}
264
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100265void LayerHistory::clear() {
Ady Abraham8a82ba62020-01-17 12:43:17 -0800266 std::lock_guard lock(mLock);
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400267 for (const auto& [key, value] : mActiveLayerInfos) {
268 value.second->clearHistory(systemTime());
Ady Abraham8a82ba62020-01-17 12:43:17 -0800269 }
Ady Abraham8a82ba62020-01-17 12:43:17 -0800270}
Ady Abraham0ccd79b2020-06-10 10:11:17 -0700271
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100272std::string LayerHistory::dump() const {
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700273 std::lock_guard lock(mLock);
Dominik Laskowski03cfce82022-11-02 12:13:29 -0400274 return base::StringPrintf("{size=%zu, active=%zu}",
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400275 mActiveLayerInfos.size() + mInactiveLayerInfos.size(),
276 mActiveLayerInfos.size());
277}
278
279float LayerHistory::getLayerFramerate(nsecs_t now, int32_t id) const {
280 std::lock_guard lock(mLock);
281 auto [found, layerPair] = findLayer(id);
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800282 if (found != LayerStatus::NotFound) {
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400283 return layerPair->second->getFps(now).getValue();
284 }
285 return 0.f;
286}
287
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800288auto LayerHistory::findLayer(int32_t id) -> std::pair<LayerStatus, LayerPair*> {
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400289 // the layer could be in either the active or inactive map, try both
290 auto it = mActiveLayerInfos.find(id);
291 if (it != mActiveLayerInfos.end()) {
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800292 return {LayerStatus::LayerInActiveMap, &(it->second)};
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400293 }
294 it = mInactiveLayerInfos.find(id);
295 if (it != mInactiveLayerInfos.end()) {
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800296 return {LayerStatus::LayerInInactiveMap, &(it->second)};
Nathaniel Nifong1303d912021-10-06 09:41:24 -0400297 }
Dominik Laskowski0c41ffa2021-12-24 16:45:12 -0800298 return {LayerStatus::NotFound, nullptr};
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700299}
300
Marin Shalamanov1bc43ee2020-11-20 16:56:52 +0100301} // namespace android::scheduler