blob: 96cf84c9455b3320c444869a2fcae8d0a9b49cd0 [file] [log] [blame]
Michael Wright1509a232018-06-21 02:50:34 +01001/*
2 * Copyright 2018 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
Dan Stoza030fbc12020-02-19 15:32:01 -080017//#define LOG_NDEBUG 0
18
Ady Abrahamabce1652022-02-24 10:51:19 -080019#define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
Michael Wright1509a232018-06-21 02:50:34 +010021#undef LOG_TAG
22#define LOG_TAG "PowerAdvisor"
23
Matt Buckley06f299a2021-09-24 19:43:51 +000024#include <unistd.h>
Michael Wright1509a232018-06-21 02:50:34 +010025#include <cinttypes>
Matt Buckley06f299a2021-09-24 19:43:51 +000026#include <cstdint>
27#include <optional>
Michael Wright1509a232018-06-21 02:50:34 +010028
Dan Stoza030fbc12020-02-19 15:32:01 -080029#include <android-base/properties.h>
Michael Wright1509a232018-06-21 02:50:34 +010030#include <utils/Log.h>
31#include <utils/Mutex.h>
Ady Abrahamabce1652022-02-24 10:51:19 -080032#include <utils/Trace.h>
Michael Wright1509a232018-06-21 02:50:34 +010033
Dan Stoza030fbc12020-02-19 15:32:01 -080034#include <binder/IServiceManager.h>
35
36#include "../SurfaceFlingerProperties.h"
37
Michael Wright1509a232018-06-21 02:50:34 +010038#include "PowerAdvisor.h"
Alec Mouridea1ac52021-06-23 18:12:18 -070039#include "SurfaceFlinger.h"
Michael Wright1509a232018-06-21 02:50:34 +010040
41namespace android {
42namespace Hwc2 {
43
44PowerAdvisor::~PowerAdvisor() = default;
45
46namespace impl {
47
Xiang Wang99f6f3c2023-05-22 13:12:16 -070048using aidl::android::hardware::power::Boost;
Xiang Wang99f6f3c2023-05-22 13:12:16 -070049using aidl::android::hardware::power::Mode;
50using aidl::android::hardware::power::SessionHint;
Matt Buckley52dfaad2024-03-07 20:20:07 +000051using aidl::android::hardware::power::SessionTag;
Xiang Wang99f6f3c2023-05-22 13:12:16 -070052using aidl::android::hardware::power::WorkDuration;
Matt Buckley06f299a2021-09-24 19:43:51 +000053
Michael Wright1509a232018-06-21 02:50:34 +010054PowerAdvisor::~PowerAdvisor() = default;
55
Dan Stoza030fbc12020-02-19 15:32:01 -080056namespace {
Alec Mouri29382ad2022-05-11 18:38:38 +000057std::chrono::milliseconds getUpdateTimeout() {
Dan Stoza030fbc12020-02-19 15:32:01 -080058 // Default to a timeout of 80ms if nothing else is specified
Alec Mouri29382ad2022-05-11 18:38:38 +000059 static std::chrono::milliseconds timeout =
60 std::chrono::milliseconds(sysprop::display_update_imminent_timeout_ms(80));
Dan Stoza030fbc12020-02-19 15:32:01 -080061 return timeout;
62}
63
Ady Abrahamabce1652022-02-24 10:51:19 -080064void traceExpensiveRendering(bool enabled) {
65 if (enabled) {
66 ATRACE_ASYNC_BEGIN("ExpensiveRendering", 0);
67 } else {
68 ATRACE_ASYNC_END("ExpensiveRendering", 0);
69 }
70}
71
Dan Stoza030fbc12020-02-19 15:32:01 -080072} // namespace
73
Matt Buckley0538cae2022-11-08 23:12:04 +000074PowerAdvisor::PowerAdvisor(SurfaceFlinger& flinger)
75 : mPowerHal(std::make_unique<power::PowerHalController>()), mFlinger(flinger) {
Alec Mouri29382ad2022-05-11 18:38:38 +000076 if (getUpdateTimeout() > 0ms) {
77 mScreenUpdateTimer.emplace("UpdateImminentTimer", getUpdateTimeout(),
Alec Mouric059dcf2022-05-05 23:40:07 +000078 /* resetCallback */ nullptr,
79 /* timeoutCallback */
80 [this] {
Alec Mouri29382ad2022-05-11 18:38:38 +000081 while (true) {
82 auto timeSinceLastUpdate = std::chrono::nanoseconds(
83 systemTime() - mLastScreenUpdatedTime.load());
84 if (timeSinceLastUpdate >= getUpdateTimeout()) {
85 break;
86 }
Alec Mouric059dcf2022-05-05 23:40:07 +000087 // We may try to disable expensive rendering and allow
88 // for sending DISPLAY_UPDATE_IMMINENT hints too early if
89 // we idled very shortly after updating the screen, so
90 // make sure we wait enough time.
Alec Mouri29382ad2022-05-11 18:38:38 +000091 std::this_thread::sleep_for(getUpdateTimeout() -
92 timeSinceLastUpdate);
Alec Mouric059dcf2022-05-05 23:40:07 +000093 }
94 mSendUpdateImminent.store(true);
95 mFlinger.disableExpensiveRendering();
96 });
97 }
98}
Alec Mouridea1ac52021-06-23 18:12:18 -070099
100void PowerAdvisor::init() {
101 // Defer starting the screen update timer until SurfaceFlinger finishes construction.
Alec Mouric059dcf2022-05-05 23:40:07 +0000102 if (mScreenUpdateTimer) {
103 mScreenUpdateTimer->start();
Dan Stoza030fbc12020-02-19 15:32:01 -0800104 }
105}
Michael Wright1509a232018-06-21 02:50:34 +0100106
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700107void PowerAdvisor::onBootFinished() {
108 mBootFinished.store(true);
109}
110
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800111void PowerAdvisor::setExpensiveRenderingExpected(DisplayId displayId, bool expected) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000112 if (!mHasExpensiveRendering) {
113 ALOGV("Skipped sending EXPENSIVE_RENDERING because HAL doesn't support it");
114 return;
115 }
Michael Wright1509a232018-06-21 02:50:34 +0100116 if (expected) {
117 mExpensiveDisplays.insert(displayId);
118 } else {
119 mExpensiveDisplays.erase(displayId);
120 }
121
Michael Wright1509a232018-06-21 02:50:34 +0100122 const bool expectsExpensiveRendering = !mExpensiveDisplays.empty();
123 if (mNotifiedExpensiveRendering != expectsExpensiveRendering) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000124 auto ret = getPowerHal().setMode(Mode::EXPENSIVE_RENDERING, expectsExpensiveRendering);
125 if (!ret.isOk()) {
126 if (ret.isUnsupported()) {
127 mHasExpensiveRendering = false;
128 }
Michael Wright1509a232018-06-21 02:50:34 +0100129 return;
130 }
Dan Stoza030fbc12020-02-19 15:32:01 -0800131
Michael Wright1509a232018-06-21 02:50:34 +0100132 mNotifiedExpensiveRendering = expectsExpensiveRendering;
Matt Buckley0538cae2022-11-08 23:12:04 +0000133 traceExpensiveRendering(mNotifiedExpensiveRendering);
Michael Wright1509a232018-06-21 02:50:34 +0100134 }
135}
136
jimmyshiu4e211772023-06-15 15:18:38 +0000137void PowerAdvisor::notifyCpuLoadUp() {
138 // Only start sending this notification once the system has booted so we don't introduce an
139 // early-boot dependency on Power HAL
140 if (!mBootFinished.load()) {
141 return;
142 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000143 if (usePowerHintSession()) {
jimmyshiu4e211772023-06-15 15:18:38 +0000144 std::lock_guard lock(mHintSessionMutex);
Matt Buckley547cc0c2023-10-27 22:22:36 +0000145 if (ensurePowerHintSessionRunning()) {
146 auto ret = mHintSession->sendHint(SessionHint::CPU_LOAD_UP);
147 if (!ret.isOk()) {
148 mHintSession = nullptr;
149 }
jimmyshiu4e211772023-06-15 15:18:38 +0000150 }
151 }
152}
153
Matt Buckley15ecd1c2022-11-01 21:57:16 +0000154void PowerAdvisor::notifyDisplayUpdateImminentAndCpuReset() {
Dan Stoza29e7bdf2020-03-23 14:43:09 -0700155 // Only start sending this notification once the system has booted so we don't introduce an
156 // early-boot dependency on Power HAL
157 if (!mBootFinished.load()) {
158 return;
159 }
160
Alec Mouric059dcf2022-05-05 23:40:07 +0000161 if (mSendUpdateImminent.exchange(false)) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000162 ALOGV("AIDL notifyDisplayUpdateImminentAndCpuReset");
Matt Buckley547cc0c2023-10-27 22:22:36 +0000163 if (usePowerHintSession()) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000164 std::lock_guard lock(mHintSessionMutex);
Matt Buckley547cc0c2023-10-27 22:22:36 +0000165 if (ensurePowerHintSessionRunning()) {
166 auto ret = mHintSession->sendHint(SessionHint::CPU_LOAD_RESET);
167 if (!ret.isOk()) {
168 mHintSession = nullptr;
169 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000170 }
Dan Stoza030fbc12020-02-19 15:32:01 -0800171 }
172
Matt Buckley0538cae2022-11-08 23:12:04 +0000173 if (!mHasDisplayUpdateImminent) {
174 ALOGV("Skipped sending DISPLAY_UPDATE_IMMINENT because HAL doesn't support it");
175 } else {
176 auto ret = getPowerHal().setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 0);
177 if (ret.isUnsupported()) {
178 mHasDisplayUpdateImminent = false;
179 }
Dan Stoza030fbc12020-02-19 15:32:01 -0800180 }
Alec Mouric059dcf2022-05-05 23:40:07 +0000181
182 if (mScreenUpdateTimer) {
183 mScreenUpdateTimer->reset();
184 } else {
185 // If we don't have a screen update timer, then we don't throttle power hal calls so
186 // flip this bit back to allow for calling into power hal again.
187 mSendUpdateImminent.store(true);
188 }
Dan Stoza030fbc12020-02-19 15:32:01 -0800189 }
190
Alec Mouric059dcf2022-05-05 23:40:07 +0000191 if (mScreenUpdateTimer) {
192 mLastScreenUpdatedTime.store(systemTime());
Dan Stoza030fbc12020-02-19 15:32:01 -0800193 }
194}
195
Matt Buckley06f299a2021-09-24 19:43:51 +0000196bool PowerAdvisor::usePowerHintSession() {
197 // uses cached value since the underlying support and flag are unlikely to change at runtime
Matt Buckley0538cae2022-11-08 23:12:04 +0000198 return mHintSessionEnabled.value_or(false) && supportsPowerHintSession();
Matt Buckley06f299a2021-09-24 19:43:51 +0000199}
200
201bool PowerAdvisor::supportsPowerHintSession() {
Matt Buckley0538cae2022-11-08 23:12:04 +0000202 if (!mSupportsHintSession.has_value()) {
203 mSupportsHintSession = getPowerHal().getHintSessionPreferredRate().isOk();
Matt Buckley06f299a2021-09-24 19:43:51 +0000204 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000205 return *mSupportsHintSession;
Matt Buckley06f299a2021-09-24 19:43:51 +0000206}
207
Matt Buckley52dfaad2024-03-07 20:20:07 +0000208bool PowerAdvisor::shouldCreateSessionWithConfig() {
209 return mSessionConfigSupported && FlagManager::getInstance().adpf_use_fmq_channel();
210}
211
Matt Buckley0538cae2022-11-08 23:12:04 +0000212bool PowerAdvisor::ensurePowerHintSessionRunning() {
Matt Buckley547cc0c2023-10-27 22:22:36 +0000213 if (mHintSession == nullptr && !mHintSessionThreadIds.empty() && usePowerHintSession()) {
Matt Buckley52dfaad2024-03-07 20:20:07 +0000214 if (shouldCreateSessionWithConfig()) {
215 auto ret = getPowerHal().createHintSessionWithConfig(getpid(),
216 static_cast<int32_t>(getuid()),
217 mHintSessionThreadIds,
218 mTargetDuration.ns(),
219 SessionTag::SURFACEFLINGER,
220 &mSessionConfig);
221 if (ret.isOk()) {
222 mHintSession = ret.value();
223 }
224 // If it fails the first time we try, or ever returns unsupported, assume unsupported
225 else if (mFirstConfigSupportCheck || ret.isUnsupported()) {
226 ALOGI("Hint session with config is unsupported, falling back to a legacy session");
227 mSessionConfigSupported = false;
228 }
229 mFirstConfigSupportCheck = false;
230 }
231 // Immediately try original method after, in case the first way returned unsupported
232 if (mHintSession == nullptr && !shouldCreateSessionWithConfig()) {
233 auto ret = getPowerHal().createHintSession(getpid(), static_cast<int32_t>(getuid()),
234 mHintSessionThreadIds, mTargetDuration.ns());
235 if (ret.isOk()) {
236 mHintSession = ret.value();
237 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000238 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000239 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000240 return mHintSession != nullptr;
Matt Buckley06f299a2021-09-24 19:43:51 +0000241}
242
Matt Buckley0538cae2022-11-08 23:12:04 +0000243void PowerAdvisor::updateTargetWorkDuration(Duration targetDuration) {
Matt Buckleyef51fba2021-10-12 19:30:12 +0000244 if (!usePowerHintSession()) {
Matt Buckley06f299a2021-09-24 19:43:51 +0000245 ALOGV("Power hint session target duration cannot be set, skipping");
246 return;
247 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000248 ATRACE_CALL();
Matt Buckley06f299a2021-09-24 19:43:51 +0000249 {
Matt Buckley0538cae2022-11-08 23:12:04 +0000250 mTargetDuration = targetDuration;
251 if (sTraceHintSessionData) ATRACE_INT64("Time target", targetDuration.ns());
Matt Buckley547cc0c2023-10-27 22:22:36 +0000252 if (targetDuration == mLastTargetDurationSent) return;
253 std::lock_guard lock(mHintSessionMutex);
254 if (ensurePowerHintSessionRunning()) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000255 ALOGV("Sending target time: %" PRId64 "ns", targetDuration.ns());
256 mLastTargetDurationSent = targetDuration;
Matt Buckley0538cae2022-11-08 23:12:04 +0000257 auto ret = mHintSession->updateTargetWorkDuration(targetDuration.ns());
258 if (!ret.isOk()) {
259 ALOGW("Failed to set power hint target work duration with error: %s",
Matt Buckley6c18e6d2024-02-07 23:39:50 +0000260 ret.errorMessage());
Matt Buckley547cc0c2023-10-27 22:22:36 +0000261 mHintSession = nullptr;
Matt Buckley0538cae2022-11-08 23:12:04 +0000262 }
Matt Buckley06f299a2021-09-24 19:43:51 +0000263 }
264 }
265}
266
Matt Buckley0538cae2022-11-08 23:12:04 +0000267void PowerAdvisor::reportActualWorkDuration() {
Matt Buckley676e4392023-05-25 22:09:26 +0000268 if (!mBootFinished || !sUseReportActualDuration || !usePowerHintSession()) {
Matt Buckley06f299a2021-09-24 19:43:51 +0000269 ALOGV("Actual work duration power hint cannot be sent, skipping");
270 return;
271 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000272 ATRACE_CALL();
Xiang Wangaab31162024-03-12 19:48:08 -0700273 std::optional<WorkDuration> actualDuration = estimateWorkDuration();
274 if (!actualDuration.has_value() || actualDuration->durationNanos < 0) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000275 ALOGV("Failed to send actual work duration, skipping");
Matt Buckley50c44062022-01-17 20:48:10 +0000276 return;
277 }
Xiang Wangaab31162024-03-12 19:48:08 -0700278 actualDuration->durationNanos += sTargetSafetyMargin.ns();
Matt Buckley0538cae2022-11-08 23:12:04 +0000279 if (sTraceHintSessionData) {
Xiang Wangaab31162024-03-12 19:48:08 -0700280 ATRACE_INT64("Measured duration", actualDuration->durationNanos);
281 ATRACE_INT64("Target error term", actualDuration->durationNanos - mTargetDuration.ns());
282 ATRACE_INT64("Reported duration", actualDuration->durationNanos);
283 if (FlagManager::getInstance().adpf_gpu_sf()) {
284 ATRACE_INT64("Reported cpu duration", actualDuration->cpuDurationNanos);
285 ATRACE_INT64("Reported gpu duration", actualDuration->gpuDurationNanos);
286 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000287 ATRACE_INT64("Reported target", mLastTargetDurationSent.ns());
288 ATRACE_INT64("Reported target error term",
Xiang Wangaab31162024-03-12 19:48:08 -0700289 actualDuration->durationNanos - mLastTargetDurationSent.ns());
Matt Buckley0538cae2022-11-08 23:12:04 +0000290 }
291
Xiang Wangaab31162024-03-12 19:48:08 -0700292 ALOGV("Sending actual work duration of: %" PRId64 " with cpu: %" PRId64 " and gpu: %" PRId64
293 " on reported target: %" PRId64 " with error: %" PRId64,
294 actualDuration->durationNanos, actualDuration->cpuDurationNanos,
295 actualDuration->gpuDurationNanos, mLastTargetDurationSent.ns(),
296 actualDuration->durationNanos - mLastTargetDurationSent.ns());
Matt Buckley0538cae2022-11-08 23:12:04 +0000297
Matt Buckley547cc0c2023-10-27 22:22:36 +0000298 if (mTimingTestingMode) {
299 mDelayReportActualMutexAcquisitonPromise.get_future().wait();
300 mDelayReportActualMutexAcquisitonPromise = std::promise<bool>{};
301 }
302
Matt Buckley0538cae2022-11-08 23:12:04 +0000303 {
304 std::lock_guard lock(mHintSessionMutex);
Matt Buckley547cc0c2023-10-27 22:22:36 +0000305 if (!ensurePowerHintSessionRunning()) {
306 ALOGV("Hint session not running and could not be started, skipping");
307 return;
308 }
Xiang Wangaab31162024-03-12 19:48:08 -0700309 mHintSessionQueue.push_back(*actualDuration);
Matt Buckley547cc0c2023-10-27 22:22:36 +0000310
Matt Buckley0538cae2022-11-08 23:12:04 +0000311 auto ret = mHintSession->reportActualWorkDuration(mHintSessionQueue);
312 if (!ret.isOk()) {
Matt Buckley6c18e6d2024-02-07 23:39:50 +0000313 ALOGW("Failed to report actual work durations with error: %s", ret.errorMessage());
Matt Buckley547cc0c2023-10-27 22:22:36 +0000314 mHintSession = nullptr;
Matt Buckley0538cae2022-11-08 23:12:04 +0000315 return;
Matt Buckley50c44062022-01-17 20:48:10 +0000316 }
317 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000318 mHintSessionQueue.clear();
Matt Buckley50c44062022-01-17 20:48:10 +0000319}
320
Matt Buckley0538cae2022-11-08 23:12:04 +0000321void PowerAdvisor::enablePowerHintSession(bool enabled) {
322 mHintSessionEnabled = enabled;
Matt Buckley06f299a2021-09-24 19:43:51 +0000323}
324
Matt Buckley547cc0c2023-10-27 22:22:36 +0000325bool PowerAdvisor::startPowerHintSession(std::vector<int32_t>&& threadIds) {
326 mHintSessionThreadIds = threadIds;
Matt Buckley0538cae2022-11-08 23:12:04 +0000327 if (!mBootFinished.load()) {
328 return false;
Matt Buckleyef51fba2021-10-12 19:30:12 +0000329 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000330 if (!usePowerHintSession()) {
331 ALOGI("Cannot start power hint session: disabled or unsupported");
332 return false;
333 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000334 LOG_ALWAYS_FATAL_IF(mHintSessionThreadIds.empty(),
335 "No thread IDs provided to power hint session!");
336 std::lock_guard lock(mHintSessionMutex);
337 if (mHintSession != nullptr) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000338 ALOGE("Cannot start power hint session: already running");
339 return false;
340 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000341 return ensurePowerHintSessionRunning();
Matt Buckleyef51fba2021-10-12 19:30:12 +0000342}
343
Xiang Wangaab31162024-03-12 19:48:08 -0700344void PowerAdvisor::setGpuStartTime(DisplayId displayId, TimePoint startTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000345 DisplayTimingData& displayData = mDisplayTimingData[displayId];
346 if (displayData.gpuEndFenceTime) {
347 nsecs_t signalTime = displayData.gpuEndFenceTime->getSignalTime();
348 if (signalTime != Fence::SIGNAL_TIME_INVALID && signalTime != Fence::SIGNAL_TIME_PENDING) {
Xiang Wangaab31162024-03-12 19:48:08 -0700349 displayData.lastValidGpuStartTime = displayData.gpuStartTime;
350 displayData.lastValidGpuEndTime = TimePoint::fromNs(signalTime);
351 for (auto&& [_, otherDisplayData] : mDisplayTimingData) {
352 if (!otherDisplayData.lastValidGpuStartTime.has_value() ||
353 !otherDisplayData.lastValidGpuEndTime.has_value())
354 continue;
355 if ((*otherDisplayData.lastValidGpuStartTime < *displayData.gpuStartTime) &&
356 (*otherDisplayData.lastValidGpuEndTime > *displayData.gpuStartTime)) {
357 displayData.lastValidGpuStartTime = *otherDisplayData.lastValidGpuEndTime;
358 break;
359 }
360 }
361 }
362 displayData.gpuEndFenceTime = nullptr;
363 }
364 displayData.gpuStartTime = startTime;
365}
366
367void PowerAdvisor::setGpuFenceTime(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime) {
368 DisplayTimingData& displayData = mDisplayTimingData[displayId];
369 if (displayData.gpuEndFenceTime && !FlagManager::getInstance().adpf_gpu_sf()) {
370 nsecs_t signalTime = displayData.gpuEndFenceTime->getSignalTime();
371 if (signalTime != Fence::SIGNAL_TIME_INVALID && signalTime != Fence::SIGNAL_TIME_PENDING) {
372 displayData.lastValidGpuStartTime = displayData.gpuStartTime;
373 displayData.lastValidGpuEndTime = TimePoint::fromNs(signalTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000374 for (auto&& [_, otherDisplayData] : mDisplayTimingData) {
375 // If the previous display started before us but ended after we should have
376 // started, then it likely delayed our start time and we must compensate for that.
377 // Displays finishing earlier should have already made their way through this call
378 // and swapped their timing into "lastValid" from "latest", so we check that here.
379 if (!otherDisplayData.lastValidGpuStartTime.has_value()) continue;
380 if ((*otherDisplayData.lastValidGpuStartTime < *displayData.gpuStartTime) &&
381 (*otherDisplayData.lastValidGpuEndTime > *displayData.gpuStartTime)) {
382 displayData.lastValidGpuStartTime = *otherDisplayData.lastValidGpuEndTime;
383 break;
384 }
385 }
Matt Buckley50c44062022-01-17 20:48:10 +0000386 }
387 }
388 displayData.gpuEndFenceTime = std::move(fenceTime);
Xiang Wangaab31162024-03-12 19:48:08 -0700389 if (!FlagManager::getInstance().adpf_gpu_sf()) {
390 displayData.gpuStartTime = TimePoint::now();
391 }
Matt Buckley50c44062022-01-17 20:48:10 +0000392}
393
Matt Buckley2fa85012022-08-30 22:38:45 +0000394void PowerAdvisor::setHwcValidateTiming(DisplayId displayId, TimePoint validateStartTime,
395 TimePoint validateEndTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000396 DisplayTimingData& displayData = mDisplayTimingData[displayId];
Matt Buckley16dec1f2022-06-07 21:46:20 +0000397 displayData.hwcValidateStartTime = validateStartTime;
398 displayData.hwcValidateEndTime = validateEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000399}
400
Matt Buckley2fa85012022-08-30 22:38:45 +0000401void PowerAdvisor::setHwcPresentTiming(DisplayId displayId, TimePoint presentStartTime,
402 TimePoint presentEndTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000403 DisplayTimingData& displayData = mDisplayTimingData[displayId];
Matt Buckley16dec1f2022-06-07 21:46:20 +0000404 displayData.hwcPresentStartTime = presentStartTime;
405 displayData.hwcPresentEndTime = presentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000406}
407
408void PowerAdvisor::setSkippedValidate(DisplayId displayId, bool skipped) {
409 mDisplayTimingData[displayId].skippedValidate = skipped;
410}
411
Xiang Wangaab31162024-03-12 19:48:08 -0700412void PowerAdvisor::setRequiresRenderEngine(DisplayId displayId, bool requiresRenderEngine) {
413 mDisplayTimingData[displayId].requiresRenderEngine = requiresRenderEngine;
Matt Buckley50c44062022-01-17 20:48:10 +0000414}
415
Matt Buckley2fa85012022-08-30 22:38:45 +0000416void PowerAdvisor::setExpectedPresentTime(TimePoint expectedPresentTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000417 mExpectedPresentTimes.append(expectedPresentTime);
418}
419
Matt Buckley2fa85012022-08-30 22:38:45 +0000420void PowerAdvisor::setSfPresentTiming(TimePoint presentFenceTime, TimePoint presentEndTime) {
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700421 mLastPresentFenceTime = presentFenceTime;
Xiang Wangaab31162024-03-12 19:48:08 -0700422 mLastSfPresentEndTime = presentEndTime;
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700423}
424
Matt Buckley2fa85012022-08-30 22:38:45 +0000425void PowerAdvisor::setFrameDelay(Duration frameDelayDuration) {
Matt Buckley50c44062022-01-17 20:48:10 +0000426 mFrameDelayDuration = frameDelayDuration;
427}
428
Matt Buckley2fa85012022-08-30 22:38:45 +0000429void PowerAdvisor::setHwcPresentDelayedTime(DisplayId displayId, TimePoint earliestFrameStartTime) {
430 mDisplayTimingData[displayId].hwcPresentDelayedTime = earliestFrameStartTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000431}
432
Matt Buckley2fa85012022-08-30 22:38:45 +0000433void PowerAdvisor::setCommitStart(TimePoint commitStartTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000434 mCommitStartTimes.append(commitStartTime);
435}
436
Matt Buckley2fa85012022-08-30 22:38:45 +0000437void PowerAdvisor::setCompositeEnd(TimePoint compositeEndTime) {
438 mLastPostcompDuration = compositeEndTime - mLastSfPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000439}
440
441void PowerAdvisor::setDisplays(std::vector<DisplayId>& displayIds) {
442 mDisplayIds = displayIds;
443}
444
Matt Buckley2fa85012022-08-30 22:38:45 +0000445void PowerAdvisor::setTotalFrameTargetWorkDuration(Duration targetDuration) {
Matt Buckley50c44062022-01-17 20:48:10 +0000446 mTotalFrameTargetDuration = targetDuration;
447}
448
449std::vector<DisplayId> PowerAdvisor::getOrderedDisplayIds(
Matt Buckley2fa85012022-08-30 22:38:45 +0000450 std::optional<TimePoint> DisplayTimingData::*sortBy) {
Matt Buckley50c44062022-01-17 20:48:10 +0000451 std::vector<DisplayId> sortedDisplays;
452 std::copy_if(mDisplayIds.begin(), mDisplayIds.end(), std::back_inserter(sortedDisplays),
453 [&](DisplayId id) {
454 return mDisplayTimingData.count(id) &&
455 (mDisplayTimingData[id].*sortBy).has_value();
456 });
457 std::sort(sortedDisplays.begin(), sortedDisplays.end(), [&](DisplayId idA, DisplayId idB) {
458 return *(mDisplayTimingData[idA].*sortBy) < *(mDisplayTimingData[idB].*sortBy);
459 });
460 return sortedDisplays;
461}
462
Xiang Wangaab31162024-03-12 19:48:08 -0700463std::optional<WorkDuration> PowerAdvisor::estimateWorkDuration() {
Matt Buckley0538cae2022-11-08 23:12:04 +0000464 if (!mExpectedPresentTimes.isFull() || !mCommitStartTimes.isFull()) {
Matt Buckley50c44062022-01-17 20:48:10 +0000465 return std::nullopt;
466 }
467
468 // Tracks when we finish presenting to hwc
Matt Buckley0538cae2022-11-08 23:12:04 +0000469 TimePoint estimatedHwcEndTime = mCommitStartTimes[0];
Matt Buckley50c44062022-01-17 20:48:10 +0000470
471 // How long we spent this frame not doing anything, waiting for fences or vsync
Matt Buckley2fa85012022-08-30 22:38:45 +0000472 Duration idleDuration = 0ns;
Matt Buckley50c44062022-01-17 20:48:10 +0000473
474 // Most recent previous gpu end time in the current frame, probably from a prior display, used
475 // as the start time for the next gpu operation if it ran over time since it probably blocked
Matt Buckley2fa85012022-08-30 22:38:45 +0000476 std::optional<TimePoint> previousValidGpuEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000477
478 // The currently estimated gpu end time for the frame,
479 // used to accumulate gpu time as we iterate over the active displays
Matt Buckley2fa85012022-08-30 22:38:45 +0000480 std::optional<TimePoint> estimatedGpuEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000481
Matt Buckley50c44062022-01-17 20:48:10 +0000482 std::vector<DisplayId>&& displayIds =
Matt Buckley16dec1f2022-06-07 21:46:20 +0000483 getOrderedDisplayIds(&DisplayTimingData::hwcPresentStartTime);
Matt Buckley0538cae2022-11-08 23:12:04 +0000484 DisplayTimeline displayTiming;
Xiang Wangaab31162024-03-12 19:48:08 -0700485 std::optional<GpuTimeline> firstGpuTimeline;
Matt Buckley50c44062022-01-17 20:48:10 +0000486
Matt Buckley1809d902022-08-05 06:51:43 +0000487 // Iterate over the displays that use hwc in the same order they are presented
Matt Buckley50c44062022-01-17 20:48:10 +0000488 for (DisplayId displayId : displayIds) {
489 if (mDisplayTimingData.count(displayId) == 0) {
490 continue;
491 }
492
493 auto& displayData = mDisplayTimingData.at(displayId);
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700494
Matt Buckley0538cae2022-11-08 23:12:04 +0000495 displayTiming = displayData.calculateDisplayTimeline(mLastPresentFenceTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000496
Matt Buckley50c44062022-01-17 20:48:10 +0000497 // Update predicted present finish time with this display's present time
Matt Buckley0538cae2022-11-08 23:12:04 +0000498 estimatedHwcEndTime = displayTiming.hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000499
500 // Track how long we spent waiting for the fence, can be excluded from the timing estimate
Matt Buckley0538cae2022-11-08 23:12:04 +0000501 idleDuration += displayTiming.probablyWaitsForPresentFence
502 ? mLastPresentFenceTime - displayTiming.presentFenceWaitStartTime
Matt Buckley2fa85012022-08-30 22:38:45 +0000503 : 0ns;
Matt Buckley50c44062022-01-17 20:48:10 +0000504
505 // Track how long we spent waiting to present, can be excluded from the timing estimate
Matt Buckley0538cae2022-11-08 23:12:04 +0000506 idleDuration += displayTiming.hwcPresentDelayDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000507
508 // Estimate the reference frame's gpu timing
509 auto gpuTiming = displayData.estimateGpuTiming(previousValidGpuEndTime);
510 if (gpuTiming.has_value()) {
Xiang Wangaab31162024-03-12 19:48:08 -0700511 if (!firstGpuTimeline.has_value()) {
512 firstGpuTimeline = gpuTiming;
513 }
Matt Buckley50c44062022-01-17 20:48:10 +0000514 previousValidGpuEndTime = gpuTiming->startTime + gpuTiming->duration;
515
516 // Estimate the prediction frame's gpu end time from the reference frame
Matt Buckley0538cae2022-11-08 23:12:04 +0000517 estimatedGpuEndTime = std::max(displayTiming.hwcPresentStartTime,
Matt Buckley2fa85012022-08-30 22:38:45 +0000518 estimatedGpuEndTime.value_or(TimePoint{0ns})) +
Matt Buckley50c44062022-01-17 20:48:10 +0000519 gpuTiming->duration;
520 }
Matt Buckley50c44062022-01-17 20:48:10 +0000521 }
Matt Buckley50c44062022-01-17 20:48:10 +0000522
Matt Buckley0538cae2022-11-08 23:12:04 +0000523 TimePoint estimatedFlingerEndTime = mLastSfPresentEndTime;
Matt Buckley1809d902022-08-05 06:51:43 +0000524
Matt Buckley50c44062022-01-17 20:48:10 +0000525 // Don't count time spent idly waiting in the estimate as we could do more work in that time
Matt Buckley0538cae2022-11-08 23:12:04 +0000526 estimatedHwcEndTime -= idleDuration;
Matt Buckley1809d902022-08-05 06:51:43 +0000527 estimatedFlingerEndTime -= idleDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000528
529 // We finish the frame when both present and the gpu are done, so wait for the later of the two
530 // Also add the frame delay duration since the target did not move while we were delayed
Matt Buckley2fa85012022-08-30 22:38:45 +0000531 Duration totalDuration = mFrameDelayDuration +
Matt Buckley0538cae2022-11-08 23:12:04 +0000532 std::max(estimatedHwcEndTime, estimatedGpuEndTime.value_or(TimePoint{0ns})) -
Matt Buckley2fa85012022-08-30 22:38:45 +0000533 mCommitStartTimes[0];
Xiang Wangaab31162024-03-12 19:48:08 -0700534 Duration totalDurationWithoutGpu =
535 mFrameDelayDuration + estimatedHwcEndTime - mCommitStartTimes[0];
Matt Buckley50c44062022-01-17 20:48:10 +0000536
537 // We finish SurfaceFlinger when post-composition finishes, so add that in here
Matt Buckley2fa85012022-08-30 22:38:45 +0000538 Duration flingerDuration =
Matt Buckley1809d902022-08-05 06:51:43 +0000539 estimatedFlingerEndTime + mLastPostcompDuration - mCommitStartTimes[0];
Xiang Wangaab31162024-03-12 19:48:08 -0700540 Duration estimatedGpuDuration = firstGpuTimeline.has_value()
541 ? estimatedGpuEndTime.value_or(TimePoint{0ns}) - firstGpuTimeline->startTime
542 : Duration::fromNs(0);
Matt Buckley1809d902022-08-05 06:51:43 +0000543
544 // Combine the two timings into a single normalized one
Matt Buckley2fa85012022-08-30 22:38:45 +0000545 Duration combinedDuration = combineTimingEstimates(totalDuration, flingerDuration);
Xiang Wangaab31162024-03-12 19:48:08 -0700546 Duration cpuDuration = combineTimingEstimates(totalDurationWithoutGpu, flingerDuration);
Matt Buckley50c44062022-01-17 20:48:10 +0000547
Xiang Wangaab31162024-03-12 19:48:08 -0700548 WorkDuration duration{
549 .timeStampNanos = TimePoint::now().ns(),
550 .durationNanos = combinedDuration.ns(),
551 .workPeriodStartTimestampNanos = mCommitStartTimes[0].ns(),
552 .cpuDurationNanos = FlagManager::getInstance().adpf_gpu_sf() ? cpuDuration.ns() : 0,
553 .gpuDurationNanos =
554 FlagManager::getInstance().adpf_gpu_sf() ? estimatedGpuDuration.ns() : 0,
555 };
556 if (sTraceHintSessionData) {
557 ATRACE_INT64("Idle duration", idleDuration.ns());
Xiang Wangaab31162024-03-12 19:48:08 -0700558 ATRACE_INT64("Total duration", totalDuration.ns());
559 ATRACE_INT64("Flinger duration", flingerDuration.ns());
560 }
561 return std::make_optional(duration);
Matt Buckley50c44062022-01-17 20:48:10 +0000562}
563
Matt Buckley2fa85012022-08-30 22:38:45 +0000564Duration PowerAdvisor::combineTimingEstimates(Duration totalDuration, Duration flingerDuration) {
565 Duration targetDuration{0ns};
Matt Buckley0538cae2022-11-08 23:12:04 +0000566 targetDuration = mTargetDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000567 if (!mTotalFrameTargetDuration.has_value()) return flingerDuration;
568
569 // Normalize total to the flinger target (vsync period) since that's how often we actually send
570 // hints
Matt Buckley2fa85012022-08-30 22:38:45 +0000571 Duration normalizedTotalDuration = Duration::fromNs((targetDuration.ns() * totalDuration.ns()) /
572 mTotalFrameTargetDuration->ns());
Matt Buckley50c44062022-01-17 20:48:10 +0000573 return std::max(flingerDuration, normalizedTotalDuration);
574}
575
Matt Buckley50c44062022-01-17 20:48:10 +0000576PowerAdvisor::DisplayTimeline PowerAdvisor::DisplayTimingData::calculateDisplayTimeline(
Matt Buckley2fa85012022-08-30 22:38:45 +0000577 TimePoint fenceTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000578 DisplayTimeline timeline;
Matt Buckley16dec1f2022-06-07 21:46:20 +0000579 // How long between calling hwc present and trying to wait on the fence
Matt Buckley2fa85012022-08-30 22:38:45 +0000580 const Duration fenceWaitStartDelay =
581 (skippedValidate ? kFenceWaitStartDelaySkippedValidate : kFenceWaitStartDelayValidated);
Matt Buckley50c44062022-01-17 20:48:10 +0000582
Matt Buckley16dec1f2022-06-07 21:46:20 +0000583 // Did our reference frame wait for an appropriate vsync before calling into hwc
584 const bool waitedOnHwcPresentTime = hwcPresentDelayedTime.has_value() &&
585 *hwcPresentDelayedTime > *hwcPresentStartTime &&
586 *hwcPresentDelayedTime < *hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000587
588 // Use validate start here if we skipped it because we did validate + present together
Matt Buckley16dec1f2022-06-07 21:46:20 +0000589 timeline.hwcPresentStartTime = skippedValidate ? *hwcValidateStartTime : *hwcPresentStartTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000590
591 // Use validate end here if we skipped it because we did validate + present together
Matt Buckley16dec1f2022-06-07 21:46:20 +0000592 timeline.hwcPresentEndTime = skippedValidate ? *hwcValidateEndTime : *hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000593
Matt Buckley16dec1f2022-06-07 21:46:20 +0000594 // How long hwc present was delayed waiting for the next appropriate vsync
595 timeline.hwcPresentDelayDuration =
Matt Buckley2fa85012022-08-30 22:38:45 +0000596 (waitedOnHwcPresentTime ? *hwcPresentDelayedTime - *hwcPresentStartTime : 0ns);
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700597 // When we started waiting for the present fence after calling into hwc present
598 timeline.presentFenceWaitStartTime =
Matt Buckley16dec1f2022-06-07 21:46:20 +0000599 timeline.hwcPresentStartTime + timeline.hwcPresentDelayDuration + fenceWaitStartDelay;
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700600 timeline.probablyWaitsForPresentFence = fenceTime > timeline.presentFenceWaitStartTime &&
Matt Buckley16dec1f2022-06-07 21:46:20 +0000601 fenceTime < timeline.hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000602
Matt Buckley16dec1f2022-06-07 21:46:20 +0000603 // How long we ran after we finished waiting for the fence but before hwc present finished
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700604 timeline.postPresentFenceHwcPresentDuration = timeline.hwcPresentEndTime -
605 (timeline.probablyWaitsForPresentFence ? fenceTime
606 : timeline.presentFenceWaitStartTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000607 return timeline;
608}
609
610std::optional<PowerAdvisor::GpuTimeline> PowerAdvisor::DisplayTimingData::estimateGpuTiming(
Matt Buckley2fa85012022-08-30 22:38:45 +0000611 std::optional<TimePoint> previousEndTime) {
Xiang Wangaab31162024-03-12 19:48:08 -0700612 if (!(requiresRenderEngine && lastValidGpuStartTime.has_value() && gpuEndFenceTime)) {
Matt Buckley50c44062022-01-17 20:48:10 +0000613 return std::nullopt;
614 }
Matt Buckley2fa85012022-08-30 22:38:45 +0000615 const TimePoint latestGpuStartTime =
616 std::max(previousEndTime.value_or(TimePoint{0ns}), *gpuStartTime);
617 const nsecs_t gpuEndFenceSignal = gpuEndFenceTime->getSignalTime();
618 Duration gpuDuration{0ns};
619 if (gpuEndFenceSignal != Fence::SIGNAL_TIME_INVALID &&
620 gpuEndFenceSignal != Fence::SIGNAL_TIME_PENDING) {
621 const TimePoint latestGpuEndTime = TimePoint::fromNs(gpuEndFenceSignal);
622
Matt Buckley50c44062022-01-17 20:48:10 +0000623 // If we know how long the most recent gpu duration was, use that
624 gpuDuration = latestGpuEndTime - latestGpuStartTime;
625 } else if (lastValidGpuEndTime.has_value()) {
626 // If we don't have the fence data, use the most recent information we do have
627 gpuDuration = *lastValidGpuEndTime - *lastValidGpuStartTime;
Matt Buckley2fa85012022-08-30 22:38:45 +0000628 if (gpuEndFenceSignal == Fence::SIGNAL_TIME_PENDING) {
Matt Buckley50c44062022-01-17 20:48:10 +0000629 // If pending but went over the previous duration, use current time as the end
Matt Buckley2fa85012022-08-30 22:38:45 +0000630 gpuDuration = std::max(gpuDuration, Duration{TimePoint::now() - latestGpuStartTime});
Matt Buckley50c44062022-01-17 20:48:10 +0000631 }
632 }
633 return GpuTimeline{.duration = gpuDuration, .startTime = latestGpuStartTime};
634}
635
Matt Buckley0538cae2022-11-08 23:12:04 +0000636const bool PowerAdvisor::sTraceHintSessionData =
Xiang Wang56dc1042024-03-22 03:58:46 +0000637 base::GetBoolProperty(std::string("debug.sf.trace_hint_sessions"), false);
Matt Buckleyef51fba2021-10-12 19:30:12 +0000638
Matt Buckleyac15a1b2023-02-28 06:51:28 +0000639const Duration PowerAdvisor::sTargetSafetyMargin = std::chrono::microseconds(
640 base::GetIntProperty<int64_t>("debug.sf.hint_margin_us",
641 ticks<std::micro>(PowerAdvisor::kDefaultTargetSafetyMargin)));
642
Matt Buckley676e4392023-05-25 22:09:26 +0000643const bool PowerAdvisor::sUseReportActualDuration =
644 base::GetBoolProperty(std::string("debug.adpf.use_report_actual_duration"), true);
645
Matt Buckley0538cae2022-11-08 23:12:04 +0000646power::PowerHalController& PowerAdvisor::getPowerHal() {
647 static std::once_flag halFlag;
648 std::call_once(halFlag, [this] { mPowerHal->init(); });
649 return *mPowerHal;
Michael Wright1509a232018-06-21 02:50:34 +0100650}
651
652} // namespace impl
653} // namespace Hwc2
654} // namespace android