586 lines
24 KiB
C++
586 lines
24 KiB
C++
/*
|
|
* Copyright 2018 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
|
|
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "PowerAdvisor"
|
|
|
|
#include <unistd.h>
|
|
#include <cinttypes>
|
|
#include <cstdint>
|
|
#include <optional>
|
|
|
|
#include <android-base/properties.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/Mutex.h>
|
|
#include <utils/Trace.h>
|
|
|
|
#include <android/hardware/power/IPower.h>
|
|
#include <android/hardware/power/IPowerHintSession.h>
|
|
#include <android/hardware/power/WorkDuration.h>
|
|
|
|
#include <binder/IServiceManager.h>
|
|
|
|
#include "../SurfaceFlingerProperties.h"
|
|
|
|
#include "PowerAdvisor.h"
|
|
#include "SurfaceFlinger.h"
|
|
|
|
#ifdef MTK_SF_HINT_DISPLAY_INFO
|
|
#include "DisplayHardware/PowerHalWrapper.h"
|
|
#endif
|
|
|
|
namespace android {
|
|
namespace Hwc2 {
|
|
|
|
PowerAdvisor::~PowerAdvisor() = default;
|
|
|
|
namespace impl {
|
|
|
|
using android::hardware::power::Boost;
|
|
using android::hardware::power::IPowerHintSession;
|
|
using android::hardware::power::Mode;
|
|
using android::hardware::power::SessionHint;
|
|
using android::hardware::power::WorkDuration;
|
|
|
|
PowerAdvisor::~PowerAdvisor() = default;
|
|
|
|
namespace {
|
|
std::chrono::milliseconds getUpdateTimeout() {
|
|
// Default to a timeout of 80ms if nothing else is specified
|
|
static std::chrono::milliseconds timeout =
|
|
std::chrono::milliseconds(sysprop::display_update_imminent_timeout_ms(80));
|
|
return timeout;
|
|
}
|
|
|
|
void traceExpensiveRendering(bool enabled) {
|
|
if (enabled) {
|
|
ATRACE_ASYNC_BEGIN("ExpensiveRendering", 0);
|
|
} else {
|
|
ATRACE_ASYNC_END("ExpensiveRendering", 0);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
PowerAdvisor::PowerAdvisor(SurfaceFlinger& flinger)
|
|
: mPowerHal(std::make_unique<power::PowerHalController>()), mFlinger(flinger) {
|
|
#ifdef MTK_SF_HINT_DISPLAY_INFO
|
|
PowerHalWrapper::getInstance();
|
|
#endif
|
|
if (getUpdateTimeout() > 0ms) {
|
|
mScreenUpdateTimer.emplace("UpdateImminentTimer", getUpdateTimeout(),
|
|
/* resetCallback */ nullptr,
|
|
/* timeoutCallback */
|
|
[this] {
|
|
while (true) {
|
|
auto timeSinceLastUpdate = std::chrono::nanoseconds(
|
|
systemTime() - mLastScreenUpdatedTime.load());
|
|
if (timeSinceLastUpdate >= getUpdateTimeout()) {
|
|
break;
|
|
}
|
|
// We may try to disable expensive rendering and allow
|
|
// for sending DISPLAY_UPDATE_IMMINENT hints too early if
|
|
// we idled very shortly after updating the screen, so
|
|
// make sure we wait enough time.
|
|
std::this_thread::sleep_for(getUpdateTimeout() -
|
|
timeSinceLastUpdate);
|
|
}
|
|
mSendUpdateImminent.store(true);
|
|
mFlinger.disableExpensiveRendering();
|
|
});
|
|
}
|
|
}
|
|
|
|
void PowerAdvisor::init() {
|
|
// Defer starting the screen update timer until SurfaceFlinger finishes construction.
|
|
if (mScreenUpdateTimer) {
|
|
mScreenUpdateTimer->start();
|
|
}
|
|
}
|
|
|
|
void PowerAdvisor::onBootFinished() {
|
|
mBootFinished.store(true);
|
|
}
|
|
|
|
void PowerAdvisor::setExpensiveRenderingExpected(DisplayId displayId, bool expected) {
|
|
if (!mHasExpensiveRendering) {
|
|
ALOGV("Skipped sending EXPENSIVE_RENDERING because HAL doesn't support it");
|
|
return;
|
|
}
|
|
if (expected) {
|
|
mExpensiveDisplays.insert(displayId);
|
|
} else {
|
|
mExpensiveDisplays.erase(displayId);
|
|
}
|
|
|
|
const bool expectsExpensiveRendering = !mExpensiveDisplays.empty();
|
|
if (mNotifiedExpensiveRendering != expectsExpensiveRendering) {
|
|
auto ret = getPowerHal().setMode(Mode::EXPENSIVE_RENDERING, expectsExpensiveRendering);
|
|
if (!ret.isOk()) {
|
|
if (ret.isUnsupported()) {
|
|
mHasExpensiveRendering = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
mNotifiedExpensiveRendering = expectsExpensiveRendering;
|
|
traceExpensiveRendering(mNotifiedExpensiveRendering);
|
|
}
|
|
}
|
|
|
|
void PowerAdvisor::notifyDisplayUpdateImminentAndCpuReset() {
|
|
// Only start sending this notification once the system has booted so we don't introduce an
|
|
// early-boot dependency on Power HAL
|
|
if (!mBootFinished.load()) {
|
|
return;
|
|
}
|
|
|
|
if (mSendUpdateImminent.exchange(false)) {
|
|
ALOGV("AIDL notifyDisplayUpdateImminentAndCpuReset");
|
|
if (usePowerHintSession() && ensurePowerHintSessionRunning()) {
|
|
std::lock_guard lock(mHintSessionMutex);
|
|
auto ret = mHintSession->sendHint(SessionHint::CPU_LOAD_RESET);
|
|
if (!ret.isOk()) {
|
|
mHintSessionRunning = false;
|
|
}
|
|
}
|
|
|
|
if (!mHasDisplayUpdateImminent) {
|
|
ALOGV("Skipped sending DISPLAY_UPDATE_IMMINENT because HAL doesn't support it");
|
|
} else {
|
|
auto ret = getPowerHal().setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 0);
|
|
if (ret.isUnsupported()) {
|
|
mHasDisplayUpdateImminent = false;
|
|
}
|
|
}
|
|
|
|
if (mScreenUpdateTimer) {
|
|
mScreenUpdateTimer->reset();
|
|
} else {
|
|
// If we don't have a screen update timer, then we don't throttle power hal calls so
|
|
// flip this bit back to allow for calling into power hal again.
|
|
mSendUpdateImminent.store(true);
|
|
}
|
|
}
|
|
|
|
if (mScreenUpdateTimer) {
|
|
mLastScreenUpdatedTime.store(systemTime());
|
|
}
|
|
}
|
|
|
|
// checks both if it supports and if it's enabled
|
|
bool PowerAdvisor::usePowerHintSession() {
|
|
// uses cached value since the underlying support and flag are unlikely to change at runtime
|
|
return mHintSessionEnabled.value_or(false) && supportsPowerHintSession();
|
|
}
|
|
|
|
bool PowerAdvisor::supportsPowerHintSession() {
|
|
// cache to avoid needing lock every time
|
|
if (!mSupportsHintSession.has_value()) {
|
|
mSupportsHintSession = getPowerHal().getHintSessionPreferredRate().isOk();
|
|
}
|
|
return *mSupportsHintSession;
|
|
}
|
|
|
|
bool PowerAdvisor::ensurePowerHintSessionRunning() {
|
|
if (!mHintSessionRunning && !mHintSessionThreadIds.empty() && usePowerHintSession()) {
|
|
startPowerHintSession(mHintSessionThreadIds);
|
|
}
|
|
return mHintSessionRunning;
|
|
}
|
|
|
|
void PowerAdvisor::updateTargetWorkDuration(Duration targetDuration) {
|
|
if (!usePowerHintSession()) {
|
|
ALOGV("Power hint session target duration cannot be set, skipping");
|
|
return;
|
|
}
|
|
ATRACE_CALL();
|
|
{
|
|
mTargetDuration = targetDuration;
|
|
if (sTraceHintSessionData) ATRACE_INT64("Time target", targetDuration.ns());
|
|
if (ensurePowerHintSessionRunning() && (targetDuration != mLastTargetDurationSent)) {
|
|
ALOGV("Sending target time: %" PRId64 "ns", targetDuration.ns());
|
|
mLastTargetDurationSent = targetDuration;
|
|
std::lock_guard lock(mHintSessionMutex);
|
|
auto ret = mHintSession->updateTargetWorkDuration(targetDuration.ns());
|
|
if (!ret.isOk()) {
|
|
ALOGW("Failed to set power hint target work duration with error: %s",
|
|
ret.exceptionMessage().c_str());
|
|
mHintSessionRunning = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PowerAdvisor::reportActualWorkDuration() {
|
|
if (!mBootFinished || !sUseReportActualDuration || !usePowerHintSession()) {
|
|
ALOGV("Actual work duration power hint cannot be sent, skipping");
|
|
return;
|
|
}
|
|
ATRACE_CALL();
|
|
std::optional<Duration> actualDuration = estimateWorkDuration();
|
|
if (!actualDuration.has_value() || actualDuration < 0ns || !ensurePowerHintSessionRunning()) {
|
|
ALOGV("Failed to send actual work duration, skipping");
|
|
return;
|
|
}
|
|
actualDuration = std::make_optional(*actualDuration + sTargetSafetyMargin);
|
|
mActualDuration = actualDuration;
|
|
WorkDuration duration;
|
|
duration.durationNanos = actualDuration->ns();
|
|
duration.timeStampNanos = TimePoint::now().ns();
|
|
mHintSessionQueue.push_back(duration);
|
|
|
|
if (sTraceHintSessionData) {
|
|
ATRACE_INT64("Measured duration", actualDuration->ns());
|
|
ATRACE_INT64("Target error term", Duration{*actualDuration - mTargetDuration}.ns());
|
|
ATRACE_INT64("Reported duration", actualDuration->ns());
|
|
ATRACE_INT64("Reported target", mLastTargetDurationSent.ns());
|
|
ATRACE_INT64("Reported target error term",
|
|
Duration{*actualDuration - mLastTargetDurationSent}.ns());
|
|
}
|
|
|
|
ALOGV("Sending actual work duration of: %" PRId64 " on reported target: %" PRId64
|
|
" with error: %" PRId64,
|
|
actualDuration->ns(), mLastTargetDurationSent.ns(),
|
|
Duration{*actualDuration - mLastTargetDurationSent}.ns());
|
|
|
|
{
|
|
std::lock_guard lock(mHintSessionMutex);
|
|
auto ret = mHintSession->reportActualWorkDuration(mHintSessionQueue);
|
|
if (!ret.isOk()) {
|
|
ALOGW("Failed to report actual work durations with error: %s",
|
|
ret.exceptionMessage().c_str());
|
|
mHintSessionRunning = false;
|
|
return;
|
|
}
|
|
}
|
|
mHintSessionQueue.clear();
|
|
}
|
|
|
|
void PowerAdvisor::enablePowerHintSession(bool enabled) {
|
|
mHintSessionEnabled = enabled;
|
|
}
|
|
|
|
bool PowerAdvisor::startPowerHintSession(const std::vector<int32_t>& threadIds) {
|
|
if (!mBootFinished.load()) {
|
|
return false;
|
|
}
|
|
if (!usePowerHintSession()) {
|
|
ALOGI("Cannot start power hint session: disabled or unsupported");
|
|
return false;
|
|
}
|
|
if (mHintSessionRunning) {
|
|
ALOGE("Cannot start power hint session: already running");
|
|
return false;
|
|
}
|
|
LOG_ALWAYS_FATAL_IF(threadIds.empty(), "No thread IDs provided to power hint session!");
|
|
{
|
|
std::lock_guard lock(mHintSessionMutex);
|
|
mHintSession = nullptr;
|
|
mHintSessionThreadIds = threadIds;
|
|
|
|
auto ret = getPowerHal().createHintSession(getpid(), static_cast<int32_t>(getuid()),
|
|
threadIds, mTargetDuration.ns());
|
|
|
|
if (ret.isOk()) {
|
|
mHintSessionRunning = true;
|
|
mHintSession = ret.value();
|
|
}
|
|
}
|
|
return mHintSessionRunning;
|
|
}
|
|
|
|
void PowerAdvisor::setGpuFenceTime(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime) {
|
|
DisplayTimingData& displayData = mDisplayTimingData[displayId];
|
|
if (displayData.gpuEndFenceTime) {
|
|
nsecs_t signalTime = displayData.gpuEndFenceTime->getSignalTime();
|
|
if (signalTime != Fence::SIGNAL_TIME_INVALID && signalTime != Fence::SIGNAL_TIME_PENDING) {
|
|
for (auto&& [_, otherDisplayData] : mDisplayTimingData) {
|
|
// If the previous display started before us but ended after we should have
|
|
// started, then it likely delayed our start time and we must compensate for that.
|
|
// Displays finishing earlier should have already made their way through this call
|
|
// and swapped their timing into "lastValid" from "latest", so we check that here.
|
|
if (!otherDisplayData.lastValidGpuStartTime.has_value()) continue;
|
|
if ((*otherDisplayData.lastValidGpuStartTime < *displayData.gpuStartTime) &&
|
|
(*otherDisplayData.lastValidGpuEndTime > *displayData.gpuStartTime)) {
|
|
displayData.lastValidGpuStartTime = *otherDisplayData.lastValidGpuEndTime;
|
|
break;
|
|
}
|
|
}
|
|
displayData.lastValidGpuStartTime = displayData.gpuStartTime;
|
|
displayData.lastValidGpuEndTime = TimePoint::fromNs(signalTime);
|
|
}
|
|
}
|
|
displayData.gpuEndFenceTime = std::move(fenceTime);
|
|
displayData.gpuStartTime = TimePoint::now();
|
|
}
|
|
|
|
void PowerAdvisor::setHwcValidateTiming(DisplayId displayId, TimePoint validateStartTime,
|
|
TimePoint validateEndTime) {
|
|
DisplayTimingData& displayData = mDisplayTimingData[displayId];
|
|
displayData.hwcValidateStartTime = validateStartTime;
|
|
displayData.hwcValidateEndTime = validateEndTime;
|
|
}
|
|
|
|
void PowerAdvisor::setHwcPresentTiming(DisplayId displayId, TimePoint presentStartTime,
|
|
TimePoint presentEndTime) {
|
|
DisplayTimingData& displayData = mDisplayTimingData[displayId];
|
|
displayData.hwcPresentStartTime = presentStartTime;
|
|
displayData.hwcPresentEndTime = presentEndTime;
|
|
}
|
|
|
|
void PowerAdvisor::setSkippedValidate(DisplayId displayId, bool skipped) {
|
|
mDisplayTimingData[displayId].skippedValidate = skipped;
|
|
}
|
|
|
|
void PowerAdvisor::setRequiresClientComposition(DisplayId displayId,
|
|
bool requiresClientComposition) {
|
|
mDisplayTimingData[displayId].usedClientComposition = requiresClientComposition;
|
|
}
|
|
|
|
void PowerAdvisor::setExpectedPresentTime(TimePoint expectedPresentTime) {
|
|
mExpectedPresentTimes.append(expectedPresentTime);
|
|
}
|
|
|
|
void PowerAdvisor::setSfPresentTiming(TimePoint presentFenceTime, TimePoint presentEndTime) {
|
|
mLastSfPresentEndTime = presentEndTime;
|
|
mLastPresentFenceTime = presentFenceTime;
|
|
}
|
|
|
|
void PowerAdvisor::setFrameDelay(Duration frameDelayDuration) {
|
|
mFrameDelayDuration = frameDelayDuration;
|
|
}
|
|
|
|
void PowerAdvisor::setHwcPresentDelayedTime(DisplayId displayId, TimePoint earliestFrameStartTime) {
|
|
mDisplayTimingData[displayId].hwcPresentDelayedTime = earliestFrameStartTime;
|
|
}
|
|
|
|
void PowerAdvisor::setCommitStart(TimePoint commitStartTime) {
|
|
mCommitStartTimes.append(commitStartTime);
|
|
}
|
|
|
|
void PowerAdvisor::setCompositeEnd(TimePoint compositeEndTime) {
|
|
mLastPostcompDuration = compositeEndTime - mLastSfPresentEndTime;
|
|
}
|
|
|
|
void PowerAdvisor::setDisplays(std::vector<DisplayId>& displayIds) {
|
|
mDisplayIds = displayIds;
|
|
}
|
|
|
|
void PowerAdvisor::setTotalFrameTargetWorkDuration(Duration targetDuration) {
|
|
mTotalFrameTargetDuration = targetDuration;
|
|
}
|
|
|
|
std::vector<DisplayId> PowerAdvisor::getOrderedDisplayIds(
|
|
std::optional<TimePoint> DisplayTimingData::*sortBy) {
|
|
std::vector<DisplayId> sortedDisplays;
|
|
std::copy_if(mDisplayIds.begin(), mDisplayIds.end(), std::back_inserter(sortedDisplays),
|
|
[&](DisplayId id) {
|
|
return mDisplayTimingData.count(id) &&
|
|
(mDisplayTimingData[id].*sortBy).has_value();
|
|
});
|
|
std::sort(sortedDisplays.begin(), sortedDisplays.end(), [&](DisplayId idA, DisplayId idB) {
|
|
return *(mDisplayTimingData[idA].*sortBy) < *(mDisplayTimingData[idB].*sortBy);
|
|
});
|
|
return sortedDisplays;
|
|
}
|
|
|
|
std::optional<Duration> PowerAdvisor::estimateWorkDuration() {
|
|
if (!mExpectedPresentTimes.isFull() || !mCommitStartTimes.isFull()) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
// Tracks when we finish presenting to hwc
|
|
TimePoint estimatedHwcEndTime = mCommitStartTimes[0];
|
|
|
|
// How long we spent this frame not doing anything, waiting for fences or vsync
|
|
Duration idleDuration = 0ns;
|
|
|
|
// Most recent previous gpu end time in the current frame, probably from a prior display, used
|
|
// as the start time for the next gpu operation if it ran over time since it probably blocked
|
|
std::optional<TimePoint> previousValidGpuEndTime;
|
|
|
|
// The currently estimated gpu end time for the frame,
|
|
// used to accumulate gpu time as we iterate over the active displays
|
|
std::optional<TimePoint> estimatedGpuEndTime;
|
|
|
|
// The timing info for the previously calculated display, if there was one
|
|
std::optional<DisplayTimeline> previousDisplayTiming;
|
|
std::vector<DisplayId>&& displayIds =
|
|
getOrderedDisplayIds(&DisplayTimingData::hwcPresentStartTime);
|
|
DisplayTimeline displayTiming;
|
|
|
|
// Iterate over the displays that use hwc in the same order they are presented
|
|
for (DisplayId displayId : displayIds) {
|
|
if (mDisplayTimingData.count(displayId) == 0) {
|
|
continue;
|
|
}
|
|
|
|
auto& displayData = mDisplayTimingData.at(displayId);
|
|
|
|
displayTiming = displayData.calculateDisplayTimeline(mLastPresentFenceTime);
|
|
|
|
// If this is the first display, include the duration before hwc present starts
|
|
if (!previousDisplayTiming.has_value()) {
|
|
estimatedHwcEndTime += displayTiming.hwcPresentStartTime - mCommitStartTimes[0];
|
|
} else { // Otherwise add the time since last display's hwc present finished
|
|
estimatedHwcEndTime +=
|
|
displayTiming.hwcPresentStartTime - previousDisplayTiming->hwcPresentEndTime;
|
|
}
|
|
|
|
// Update predicted present finish time with this display's present time
|
|
estimatedHwcEndTime = displayTiming.hwcPresentEndTime;
|
|
|
|
// Track how long we spent waiting for the fence, can be excluded from the timing estimate
|
|
idleDuration += displayTiming.probablyWaitsForPresentFence
|
|
? mLastPresentFenceTime - displayTiming.presentFenceWaitStartTime
|
|
: 0ns;
|
|
|
|
// Track how long we spent waiting to present, can be excluded from the timing estimate
|
|
idleDuration += displayTiming.hwcPresentDelayDuration;
|
|
|
|
// Estimate the reference frame's gpu timing
|
|
auto gpuTiming = displayData.estimateGpuTiming(previousValidGpuEndTime);
|
|
if (gpuTiming.has_value()) {
|
|
previousValidGpuEndTime = gpuTiming->startTime + gpuTiming->duration;
|
|
|
|
// Estimate the prediction frame's gpu end time from the reference frame
|
|
estimatedGpuEndTime = std::max(displayTiming.hwcPresentStartTime,
|
|
estimatedGpuEndTime.value_or(TimePoint{0ns})) +
|
|
gpuTiming->duration;
|
|
}
|
|
previousDisplayTiming = displayTiming;
|
|
}
|
|
ATRACE_INT64("Idle duration", idleDuration.ns());
|
|
|
|
TimePoint estimatedFlingerEndTime = mLastSfPresentEndTime;
|
|
|
|
// Don't count time spent idly waiting in the estimate as we could do more work in that time
|
|
estimatedHwcEndTime -= idleDuration;
|
|
estimatedFlingerEndTime -= idleDuration;
|
|
|
|
// We finish the frame when both present and the gpu are done, so wait for the later of the two
|
|
// Also add the frame delay duration since the target did not move while we were delayed
|
|
Duration totalDuration = mFrameDelayDuration +
|
|
std::max(estimatedHwcEndTime, estimatedGpuEndTime.value_or(TimePoint{0ns})) -
|
|
mCommitStartTimes[0];
|
|
|
|
// We finish SurfaceFlinger when post-composition finishes, so add that in here
|
|
Duration flingerDuration =
|
|
estimatedFlingerEndTime + mLastPostcompDuration - mCommitStartTimes[0];
|
|
|
|
// Combine the two timings into a single normalized one
|
|
Duration combinedDuration = combineTimingEstimates(totalDuration, flingerDuration);
|
|
|
|
return std::make_optional(combinedDuration);
|
|
}
|
|
|
|
Duration PowerAdvisor::combineTimingEstimates(Duration totalDuration, Duration flingerDuration) {
|
|
Duration targetDuration{0ns};
|
|
targetDuration = mTargetDuration;
|
|
if (!mTotalFrameTargetDuration.has_value()) return flingerDuration;
|
|
|
|
// Normalize total to the flinger target (vsync period) since that's how often we actually send
|
|
// hints
|
|
Duration normalizedTotalDuration = Duration::fromNs((targetDuration.ns() * totalDuration.ns()) /
|
|
mTotalFrameTargetDuration->ns());
|
|
return std::max(flingerDuration, normalizedTotalDuration);
|
|
}
|
|
|
|
PowerAdvisor::DisplayTimeline PowerAdvisor::DisplayTimingData::calculateDisplayTimeline(
|
|
TimePoint fenceTime) {
|
|
DisplayTimeline timeline;
|
|
// How long between calling hwc present and trying to wait on the fence
|
|
const Duration fenceWaitStartDelay =
|
|
(skippedValidate ? kFenceWaitStartDelaySkippedValidate : kFenceWaitStartDelayValidated);
|
|
|
|
// Did our reference frame wait for an appropriate vsync before calling into hwc
|
|
const bool waitedOnHwcPresentTime = hwcPresentDelayedTime.has_value() &&
|
|
*hwcPresentDelayedTime > *hwcPresentStartTime &&
|
|
*hwcPresentDelayedTime < *hwcPresentEndTime;
|
|
|
|
// Use validate start here if we skipped it because we did validate + present together
|
|
timeline.hwcPresentStartTime = skippedValidate ? *hwcValidateStartTime : *hwcPresentStartTime;
|
|
|
|
// Use validate end here if we skipped it because we did validate + present together
|
|
timeline.hwcPresentEndTime = skippedValidate ? *hwcValidateEndTime : *hwcPresentEndTime;
|
|
|
|
// How long hwc present was delayed waiting for the next appropriate vsync
|
|
timeline.hwcPresentDelayDuration =
|
|
(waitedOnHwcPresentTime ? *hwcPresentDelayedTime - *hwcPresentStartTime : 0ns);
|
|
// When we started waiting for the present fence after calling into hwc present
|
|
timeline.presentFenceWaitStartTime =
|
|
timeline.hwcPresentStartTime + timeline.hwcPresentDelayDuration + fenceWaitStartDelay;
|
|
timeline.probablyWaitsForPresentFence = fenceTime > timeline.presentFenceWaitStartTime &&
|
|
fenceTime < timeline.hwcPresentEndTime;
|
|
|
|
// How long we ran after we finished waiting for the fence but before hwc present finished
|
|
timeline.postPresentFenceHwcPresentDuration = timeline.hwcPresentEndTime -
|
|
(timeline.probablyWaitsForPresentFence ? fenceTime
|
|
: timeline.presentFenceWaitStartTime);
|
|
return timeline;
|
|
}
|
|
|
|
std::optional<PowerAdvisor::GpuTimeline> PowerAdvisor::DisplayTimingData::estimateGpuTiming(
|
|
std::optional<TimePoint> previousEndTime) {
|
|
if (!(usedClientComposition && lastValidGpuStartTime.has_value() && gpuEndFenceTime)) {
|
|
return std::nullopt;
|
|
}
|
|
const TimePoint latestGpuStartTime =
|
|
std::max(previousEndTime.value_or(TimePoint{0ns}), *gpuStartTime);
|
|
const nsecs_t gpuEndFenceSignal = gpuEndFenceTime->getSignalTime();
|
|
Duration gpuDuration{0ns};
|
|
if (gpuEndFenceSignal != Fence::SIGNAL_TIME_INVALID &&
|
|
gpuEndFenceSignal != Fence::SIGNAL_TIME_PENDING) {
|
|
const TimePoint latestGpuEndTime = TimePoint::fromNs(gpuEndFenceSignal);
|
|
|
|
// If we know how long the most recent gpu duration was, use that
|
|
gpuDuration = latestGpuEndTime - latestGpuStartTime;
|
|
} else if (lastValidGpuEndTime.has_value()) {
|
|
// If we don't have the fence data, use the most recent information we do have
|
|
gpuDuration = *lastValidGpuEndTime - *lastValidGpuStartTime;
|
|
if (gpuEndFenceSignal == Fence::SIGNAL_TIME_PENDING) {
|
|
// If pending but went over the previous duration, use current time as the end
|
|
gpuDuration = std::max(gpuDuration, Duration{TimePoint::now() - latestGpuStartTime});
|
|
}
|
|
}
|
|
return GpuTimeline{.duration = gpuDuration, .startTime = latestGpuStartTime};
|
|
}
|
|
|
|
const bool PowerAdvisor::sTraceHintSessionData =
|
|
base::GetBoolProperty(std::string("debug.sf.trace_hint_sessions"), false);
|
|
|
|
const Duration PowerAdvisor::sTargetSafetyMargin = std::chrono::microseconds(
|
|
base::GetIntProperty<int64_t>("debug.sf.hint_margin_us",
|
|
ticks<std::micro>(PowerAdvisor::kDefaultTargetSafetyMargin)));
|
|
|
|
const bool PowerAdvisor::sUseReportActualDuration =
|
|
base::GetBoolProperty(std::string("debug.adpf.use_report_actual_duration"), true);
|
|
|
|
power::PowerHalController& PowerAdvisor::getPowerHal() {
|
|
static std::once_flag halFlag;
|
|
std::call_once(halFlag, [this] { mPowerHal->init(); });
|
|
return *mPowerHal;
|
|
}
|
|
|
|
} // namespace impl
|
|
} // namespace Hwc2
|
|
} // namespace android
|