blob: faa51972e914d9ed57abee6bb40e260ecb33c771 [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();
273 std::optional<Duration> actualDuration = estimateWorkDuration();
Matt Buckley547cc0c2023-10-27 22:22:36 +0000274 if (!actualDuration.has_value() || actualDuration < 0ns) {
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 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000278 actualDuration = std::make_optional(*actualDuration + sTargetSafetyMargin);
279 mActualDuration = actualDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000280
Matt Buckley0538cae2022-11-08 23:12:04 +0000281 if (sTraceHintSessionData) {
282 ATRACE_INT64("Measured duration", actualDuration->ns());
283 ATRACE_INT64("Target error term", Duration{*actualDuration - mTargetDuration}.ns());
284 ATRACE_INT64("Reported duration", actualDuration->ns());
285 ATRACE_INT64("Reported target", mLastTargetDurationSent.ns());
286 ATRACE_INT64("Reported target error term",
287 Duration{*actualDuration - mLastTargetDurationSent}.ns());
288 }
289
290 ALOGV("Sending actual work duration of: %" PRId64 " on reported target: %" PRId64
291 " with error: %" PRId64,
292 actualDuration->ns(), mLastTargetDurationSent.ns(),
293 Duration{*actualDuration - mLastTargetDurationSent}.ns());
294
Matt Buckley547cc0c2023-10-27 22:22:36 +0000295 if (mTimingTestingMode) {
296 mDelayReportActualMutexAcquisitonPromise.get_future().wait();
297 mDelayReportActualMutexAcquisitonPromise = std::promise<bool>{};
298 }
299
Matt Buckley0538cae2022-11-08 23:12:04 +0000300 {
301 std::lock_guard lock(mHintSessionMutex);
Matt Buckley547cc0c2023-10-27 22:22:36 +0000302 if (!ensurePowerHintSessionRunning()) {
303 ALOGV("Hint session not running and could not be started, skipping");
304 return;
305 }
306
307 WorkDuration duration{
308 .timeStampNanos = TimePoint::now().ns(),
309 // TODO(b/284324521): Correctly calculate total duration.
310 .durationNanos = actualDuration->ns(),
311 .workPeriodStartTimestampNanos = mCommitStartTimes[0].ns(),
312 .cpuDurationNanos = actualDuration->ns(),
313 // TODO(b/284324521): Calculate RenderEngine GPU time.
314 .gpuDurationNanos = 0,
315 };
316 mHintSessionQueue.push_back(duration);
317
Matt Buckley0538cae2022-11-08 23:12:04 +0000318 auto ret = mHintSession->reportActualWorkDuration(mHintSessionQueue);
319 if (!ret.isOk()) {
Matt Buckley6c18e6d2024-02-07 23:39:50 +0000320 ALOGW("Failed to report actual work durations with error: %s", ret.errorMessage());
Matt Buckley547cc0c2023-10-27 22:22:36 +0000321 mHintSession = nullptr;
Matt Buckley0538cae2022-11-08 23:12:04 +0000322 return;
Matt Buckley50c44062022-01-17 20:48:10 +0000323 }
324 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000325 mHintSessionQueue.clear();
Matt Buckley50c44062022-01-17 20:48:10 +0000326}
327
Matt Buckley0538cae2022-11-08 23:12:04 +0000328void PowerAdvisor::enablePowerHintSession(bool enabled) {
329 mHintSessionEnabled = enabled;
Matt Buckley06f299a2021-09-24 19:43:51 +0000330}
331
Matt Buckley547cc0c2023-10-27 22:22:36 +0000332bool PowerAdvisor::startPowerHintSession(std::vector<int32_t>&& threadIds) {
333 mHintSessionThreadIds = threadIds;
Matt Buckley0538cae2022-11-08 23:12:04 +0000334 if (!mBootFinished.load()) {
335 return false;
Matt Buckleyef51fba2021-10-12 19:30:12 +0000336 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000337 if (!usePowerHintSession()) {
338 ALOGI("Cannot start power hint session: disabled or unsupported");
339 return false;
340 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000341 LOG_ALWAYS_FATAL_IF(mHintSessionThreadIds.empty(),
342 "No thread IDs provided to power hint session!");
343 std::lock_guard lock(mHintSessionMutex);
344 if (mHintSession != nullptr) {
Matt Buckley0538cae2022-11-08 23:12:04 +0000345 ALOGE("Cannot start power hint session: already running");
346 return false;
347 }
Matt Buckley547cc0c2023-10-27 22:22:36 +0000348 return ensurePowerHintSessionRunning();
Matt Buckleyef51fba2021-10-12 19:30:12 +0000349}
350
Matt Buckley50c44062022-01-17 20:48:10 +0000351void PowerAdvisor::setGpuFenceTime(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime) {
352 DisplayTimingData& displayData = mDisplayTimingData[displayId];
353 if (displayData.gpuEndFenceTime) {
354 nsecs_t signalTime = displayData.gpuEndFenceTime->getSignalTime();
355 if (signalTime != Fence::SIGNAL_TIME_INVALID && signalTime != Fence::SIGNAL_TIME_PENDING) {
356 for (auto&& [_, otherDisplayData] : mDisplayTimingData) {
357 // If the previous display started before us but ended after we should have
358 // started, then it likely delayed our start time and we must compensate for that.
359 // Displays finishing earlier should have already made their way through this call
360 // and swapped their timing into "lastValid" from "latest", so we check that here.
361 if (!otherDisplayData.lastValidGpuStartTime.has_value()) continue;
362 if ((*otherDisplayData.lastValidGpuStartTime < *displayData.gpuStartTime) &&
363 (*otherDisplayData.lastValidGpuEndTime > *displayData.gpuStartTime)) {
364 displayData.lastValidGpuStartTime = *otherDisplayData.lastValidGpuEndTime;
365 break;
366 }
367 }
368 displayData.lastValidGpuStartTime = displayData.gpuStartTime;
Matt Buckley2fa85012022-08-30 22:38:45 +0000369 displayData.lastValidGpuEndTime = TimePoint::fromNs(signalTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000370 }
371 }
372 displayData.gpuEndFenceTime = std::move(fenceTime);
Matt Buckley2fa85012022-08-30 22:38:45 +0000373 displayData.gpuStartTime = TimePoint::now();
Matt Buckley50c44062022-01-17 20:48:10 +0000374}
375
Matt Buckley2fa85012022-08-30 22:38:45 +0000376void PowerAdvisor::setHwcValidateTiming(DisplayId displayId, TimePoint validateStartTime,
377 TimePoint validateEndTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000378 DisplayTimingData& displayData = mDisplayTimingData[displayId];
Matt Buckley16dec1f2022-06-07 21:46:20 +0000379 displayData.hwcValidateStartTime = validateStartTime;
380 displayData.hwcValidateEndTime = validateEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000381}
382
Matt Buckley2fa85012022-08-30 22:38:45 +0000383void PowerAdvisor::setHwcPresentTiming(DisplayId displayId, TimePoint presentStartTime,
384 TimePoint presentEndTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000385 DisplayTimingData& displayData = mDisplayTimingData[displayId];
Matt Buckley16dec1f2022-06-07 21:46:20 +0000386 displayData.hwcPresentStartTime = presentStartTime;
387 displayData.hwcPresentEndTime = presentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000388}
389
390void PowerAdvisor::setSkippedValidate(DisplayId displayId, bool skipped) {
391 mDisplayTimingData[displayId].skippedValidate = skipped;
392}
393
394void PowerAdvisor::setRequiresClientComposition(DisplayId displayId,
395 bool requiresClientComposition) {
396 mDisplayTimingData[displayId].usedClientComposition = requiresClientComposition;
397}
398
Matt Buckley2fa85012022-08-30 22:38:45 +0000399void PowerAdvisor::setExpectedPresentTime(TimePoint expectedPresentTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000400 mExpectedPresentTimes.append(expectedPresentTime);
401}
402
Matt Buckley2fa85012022-08-30 22:38:45 +0000403void PowerAdvisor::setSfPresentTiming(TimePoint presentFenceTime, TimePoint presentEndTime) {
Matt Buckley1809d902022-08-05 06:51:43 +0000404 mLastSfPresentEndTime = presentEndTime;
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700405 mLastPresentFenceTime = presentFenceTime;
406}
407
Matt Buckley2fa85012022-08-30 22:38:45 +0000408void PowerAdvisor::setFrameDelay(Duration frameDelayDuration) {
Matt Buckley50c44062022-01-17 20:48:10 +0000409 mFrameDelayDuration = frameDelayDuration;
410}
411
Matt Buckley2fa85012022-08-30 22:38:45 +0000412void PowerAdvisor::setHwcPresentDelayedTime(DisplayId displayId, TimePoint earliestFrameStartTime) {
413 mDisplayTimingData[displayId].hwcPresentDelayedTime = earliestFrameStartTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000414}
415
Matt Buckley2fa85012022-08-30 22:38:45 +0000416void PowerAdvisor::setCommitStart(TimePoint commitStartTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000417 mCommitStartTimes.append(commitStartTime);
418}
419
Matt Buckley2fa85012022-08-30 22:38:45 +0000420void PowerAdvisor::setCompositeEnd(TimePoint compositeEndTime) {
421 mLastPostcompDuration = compositeEndTime - mLastSfPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000422}
423
424void PowerAdvisor::setDisplays(std::vector<DisplayId>& displayIds) {
425 mDisplayIds = displayIds;
426}
427
Matt Buckley2fa85012022-08-30 22:38:45 +0000428void PowerAdvisor::setTotalFrameTargetWorkDuration(Duration targetDuration) {
Matt Buckley50c44062022-01-17 20:48:10 +0000429 mTotalFrameTargetDuration = targetDuration;
430}
431
432std::vector<DisplayId> PowerAdvisor::getOrderedDisplayIds(
Matt Buckley2fa85012022-08-30 22:38:45 +0000433 std::optional<TimePoint> DisplayTimingData::*sortBy) {
Matt Buckley50c44062022-01-17 20:48:10 +0000434 std::vector<DisplayId> sortedDisplays;
435 std::copy_if(mDisplayIds.begin(), mDisplayIds.end(), std::back_inserter(sortedDisplays),
436 [&](DisplayId id) {
437 return mDisplayTimingData.count(id) &&
438 (mDisplayTimingData[id].*sortBy).has_value();
439 });
440 std::sort(sortedDisplays.begin(), sortedDisplays.end(), [&](DisplayId idA, DisplayId idB) {
441 return *(mDisplayTimingData[idA].*sortBy) < *(mDisplayTimingData[idB].*sortBy);
442 });
443 return sortedDisplays;
444}
445
Matt Buckley0538cae2022-11-08 23:12:04 +0000446std::optional<Duration> PowerAdvisor::estimateWorkDuration() {
447 if (!mExpectedPresentTimes.isFull() || !mCommitStartTimes.isFull()) {
Matt Buckley50c44062022-01-17 20:48:10 +0000448 return std::nullopt;
449 }
450
451 // Tracks when we finish presenting to hwc
Matt Buckley0538cae2022-11-08 23:12:04 +0000452 TimePoint estimatedHwcEndTime = mCommitStartTimes[0];
Matt Buckley50c44062022-01-17 20:48:10 +0000453
454 // How long we spent this frame not doing anything, waiting for fences or vsync
Matt Buckley2fa85012022-08-30 22:38:45 +0000455 Duration idleDuration = 0ns;
Matt Buckley50c44062022-01-17 20:48:10 +0000456
457 // Most recent previous gpu end time in the current frame, probably from a prior display, used
458 // 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 +0000459 std::optional<TimePoint> previousValidGpuEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000460
461 // The currently estimated gpu end time for the frame,
462 // used to accumulate gpu time as we iterate over the active displays
Matt Buckley2fa85012022-08-30 22:38:45 +0000463 std::optional<TimePoint> estimatedGpuEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000464
Matt Buckley50c44062022-01-17 20:48:10 +0000465 // The timing info for the previously calculated display, if there was one
Matt Buckley0538cae2022-11-08 23:12:04 +0000466 std::optional<DisplayTimeline> previousDisplayTiming;
Matt Buckley50c44062022-01-17 20:48:10 +0000467 std::vector<DisplayId>&& displayIds =
Matt Buckley16dec1f2022-06-07 21:46:20 +0000468 getOrderedDisplayIds(&DisplayTimingData::hwcPresentStartTime);
Matt Buckley0538cae2022-11-08 23:12:04 +0000469 DisplayTimeline displayTiming;
Matt Buckley50c44062022-01-17 20:48:10 +0000470
Matt Buckley1809d902022-08-05 06:51:43 +0000471 // Iterate over the displays that use hwc in the same order they are presented
Matt Buckley50c44062022-01-17 20:48:10 +0000472 for (DisplayId displayId : displayIds) {
473 if (mDisplayTimingData.count(displayId) == 0) {
474 continue;
475 }
476
477 auto& displayData = mDisplayTimingData.at(displayId);
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700478
Matt Buckley0538cae2022-11-08 23:12:04 +0000479 displayTiming = displayData.calculateDisplayTimeline(mLastPresentFenceTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000480
Matt Buckley16dec1f2022-06-07 21:46:20 +0000481 // If this is the first display, include the duration before hwc present starts
Matt Buckley0538cae2022-11-08 23:12:04 +0000482 if (!previousDisplayTiming.has_value()) {
483 estimatedHwcEndTime += displayTiming.hwcPresentStartTime - mCommitStartTimes[0];
Matt Buckley16dec1f2022-06-07 21:46:20 +0000484 } else { // Otherwise add the time since last display's hwc present finished
Matt Buckley0538cae2022-11-08 23:12:04 +0000485 estimatedHwcEndTime +=
486 displayTiming.hwcPresentStartTime - previousDisplayTiming->hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000487 }
488
Matt Buckley50c44062022-01-17 20:48:10 +0000489 // Update predicted present finish time with this display's present time
Matt Buckley0538cae2022-11-08 23:12:04 +0000490 estimatedHwcEndTime = displayTiming.hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000491
492 // Track how long we spent waiting for the fence, can be excluded from the timing estimate
Matt Buckley0538cae2022-11-08 23:12:04 +0000493 idleDuration += displayTiming.probablyWaitsForPresentFence
494 ? mLastPresentFenceTime - displayTiming.presentFenceWaitStartTime
Matt Buckley2fa85012022-08-30 22:38:45 +0000495 : 0ns;
Matt Buckley50c44062022-01-17 20:48:10 +0000496
497 // Track how long we spent waiting to present, can be excluded from the timing estimate
Matt Buckley0538cae2022-11-08 23:12:04 +0000498 idleDuration += displayTiming.hwcPresentDelayDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000499
500 // Estimate the reference frame's gpu timing
501 auto gpuTiming = displayData.estimateGpuTiming(previousValidGpuEndTime);
502 if (gpuTiming.has_value()) {
503 previousValidGpuEndTime = gpuTiming->startTime + gpuTiming->duration;
504
505 // Estimate the prediction frame's gpu end time from the reference frame
Matt Buckley0538cae2022-11-08 23:12:04 +0000506 estimatedGpuEndTime = std::max(displayTiming.hwcPresentStartTime,
Matt Buckley2fa85012022-08-30 22:38:45 +0000507 estimatedGpuEndTime.value_or(TimePoint{0ns})) +
Matt Buckley50c44062022-01-17 20:48:10 +0000508 gpuTiming->duration;
509 }
Matt Buckley0538cae2022-11-08 23:12:04 +0000510 previousDisplayTiming = displayTiming;
Matt Buckley50c44062022-01-17 20:48:10 +0000511 }
Matt Buckley2fa85012022-08-30 22:38:45 +0000512 ATRACE_INT64("Idle duration", idleDuration.ns());
Matt Buckley50c44062022-01-17 20:48:10 +0000513
Matt Buckley0538cae2022-11-08 23:12:04 +0000514 TimePoint estimatedFlingerEndTime = mLastSfPresentEndTime;
Matt Buckley1809d902022-08-05 06:51:43 +0000515
Matt Buckley50c44062022-01-17 20:48:10 +0000516 // 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 +0000517 estimatedHwcEndTime -= idleDuration;
Matt Buckley1809d902022-08-05 06:51:43 +0000518 estimatedFlingerEndTime -= idleDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000519
520 // We finish the frame when both present and the gpu are done, so wait for the later of the two
521 // Also add the frame delay duration since the target did not move while we were delayed
Matt Buckley2fa85012022-08-30 22:38:45 +0000522 Duration totalDuration = mFrameDelayDuration +
Matt Buckley0538cae2022-11-08 23:12:04 +0000523 std::max(estimatedHwcEndTime, estimatedGpuEndTime.value_or(TimePoint{0ns})) -
Matt Buckley2fa85012022-08-30 22:38:45 +0000524 mCommitStartTimes[0];
Matt Buckley50c44062022-01-17 20:48:10 +0000525
526 // We finish SurfaceFlinger when post-composition finishes, so add that in here
Matt Buckley2fa85012022-08-30 22:38:45 +0000527 Duration flingerDuration =
Matt Buckley1809d902022-08-05 06:51:43 +0000528 estimatedFlingerEndTime + mLastPostcompDuration - mCommitStartTimes[0];
529
530 // Combine the two timings into a single normalized one
Matt Buckley2fa85012022-08-30 22:38:45 +0000531 Duration combinedDuration = combineTimingEstimates(totalDuration, flingerDuration);
Matt Buckley50c44062022-01-17 20:48:10 +0000532
533 return std::make_optional(combinedDuration);
534}
535
Matt Buckley2fa85012022-08-30 22:38:45 +0000536Duration PowerAdvisor::combineTimingEstimates(Duration totalDuration, Duration flingerDuration) {
537 Duration targetDuration{0ns};
Matt Buckley0538cae2022-11-08 23:12:04 +0000538 targetDuration = mTargetDuration;
Matt Buckley50c44062022-01-17 20:48:10 +0000539 if (!mTotalFrameTargetDuration.has_value()) return flingerDuration;
540
541 // Normalize total to the flinger target (vsync period) since that's how often we actually send
542 // hints
Matt Buckley2fa85012022-08-30 22:38:45 +0000543 Duration normalizedTotalDuration = Duration::fromNs((targetDuration.ns() * totalDuration.ns()) /
544 mTotalFrameTargetDuration->ns());
Matt Buckley50c44062022-01-17 20:48:10 +0000545 return std::max(flingerDuration, normalizedTotalDuration);
546}
547
Matt Buckley50c44062022-01-17 20:48:10 +0000548PowerAdvisor::DisplayTimeline PowerAdvisor::DisplayTimingData::calculateDisplayTimeline(
Matt Buckley2fa85012022-08-30 22:38:45 +0000549 TimePoint fenceTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000550 DisplayTimeline timeline;
Matt Buckley16dec1f2022-06-07 21:46:20 +0000551 // How long between calling hwc present and trying to wait on the fence
Matt Buckley2fa85012022-08-30 22:38:45 +0000552 const Duration fenceWaitStartDelay =
553 (skippedValidate ? kFenceWaitStartDelaySkippedValidate : kFenceWaitStartDelayValidated);
Matt Buckley50c44062022-01-17 20:48:10 +0000554
Matt Buckley16dec1f2022-06-07 21:46:20 +0000555 // Did our reference frame wait for an appropriate vsync before calling into hwc
556 const bool waitedOnHwcPresentTime = hwcPresentDelayedTime.has_value() &&
557 *hwcPresentDelayedTime > *hwcPresentStartTime &&
558 *hwcPresentDelayedTime < *hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000559
560 // Use validate start here if we skipped it because we did validate + present together
Matt Buckley16dec1f2022-06-07 21:46:20 +0000561 timeline.hwcPresentStartTime = skippedValidate ? *hwcValidateStartTime : *hwcPresentStartTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000562
563 // Use validate end here if we skipped it because we did validate + present together
Matt Buckley16dec1f2022-06-07 21:46:20 +0000564 timeline.hwcPresentEndTime = skippedValidate ? *hwcValidateEndTime : *hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000565
Matt Buckley16dec1f2022-06-07 21:46:20 +0000566 // How long hwc present was delayed waiting for the next appropriate vsync
567 timeline.hwcPresentDelayDuration =
Matt Buckley2fa85012022-08-30 22:38:45 +0000568 (waitedOnHwcPresentTime ? *hwcPresentDelayedTime - *hwcPresentStartTime : 0ns);
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700569 // When we started waiting for the present fence after calling into hwc present
570 timeline.presentFenceWaitStartTime =
Matt Buckley16dec1f2022-06-07 21:46:20 +0000571 timeline.hwcPresentStartTime + timeline.hwcPresentDelayDuration + fenceWaitStartDelay;
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700572 timeline.probablyWaitsForPresentFence = fenceTime > timeline.presentFenceWaitStartTime &&
Matt Buckley16dec1f2022-06-07 21:46:20 +0000573 fenceTime < timeline.hwcPresentEndTime;
Matt Buckley50c44062022-01-17 20:48:10 +0000574
Matt Buckley16dec1f2022-06-07 21:46:20 +0000575 // How long we ran after we finished waiting for the fence but before hwc present finished
Matt Buckleyc6b9d382022-06-17 15:28:07 -0700576 timeline.postPresentFenceHwcPresentDuration = timeline.hwcPresentEndTime -
577 (timeline.probablyWaitsForPresentFence ? fenceTime
578 : timeline.presentFenceWaitStartTime);
Matt Buckley50c44062022-01-17 20:48:10 +0000579 return timeline;
580}
581
582std::optional<PowerAdvisor::GpuTimeline> PowerAdvisor::DisplayTimingData::estimateGpuTiming(
Matt Buckley2fa85012022-08-30 22:38:45 +0000583 std::optional<TimePoint> previousEndTime) {
Matt Buckley50c44062022-01-17 20:48:10 +0000584 if (!(usedClientComposition && lastValidGpuStartTime.has_value() && gpuEndFenceTime)) {
585 return std::nullopt;
586 }
Matt Buckley2fa85012022-08-30 22:38:45 +0000587 const TimePoint latestGpuStartTime =
588 std::max(previousEndTime.value_or(TimePoint{0ns}), *gpuStartTime);
589 const nsecs_t gpuEndFenceSignal = gpuEndFenceTime->getSignalTime();
590 Duration gpuDuration{0ns};
591 if (gpuEndFenceSignal != Fence::SIGNAL_TIME_INVALID &&
592 gpuEndFenceSignal != Fence::SIGNAL_TIME_PENDING) {
593 const TimePoint latestGpuEndTime = TimePoint::fromNs(gpuEndFenceSignal);
594
Matt Buckley50c44062022-01-17 20:48:10 +0000595 // If we know how long the most recent gpu duration was, use that
596 gpuDuration = latestGpuEndTime - latestGpuStartTime;
597 } else if (lastValidGpuEndTime.has_value()) {
598 // If we don't have the fence data, use the most recent information we do have
599 gpuDuration = *lastValidGpuEndTime - *lastValidGpuStartTime;
Matt Buckley2fa85012022-08-30 22:38:45 +0000600 if (gpuEndFenceSignal == Fence::SIGNAL_TIME_PENDING) {
Matt Buckley50c44062022-01-17 20:48:10 +0000601 // If pending but went over the previous duration, use current time as the end
Matt Buckley2fa85012022-08-30 22:38:45 +0000602 gpuDuration = std::max(gpuDuration, Duration{TimePoint::now() - latestGpuStartTime});
Matt Buckley50c44062022-01-17 20:48:10 +0000603 }
604 }
605 return GpuTimeline{.duration = gpuDuration, .startTime = latestGpuStartTime};
606}
607
Matt Buckley0538cae2022-11-08 23:12:04 +0000608const bool PowerAdvisor::sTraceHintSessionData =
Matt Buckleyef51fba2021-10-12 19:30:12 +0000609 base::GetBoolProperty(std::string("debug.sf.trace_hint_sessions"), false);
610
Matt Buckleyac15a1b2023-02-28 06:51:28 +0000611const Duration PowerAdvisor::sTargetSafetyMargin = std::chrono::microseconds(
612 base::GetIntProperty<int64_t>("debug.sf.hint_margin_us",
613 ticks<std::micro>(PowerAdvisor::kDefaultTargetSafetyMargin)));
614
Matt Buckley676e4392023-05-25 22:09:26 +0000615const bool PowerAdvisor::sUseReportActualDuration =
616 base::GetBoolProperty(std::string("debug.adpf.use_report_actual_duration"), true);
617
Matt Buckley0538cae2022-11-08 23:12:04 +0000618power::PowerHalController& PowerAdvisor::getPowerHal() {
619 static std::once_flag halFlag;
620 std::call_once(halFlag, [this] { mPowerHal->init(); });
621 return *mPowerHal;
Michael Wright1509a232018-06-21 02:50:34 +0100622}
623
624} // namespace impl
625} // namespace Hwc2
626} // namespace android