Rewrite the PowerAdvisor using standard power wrappers and clean up
* Replace custom AIDL/HIDL wrappers with libpowermanager
* Remove early hint code as it is deprecated for load change hints
Bug: b/245975645
Bug: b/244358432
Test: atest libsurfaceflinger_unittest
Change-Id: I2a11779ce1f78bcf29ea0e7978cb8933e74e9f7b
diff --git a/services/powermanager/Android.bp b/services/powermanager/Android.bp
index 7fb33e5..b34e54f 100644
--- a/services/powermanager/Android.bp
+++ b/services/powermanager/Android.bp
@@ -43,6 +43,14 @@
"android.hardware.power-V4-cpp",
],
+ export_shared_lib_headers: [
+ "android.hardware.power@1.0",
+ "android.hardware.power@1.1",
+ "android.hardware.power@1.2",
+ "android.hardware.power@1.3",
+ "android.hardware.power-V4-cpp",
+ ],
+
cflags: [
"-Wall",
"-Werror",
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index fe7cff7..5683a92 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -47,8 +47,6 @@
"android.hardware.graphics.composer@2.2",
"android.hardware.graphics.composer@2.3",
"android.hardware.graphics.composer@2.4",
- "android.hardware.power@1.0",
- "android.hardware.power@1.3",
"android.hardware.power-V4-cpp",
"libbase",
"libbinder",
@@ -63,6 +61,7 @@
"liblayers_proto",
"liblog",
"libnativewindow",
+ "libpowermanager",
"libprocessgroup",
"libprotobuf-cpp-lite",
"libsync",
@@ -105,7 +104,7 @@
"android.hardware.graphics.composer@2.2",
"android.hardware.graphics.composer@2.3",
"android.hardware.graphics.composer@2.4",
- "android.hardware.power@1.3",
+ "libpowermanager",
"libhidlbase",
"libtimestats",
],
diff --git a/services/surfaceflinger/CompositionEngine/tests/MockPowerAdvisor.h b/services/surfaceflinger/CompositionEngine/tests/MockPowerAdvisor.h
index c555b39..961ec80 100644
--- a/services/surfaceflinger/CompositionEngine/tests/MockPowerAdvisor.h
+++ b/services/surfaceflinger/CompositionEngine/tests/MockPowerAdvisor.h
@@ -37,11 +37,10 @@
MOCK_METHOD(void, notifyDisplayUpdateImminentAndCpuReset, (), (override));
MOCK_METHOD(bool, usePowerHintSession, (), (override));
MOCK_METHOD(bool, supportsPowerHintSession, (), (override));
- MOCK_METHOD(bool, isPowerHintSessionRunning, (), (override));
- MOCK_METHOD(void, setTargetWorkDuration, (Duration targetDuration), (override));
- MOCK_METHOD(void, sendActualWorkDuration, (), (override));
- MOCK_METHOD(void, sendPredictedWorkDuration, (), (override));
- MOCK_METHOD(void, enablePowerHint, (bool enabled), (override));
+ MOCK_METHOD(bool, ensurePowerHintSessionRunning, (), (override));
+ MOCK_METHOD(void, updateTargetWorkDuration, (Duration targetDuration), (override));
+ MOCK_METHOD(void, reportActualWorkDuration, (), (override));
+ MOCK_METHOD(void, enablePowerHintSession, (bool enabled), (override));
MOCK_METHOD(bool, startPowerHintSession, (const std::vector<int32_t>& threadIds), (override));
MOCK_METHOD(void, setGpuFenceTime,
(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime), (override));
diff --git a/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp b/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
index 36f71bb..37b68c8 100644
--- a/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
+++ b/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
@@ -31,7 +31,7 @@
#include <utils/Mutex.h>
#include <utils/Trace.h>
-#include <android/hardware/power/1.3/IPower.h>
+#include <android/hardware/power/IPower.h>
#include <android/hardware/power/IPowerHintSession.h>
#include <android/hardware/power/WorkDuration.h>
@@ -49,12 +49,7 @@
namespace impl {
-namespace V1_0 = android::hardware::power::V1_0;
-namespace V1_3 = android::hardware::power::V1_3;
-using V1_3::PowerHint;
-
using android::hardware::power::Boost;
-using android::hardware::power::IPower;
using android::hardware::power::IPowerHintSession;
using android::hardware::power::Mode;
using android::hardware::power::SessionHint;
@@ -80,7 +75,8 @@
} // namespace
-PowerAdvisor::PowerAdvisor(SurfaceFlinger& flinger) : mFlinger(flinger) {
+PowerAdvisor::PowerAdvisor(SurfaceFlinger& flinger)
+ : mPowerHal(std::make_unique<power::PowerHalController>()), mFlinger(flinger) {
if (getUpdateTimeout() > 0ms) {
mScreenUpdateTimer.emplace("UpdateImminentTimer", getUpdateTimeout(),
/* resetCallback */ nullptr,
@@ -117,6 +113,10 @@
}
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 {
@@ -125,19 +125,16 @@
const bool expectsExpensiveRendering = !mExpensiveDisplays.empty();
if (mNotifiedExpensiveRendering != expectsExpensiveRendering) {
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- if (halWrapper == nullptr) {
- return;
- }
-
- if (!halWrapper->setExpensiveRendering(expectsExpensiveRendering)) {
- // The HAL has become unavailable; attempt to reconnect later
- mReconnectPowerHal = true;
+ auto ret = getPowerHal().setMode(Mode::EXPENSIVE_RENDERING, expectsExpensiveRendering);
+ if (!ret.isOk()) {
+ if (ret.isUnsupported()) {
+ mHasExpensiveRendering = false;
+ }
return;
}
mNotifiedExpensiveRendering = expectsExpensiveRendering;
+ traceExpensiveRendering(mNotifiedExpensiveRendering);
}
}
@@ -149,16 +146,22 @@
}
if (mSendUpdateImminent.exchange(false)) {
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- if (halWrapper == nullptr) {
- return;
+ 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 (!halWrapper->notifyDisplayUpdateImminentAndCpuReset()) {
- // The HAL has become unavailable; attempt to reconnect later
- mReconnectPowerHal = true;
- return;
+ 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) {
@@ -178,87 +181,123 @@
// 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 mPowerHintEnabled.value_or(false) && supportsPowerHintSession();
+ return mHintSessionEnabled.value_or(false) && supportsPowerHintSession();
}
bool PowerAdvisor::supportsPowerHintSession() {
// cache to avoid needing lock every time
- if (!mSupportsPowerHint.has_value()) {
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- mSupportsPowerHint = halWrapper && halWrapper->supportsPowerHintSession();
+ if (!mSupportsHintSession.has_value()) {
+ mSupportsHintSession = getPowerHal().getHintSessionPreferredRate().isOk();
}
- return *mSupportsPowerHint;
+ return *mSupportsHintSession;
}
-bool PowerAdvisor::isPowerHintSessionRunning() {
- return mPowerHintSessionRunning;
+bool PowerAdvisor::ensurePowerHintSessionRunning() {
+ if (!mHintSessionRunning && !mHintSessionThreadIds.empty() && usePowerHintSession()) {
+ startPowerHintSession(mHintSessionThreadIds);
+ }
+ return mHintSessionRunning;
}
-void PowerAdvisor::setTargetWorkDuration(Duration targetDuration) {
+void PowerAdvisor::updateTargetWorkDuration(Duration targetDuration) {
if (!usePowerHintSession()) {
ALOGV("Power hint session target duration cannot be set, skipping");
return;
}
+ ATRACE_CALL();
{
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- if (halWrapper != nullptr) {
- halWrapper->setTargetWorkDuration(targetDuration);
+ 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::sendActualWorkDuration() {
+void PowerAdvisor::reportActualWorkDuration() {
if (!mBootFinished || !usePowerHintSession()) {
ALOGV("Actual work duration power hint cannot be sent, skipping");
return;
}
- const std::optional<Duration> actualDuration = estimateWorkDuration(false);
- if (actualDuration.has_value()) {
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- if (halWrapper != nullptr) {
- halWrapper->sendActualWorkDuration(*actualDuration + sTargetSafetyMargin,
- TimePoint::now());
- }
- }
-}
-
-void PowerAdvisor::sendPredictedWorkDuration() {
- if (!mBootFinished || !usePowerHintSession()) {
- ALOGV("Actual work duration power hint cannot be sent, skipping");
+ 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);
- const std::optional<Duration> predictedDuration = estimateWorkDuration(true);
- if (predictedDuration.has_value()) {
- std::lock_guard lock(mPowerHalMutex);
- HalWrapper* const halWrapper = getPowerHal();
- if (halWrapper != nullptr) {
- halWrapper->sendActualWorkDuration(*predictedDuration + sTargetSafetyMargin,
- TimePoint::now());
+ 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::enablePowerHint(bool enabled) {
- mPowerHintEnabled = enabled;
+void PowerAdvisor::enablePowerHintSession(bool enabled) {
+ mHintSessionEnabled = enabled;
}
bool PowerAdvisor::startPowerHintSession(const std::vector<int32_t>& threadIds) {
- if (!usePowerHintSession()) {
- ALOGI("Power hint session cannot be started, skipping");
+ 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(mPowerHalMutex);
- HalWrapper* halWrapper = getPowerHal();
- if (halWrapper != nullptr && usePowerHintSession()) {
- halWrapper->setPowerHintSessionThreadIds(threadIds);
- mPowerHintSessionRunning = halWrapper->startPowerHintSession();
+ 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 mPowerHintSessionRunning;
+ return mHintSessionRunning;
}
void PowerAdvisor::setGpuFenceTime(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime) {
@@ -356,13 +395,13 @@
return sortedDisplays;
}
-std::optional<Duration> PowerAdvisor::estimateWorkDuration(bool earlyHint) {
- if (earlyHint && (!mExpectedPresentTimes.isFull() || !mCommitStartTimes.isFull())) {
+std::optional<Duration> PowerAdvisor::estimateWorkDuration() {
+ if (!mExpectedPresentTimes.isFull() || !mCommitStartTimes.isFull()) {
return std::nullopt;
}
// Tracks when we finish presenting to hwc
- TimePoint estimatedEndTime = mCommitStartTimes[0];
+ TimePoint estimatedHwcEndTime = mCommitStartTimes[0];
// How long we spent this frame not doing anything, waiting for fences or vsync
Duration idleDuration = 0ns;
@@ -375,21 +414,11 @@
// used to accumulate gpu time as we iterate over the active displays
std::optional<TimePoint> estimatedGpuEndTime;
- // If we're predicting at the start of the frame, we use last frame as our reference point
- // If we're predicting at the end of the frame, we use the current frame as a reference point
- TimePoint referenceFrameStartTime = (earlyHint ? mCommitStartTimes[-1] : mCommitStartTimes[0]);
-
- // When the prior frame should be presenting to the display
- // If we're predicting at the start of the frame, we use last frame's expected present time
- // If we're predicting at the end of the frame, the present fence time is already known
- TimePoint lastFramePresentTime =
- (earlyHint ? mExpectedPresentTimes[-1] : mLastPresentFenceTime);
-
// The timing info for the previously calculated display, if there was one
- std::optional<DisplayTimeline> previousDisplayReferenceTiming;
+ std::optional<DisplayTimeline> previousDisplayTiming;
std::vector<DisplayId>&& displayIds =
getOrderedDisplayIds(&DisplayTimingData::hwcPresentStartTime);
- DisplayTimeline referenceTiming, estimatedTiming;
+ DisplayTimeline displayTiming;
// Iterate over the displays that use hwc in the same order they are presented
for (DisplayId displayId : displayIds) {
@@ -399,35 +428,26 @@
auto& displayData = mDisplayTimingData.at(displayId);
- // mLastPresentFenceTime should always be the time of the reference frame, since it will be
- // the previous frame's present fence if called at the start, and current frame's if called
- // at the end
- referenceTiming = displayData.calculateDisplayTimeline(mLastPresentFenceTime);
+ displayTiming = displayData.calculateDisplayTimeline(mLastPresentFenceTime);
// If this is the first display, include the duration before hwc present starts
- if (!previousDisplayReferenceTiming.has_value()) {
- estimatedEndTime += referenceTiming.hwcPresentStartTime - referenceFrameStartTime;
+ if (!previousDisplayTiming.has_value()) {
+ estimatedHwcEndTime += displayTiming.hwcPresentStartTime - mCommitStartTimes[0];
} else { // Otherwise add the time since last display's hwc present finished
- estimatedEndTime += referenceTiming.hwcPresentStartTime -
- previousDisplayReferenceTiming->hwcPresentEndTime;
+ estimatedHwcEndTime +=
+ displayTiming.hwcPresentStartTime - previousDisplayTiming->hwcPresentEndTime;
}
- // Late hint can re-use reference timing here since it's estimating its own reference frame
- estimatedTiming = earlyHint
- ? referenceTiming.estimateTimelineFromReference(lastFramePresentTime,
- estimatedEndTime)
- : referenceTiming;
-
// Update predicted present finish time with this display's present time
- estimatedEndTime = estimatedTiming.hwcPresentEndTime;
+ estimatedHwcEndTime = displayTiming.hwcPresentEndTime;
// Track how long we spent waiting for the fence, can be excluded from the timing estimate
- idleDuration += estimatedTiming.probablyWaitsForPresentFence
- ? lastFramePresentTime - estimatedTiming.presentFenceWaitStartTime
+ idleDuration += displayTiming.probablyWaitsForPresentFence
+ ? mLastPresentFenceTime - displayTiming.presentFenceWaitStartTime
: 0ns;
// Track how long we spent waiting to present, can be excluded from the timing estimate
- idleDuration += earlyHint ? 0ns : referenceTiming.hwcPresentDelayDuration;
+ idleDuration += displayTiming.hwcPresentDelayDuration;
// Estimate the reference frame's gpu timing
auto gpuTiming = displayData.estimateGpuTiming(previousValidGpuEndTime);
@@ -435,24 +455,24 @@
previousValidGpuEndTime = gpuTiming->startTime + gpuTiming->duration;
// Estimate the prediction frame's gpu end time from the reference frame
- estimatedGpuEndTime = std::max(estimatedTiming.hwcPresentStartTime,
+ estimatedGpuEndTime = std::max(displayTiming.hwcPresentStartTime,
estimatedGpuEndTime.value_or(TimePoint{0ns})) +
gpuTiming->duration;
}
- previousDisplayReferenceTiming = referenceTiming;
+ previousDisplayTiming = displayTiming;
}
ATRACE_INT64("Idle duration", idleDuration.ns());
- TimePoint estimatedFlingerEndTime = earlyHint ? estimatedEndTime : mLastSfPresentEndTime;
+ TimePoint estimatedFlingerEndTime = mLastSfPresentEndTime;
// Don't count time spent idly waiting in the estimate as we could do more work in that time
- estimatedEndTime -= idleDuration;
+ 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(estimatedEndTime, estimatedGpuEndTime.value_or(TimePoint{0ns})) -
+ std::max(estimatedHwcEndTime, estimatedGpuEndTime.value_or(TimePoint{0ns})) -
mCommitStartTimes[0];
// We finish SurfaceFlinger when post-composition finishes, so add that in here
@@ -467,10 +487,7 @@
Duration PowerAdvisor::combineTimingEstimates(Duration totalDuration, Duration flingerDuration) {
Duration targetDuration{0ns};
- {
- std::lock_guard lock(mPowerHalMutex);
- targetDuration = *getPowerHal()->getTargetWorkDuration();
- }
+ targetDuration = mTargetDuration;
if (!mTotalFrameTargetDuration.has_value()) return flingerDuration;
// Normalize total to the flinger target (vsync period) since that's how often we actually send
@@ -480,26 +497,6 @@
return std::max(flingerDuration, normalizedTotalDuration);
}
-PowerAdvisor::DisplayTimeline PowerAdvisor::DisplayTimeline::estimateTimelineFromReference(
- TimePoint fenceTime, TimePoint displayStartTime) {
- DisplayTimeline estimated;
- estimated.hwcPresentStartTime = displayStartTime;
-
- // We don't predict waiting for vsync alignment yet
- estimated.hwcPresentDelayDuration = 0ns;
-
- // How long we expect to run before we start waiting for the fence
- // For now just re-use last frame's post-present duration and assume it will not change much
- // Excludes time spent waiting for vsync since that's not going to be consistent
- estimated.presentFenceWaitStartTime = estimated.hwcPresentStartTime +
- (presentFenceWaitStartTime - (hwcPresentStartTime + hwcPresentDelayDuration));
- estimated.probablyWaitsForPresentFence = fenceTime > estimated.presentFenceWaitStartTime;
- estimated.hwcPresentEndTime = postPresentFenceHwcPresentDuration +
- (estimated.probablyWaitsForPresentFence ? fenceTime
- : estimated.presentFenceWaitStartTime);
- return estimated;
-}
-
PowerAdvisor::DisplayTimeline PowerAdvisor::DisplayTimingData::calculateDisplayTimeline(
TimePoint fenceTime) {
DisplayTimeline timeline;
@@ -560,321 +557,17 @@
return GpuTimeline{.duration = gpuDuration, .startTime = latestGpuStartTime};
}
-class HidlPowerHalWrapper : public PowerAdvisor::HalWrapper {
-public:
- HidlPowerHalWrapper(sp<V1_3::IPower> powerHal) : mPowerHal(std::move(powerHal)) {}
-
- ~HidlPowerHalWrapper() override = default;
-
- static std::unique_ptr<HalWrapper> connect() {
- // Power HAL 1.3 is not guaranteed to be available, thus we need to query
- // Power HAL 1.0 first and try to cast it to Power HAL 1.3.
- sp<V1_3::IPower> powerHal = nullptr;
- sp<V1_0::IPower> powerHal_1_0 = V1_0::IPower::getService();
- if (powerHal_1_0 != nullptr) {
- // Try to cast to Power HAL 1.3
- powerHal = V1_3::IPower::castFrom(powerHal_1_0);
- if (powerHal == nullptr) {
- ALOGW("No Power HAL 1.3 service in system, disabling PowerAdvisor");
- } else {
- ALOGI("Loaded Power HAL 1.3 service");
- }
- } else {
- ALOGW("No Power HAL found, disabling PowerAdvisor");
- }
-
- if (powerHal == nullptr) {
- return nullptr;
- }
-
- return std::make_unique<HidlPowerHalWrapper>(std::move(powerHal));
- }
-
- bool setExpensiveRendering(bool enabled) override {
- ALOGV("HIDL setExpensiveRendering %s", enabled ? "T" : "F");
- auto ret = mPowerHal->powerHintAsync_1_3(PowerHint::EXPENSIVE_RENDERING, enabled);
- if (ret.isOk()) {
- traceExpensiveRendering(enabled);
- }
- return ret.isOk();
- }
-
- bool notifyDisplayUpdateImminentAndCpuReset() override {
- // Power HAL 1.x doesn't have a notification for this
- ALOGV("HIDL notifyUpdateImminent received but can't send");
- return true;
- }
-
- bool supportsPowerHintSession() override { return false; }
-
- bool isPowerHintSessionRunning() override { return false; }
-
- void restartPowerHintSession() override {}
-
- void setPowerHintSessionThreadIds(const std::vector<int32_t>&) override {}
-
- bool startPowerHintSession() override { return false; }
-
- void setTargetWorkDuration(Duration) override {}
-
- void sendActualWorkDuration(Duration, TimePoint) override {}
-
- bool shouldReconnectHAL() override { return false; }
-
- std::vector<int32_t> getPowerHintSessionThreadIds() override { return std::vector<int32_t>{}; }
-
- std::optional<Duration> getTargetWorkDuration() override { return std::nullopt; }
-
-private:
- const sp<V1_3::IPower> mPowerHal = nullptr;
-};
-
-AidlPowerHalWrapper::AidlPowerHalWrapper(sp<IPower> powerHal) : mPowerHal(std::move(powerHal)) {
- auto ret = mPowerHal->isModeSupported(Mode::EXPENSIVE_RENDERING, &mHasExpensiveRendering);
- if (!ret.isOk()) {
- mHasExpensiveRendering = false;
- }
-
- ret = mPowerHal->isBoostSupported(Boost::DISPLAY_UPDATE_IMMINENT, &mHasDisplayUpdateImminent);
- if (!ret.isOk()) {
- mHasDisplayUpdateImminent = false;
- }
-
- mSupportsPowerHint = checkPowerHintSessionSupported();
-}
-
-AidlPowerHalWrapper::~AidlPowerHalWrapper() {
- if (mPowerHintSession != nullptr) {
- mPowerHintSession->close();
- mPowerHintSession = nullptr;
- }
-}
-
-std::unique_ptr<PowerAdvisor::HalWrapper> AidlPowerHalWrapper::connect() {
- // This only waits if the service is actually declared
- sp<IPower> powerHal = waitForVintfService<IPower>();
- if (powerHal == nullptr) {
- return nullptr;
- }
- ALOGI("Loaded AIDL Power HAL service");
-
- return std::make_unique<AidlPowerHalWrapper>(std::move(powerHal));
-}
-
-bool AidlPowerHalWrapper::setExpensiveRendering(bool enabled) {
- ALOGV("AIDL setExpensiveRendering %s", enabled ? "T" : "F");
- if (!mHasExpensiveRendering) {
- ALOGV("Skipped sending EXPENSIVE_RENDERING because HAL doesn't support it");
- return true;
- }
-
- auto ret = mPowerHal->setMode(Mode::EXPENSIVE_RENDERING, enabled);
- if (ret.isOk()) {
- traceExpensiveRendering(enabled);
- }
- return ret.isOk();
-}
-
-bool AidlPowerHalWrapper::notifyDisplayUpdateImminentAndCpuReset() {
- ALOGV("AIDL notifyDisplayUpdateImminentAndCpuReset");
- if (isPowerHintSessionRunning()) {
- mPowerHintSession->sendHint(SessionHint::CPU_LOAD_RESET);
- }
-
- if (!mHasDisplayUpdateImminent) {
- ALOGV("Skipped sending DISPLAY_UPDATE_IMMINENT because HAL doesn't support it");
- return true;
- }
-
- auto ret = mPowerHal->setBoost(Boost::DISPLAY_UPDATE_IMMINENT, 0);
- return ret.isOk();
-}
-
-// Only version 2+ of the aidl supports power hint sessions, hidl has no support
-bool AidlPowerHalWrapper::supportsPowerHintSession() {
- return mSupportsPowerHint;
-}
-
-bool AidlPowerHalWrapper::checkPowerHintSessionSupported() {
- int64_t unused;
- // Try to get preferred rate to determine if hint sessions are supported
- // We check for isOk not EX_UNSUPPORTED_OPERATION to lump together errors
- return mPowerHal->getHintSessionPreferredRate(&unused).isOk();
-}
-
-bool AidlPowerHalWrapper::isPowerHintSessionRunning() {
- return mPowerHintSession != nullptr;
-}
-
-void AidlPowerHalWrapper::closePowerHintSession() {
- if (mPowerHintSession != nullptr) {
- mPowerHintSession->close();
- mPowerHintSession = nullptr;
- }
-}
-
-void AidlPowerHalWrapper::restartPowerHintSession() {
- closePowerHintSession();
- startPowerHintSession();
-}
-
-void AidlPowerHalWrapper::setPowerHintSessionThreadIds(const std::vector<int32_t>& threadIds) {
- if (threadIds != mPowerHintThreadIds) {
- mPowerHintThreadIds = threadIds;
- if (isPowerHintSessionRunning()) {
- restartPowerHintSession();
- }
- }
-}
-
-bool AidlPowerHalWrapper::startPowerHintSession() {
- if (mPowerHintSession != nullptr || mPowerHintThreadIds.empty()) {
- ALOGV("Cannot start power hint session, skipping");
- return false;
- }
- auto ret = mPowerHal->createHintSession(getpid(), static_cast<int32_t>(getuid()),
- mPowerHintThreadIds, mTargetDuration.ns(),
- &mPowerHintSession);
- if (!ret.isOk()) {
- ALOGW("Failed to start power hint session with error: %s",
- ret.exceptionToString(ret.exceptionCode()).c_str());
- } else {
- mLastTargetDurationSent = mTargetDuration;
- }
- return isPowerHintSessionRunning();
-}
-
-void AidlPowerHalWrapper::setTargetWorkDuration(Duration targetDuration) {
- ATRACE_CALL();
- mTargetDuration = targetDuration;
- if (sTraceHintSessionData) ATRACE_INT64("Time target", targetDuration.ns());
- if (isPowerHintSessionRunning() && (targetDuration != mLastTargetDurationSent)) {
- ALOGV("Sending target time: %" PRId64 "ns", targetDuration.ns());
- mLastTargetDurationSent = targetDuration;
- auto ret = mPowerHintSession->updateTargetWorkDuration(targetDuration.ns());
- if (!ret.isOk()) {
- ALOGW("Failed to set power hint target work duration with error: %s",
- ret.exceptionMessage().c_str());
- mShouldReconnectHal = true;
- }
- }
-}
-
-void AidlPowerHalWrapper::sendActualWorkDuration(Duration actualDuration, TimePoint timestamp) {
- ATRACE_CALL();
- if (actualDuration < 0ns || !isPowerHintSessionRunning()) {
- ALOGV("Failed to send actual work duration, skipping");
- return;
- }
- mActualDuration = actualDuration;
- WorkDuration duration;
- duration.durationNanos = actualDuration.ns();
- duration.timeStampNanos = timestamp.ns();
- mPowerHintQueue.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());
-
- auto ret = mPowerHintSession->reportActualWorkDuration(mPowerHintQueue);
- if (!ret.isOk()) {
- ALOGW("Failed to report actual work durations with error: %s",
- ret.exceptionMessage().c_str());
- mShouldReconnectHal = true;
- }
- mPowerHintQueue.clear();
-}
-
-bool AidlPowerHalWrapper::shouldReconnectHAL() {
- return mShouldReconnectHal;
-}
-
-std::vector<int32_t> AidlPowerHalWrapper::getPowerHintSessionThreadIds() {
- return mPowerHintThreadIds;
-}
-
-std::optional<Duration> AidlPowerHalWrapper::getTargetWorkDuration() {
- return mTargetDuration;
-}
-
-const bool AidlPowerHalWrapper::sTraceHintSessionData =
+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)));
-PowerAdvisor::HalWrapper* PowerAdvisor::getPowerHal() {
- if (!mHasHal) {
- return nullptr;
- }
-
- // Grab old hint session values before we destroy any existing wrapper
- std::vector<int32_t> oldPowerHintSessionThreadIds;
- std::optional<Duration> oldTargetWorkDuration;
-
- if (mHalWrapper != nullptr) {
- oldPowerHintSessionThreadIds = mHalWrapper->getPowerHintSessionThreadIds();
- oldTargetWorkDuration = mHalWrapper->getTargetWorkDuration();
- }
-
- // If we used to have a HAL, but it stopped responding, attempt to reconnect
- if (mReconnectPowerHal) {
- mHalWrapper = nullptr;
- mReconnectPowerHal = false;
- }
-
- if (mHalWrapper != nullptr) {
- auto wrapper = mHalWrapper.get();
- // If the wrapper is fine, return it, but if it indicates a reconnect, remake it
- if (!wrapper->shouldReconnectHAL()) {
- return wrapper;
- }
- ALOGD("Reconnecting Power HAL");
- mHalWrapper = nullptr;
- }
-
- // At this point, we know for sure there is no running session
- mPowerHintSessionRunning = false;
-
- // First attempt to connect to the AIDL Power HAL
- mHalWrapper = AidlPowerHalWrapper::connect();
-
- // If that didn't succeed, attempt to connect to the HIDL Power HAL
- if (mHalWrapper == nullptr) {
- mHalWrapper = HidlPowerHalWrapper::connect();
- } else {
- ALOGD("Successfully connecting AIDL Power HAL");
- // If AIDL, pass on any existing hint session values
- mHalWrapper->setPowerHintSessionThreadIds(oldPowerHintSessionThreadIds);
- // Only set duration and start if duration is defined
- if (oldTargetWorkDuration.has_value()) {
- mHalWrapper->setTargetWorkDuration(*oldTargetWorkDuration);
- // Only start if possible to run and both threadids and duration are defined
- if (usePowerHintSession() && !oldPowerHintSessionThreadIds.empty()) {
- mPowerHintSessionRunning = mHalWrapper->startPowerHintSession();
- }
- }
- }
-
- // If we make it to this point and still don't have a HAL, it's unlikely we
- // will, so stop trying
- if (mHalWrapper == nullptr) {
- mHasHal = false;
- }
-
- return mHalWrapper.get();
+power::PowerHalController& PowerAdvisor::getPowerHal() {
+ static std::once_flag halFlag;
+ std::call_once(halFlag, [this] { mPowerHal->init(); });
+ return *mPowerHal;
}
} // namespace impl
diff --git a/services/surfaceflinger/DisplayHardware/PowerAdvisor.h b/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
index c4cfdc3..7a0d426 100644
--- a/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
+++ b/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
@@ -27,6 +27,7 @@
#include <android/hardware/power/IPower.h>
#include <compositionengine/impl/OutputCompositionState.h>
+#include <powermanager/PowerHalController.h>
#include <scheduler/Time.h>
#include <ui/DisplayIdentification.h>
#include "../Scheduler/OneShotTimer.h"
@@ -52,15 +53,14 @@
// Checks both if it supports and if it's enabled
virtual bool usePowerHintSession() = 0;
virtual bool supportsPowerHintSession() = 0;
- virtual bool isPowerHintSessionRunning() = 0;
+
+ virtual bool ensurePowerHintSessionRunning() = 0;
// Sends a power hint that updates to the target work duration for the frame
- virtual void setTargetWorkDuration(Duration targetDuration) = 0;
+ virtual void updateTargetWorkDuration(Duration targetDuration) = 0;
// Sends a power hint for the actual known work duration at the end of the frame
- virtual void sendActualWorkDuration() = 0;
- // Sends a power hint for the upcoming frame predicted from previous frame timing
- virtual void sendPredictedWorkDuration() = 0;
+ virtual void reportActualWorkDuration() = 0;
// Sets whether the power hint session is enabled
- virtual void enablePowerHint(bool enabled) = 0;
+ virtual void enablePowerHintSession(bool enabled) = 0;
// Initializes the power hint session
virtual bool startPowerHintSession(const std::vector<int32_t>& threadIds) = 0;
// Provides PowerAdvisor with a copy of the gpu fence so it can determine the gpu end time
@@ -101,24 +101,6 @@
// full state of the system when sending out power hints to things like the GPU.
class PowerAdvisor final : public Hwc2::PowerAdvisor {
public:
- class HalWrapper {
- public:
- virtual ~HalWrapper() = default;
-
- virtual bool setExpensiveRendering(bool enabled) = 0;
- virtual bool notifyDisplayUpdateImminentAndCpuReset() = 0;
- virtual bool supportsPowerHintSession() = 0;
- virtual bool isPowerHintSessionRunning() = 0;
- virtual void restartPowerHintSession() = 0;
- virtual void setPowerHintSessionThreadIds(const std::vector<int32_t>& threadIds) = 0;
- virtual bool startPowerHintSession() = 0;
- virtual void setTargetWorkDuration(Duration targetDuration) = 0;
- virtual void sendActualWorkDuration(Duration actualDuration, TimePoint timestamp) = 0;
- virtual bool shouldReconnectHAL() = 0;
- virtual std::vector<int32_t> getPowerHintSessionThreadIds() = 0;
- virtual std::optional<Duration> getTargetWorkDuration() = 0;
- };
-
PowerAdvisor(SurfaceFlinger& flinger);
~PowerAdvisor() override;
@@ -129,11 +111,10 @@
void notifyDisplayUpdateImminentAndCpuReset() override;
bool usePowerHintSession() override;
bool supportsPowerHintSession() override;
- bool isPowerHintSessionRunning() override;
- void setTargetWorkDuration(Duration targetDuration) override;
- void sendActualWorkDuration() override;
- void sendPredictedWorkDuration() override;
- void enablePowerHint(bool enabled) override;
+ bool ensurePowerHintSessionRunning() override;
+ void updateTargetWorkDuration(Duration targetDuration) override;
+ void reportActualWorkDuration() override;
+ void enablePowerHintSession(bool enabled) override;
bool startPowerHintSession(const std::vector<int32_t>& threadIds) override;
void setGpuFenceTime(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime);
void setHwcValidateTiming(DisplayId displayId, TimePoint validateStartTime,
@@ -155,15 +136,7 @@
private:
friend class PowerAdvisorTest;
- // Tracks if powerhal exists
- bool mHasHal = true;
- // Holds the hal wrapper for getPowerHal
- std::unique_ptr<HalWrapper> mHalWrapper GUARDED_BY(mPowerHalMutex) = nullptr;
-
- HalWrapper* getPowerHal() REQUIRES(mPowerHalMutex);
- bool mReconnectPowerHal GUARDED_BY(mPowerHalMutex) = false;
- std::mutex mPowerHalMutex;
-
+ std::unique_ptr<power::PowerHalController> mPowerHal;
std::atomic_bool mBootFinished = false;
std::unordered_set<DisplayId> mExpensiveDisplays;
@@ -189,9 +162,6 @@
Duration postPresentFenceHwcPresentDuration{0ns};
// Are we likely to have waited for the present fence during composition
bool probablyWaitsForPresentFence = false;
- // Estimate one frame's timeline from that of a previous frame
- DisplayTimeline estimateTimelineFromReference(TimePoint fenceTime,
- TimePoint displayStartTime);
};
struct GpuTimeline {
@@ -243,8 +213,7 @@
std::vector<DisplayId> getOrderedDisplayIds(
std::optional<TimePoint> DisplayTimingData::*sortBy);
// Estimates a frame's total work duration including gpu time.
- // Runs either at the beginning or end of a frame, using the most recent data available
- std::optional<Duration> estimateWorkDuration(bool earlyHint);
+ std::optional<Duration> estimateWorkDuration();
// There are two different targets and actual work durations we care about,
// this normalizes them together and takes the max of the two
Duration combineTimingEstimates(Duration totalDuration, Duration flingerDuration);
@@ -268,9 +237,32 @@
// Updated list of display IDs
std::vector<DisplayId> mDisplayIds;
- std::optional<bool> mPowerHintEnabled;
- std::optional<bool> mSupportsPowerHint;
- bool mPowerHintSessionRunning = false;
+ // Ensure powerhal connection is initialized
+ power::PowerHalController& getPowerHal();
+
+ std::optional<bool> mHintSessionEnabled;
+ std::optional<bool> mSupportsHintSession;
+ bool mHintSessionRunning = false;
+
+ std::mutex mHintSessionMutex;
+ sp<hardware::power::IPowerHintSession> mHintSession GUARDED_BY(mHintSessionMutex) = nullptr;
+
+ // Initialize to true so we try to call, to check if it's supported
+ bool mHasExpensiveRendering = true;
+ bool mHasDisplayUpdateImminent = true;
+ // Queue of actual durations saved to report
+ std::vector<hardware::power::WorkDuration> mHintSessionQueue;
+ // The latest values we have received for target and actual
+ Duration mTargetDuration = kDefaultTargetDuration;
+ std::optional<Duration> mActualDuration;
+ // The list of thread ids, stored so we can restart the session from this class if needed
+ std::vector<int32_t> mHintSessionThreadIds;
+ Duration mLastTargetDurationSent = kDefaultTargetDuration;
+ // Whether we should emit ATRACE_INT data for hint sessions
+ static const bool sTraceHintSessionData;
+
+ // Default target duration for the hint session
+ static constexpr const Duration kDefaultTargetDuration{16ms};
// An adjustable safety margin which pads the "actual" value sent to PowerHAL,
// encouraging more aggressive boosting to give SurfaceFlinger a larger margin for error
@@ -282,56 +274,6 @@
static constexpr const Duration kFenceWaitStartDelaySkippedValidate{250us};
};
-class AidlPowerHalWrapper : public PowerAdvisor::HalWrapper {
-public:
- explicit AidlPowerHalWrapper(sp<hardware::power::IPower> powerHal);
- ~AidlPowerHalWrapper() override;
-
- static std::unique_ptr<HalWrapper> connect();
-
- bool setExpensiveRendering(bool enabled) override;
- bool notifyDisplayUpdateImminentAndCpuReset() override;
- bool supportsPowerHintSession() override;
- bool isPowerHintSessionRunning() override;
- void restartPowerHintSession() override;
- void setPowerHintSessionThreadIds(const std::vector<int32_t>& threadIds) override;
- bool startPowerHintSession() override;
- void setTargetWorkDuration(Duration targetDuration) override;
- void sendActualWorkDuration(Duration actualDuration, TimePoint timestamp) override;
- bool shouldReconnectHAL() override;
- std::vector<int32_t> getPowerHintSessionThreadIds() override;
- std::optional<Duration> getTargetWorkDuration() override;
-
-private:
- friend class AidlPowerHalWrapperTest;
-
- bool checkPowerHintSessionSupported();
- void closePowerHintSession();
-
- const sp<hardware::power::IPower> mPowerHal = nullptr;
- bool mHasExpensiveRendering = false;
- bool mHasDisplayUpdateImminent = false;
- // Used to indicate an error state and need for reconstruction
- bool mShouldReconnectHal = false;
-
- // Power hint session data
-
- // Concurrent access for this is protected by mPowerHalMutex
- sp<hardware::power::IPowerHintSession> mPowerHintSession = nullptr;
- // Queue of actual durations saved to report
- std::vector<hardware::power::WorkDuration> mPowerHintQueue;
- // The latest values we have received for target and actual
- Duration mTargetDuration = kDefaultTargetDuration;
- std::optional<Duration> mActualDuration;
- // The list of thread ids, stored so we can restart the session from this class if needed
- std::vector<int32_t> mPowerHintThreadIds;
- bool mSupportsPowerHint = false;
- Duration mLastTargetDurationSent = kDefaultTargetDuration;
- // Whether we should emit ATRACE_INT data for hint sessions
- static const bool sTraceHintSessionData;
- static constexpr Duration kDefaultTargetDuration{16ms};
-};
-
} // namespace impl
} // namespace Hwc2
} // namespace android
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 5664d84..523474b 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -478,10 +478,6 @@
mIgnoreHdrCameraLayers = ignore_hdr_camera_layers(false);
- // Power hint session mode, representing which hint(s) to send: early, late, or both)
- mPowerHintSessionMode =
- {.late = base::GetBoolProperty("debug.sf.send_late_power_session_hint"s, true),
- .early = base::GetBoolProperty("debug.sf.send_early_power_session_hint"s, false)};
mLayerLifecycleManagerEnabled =
base::GetBoolProperty("persist.debug.sf.enable_layer_lifecycle_manager"s, false);
mLegacyFrontEndEnabled = !mLayerLifecycleManagerEnabled ||
@@ -715,12 +711,12 @@
readPersistentProperties();
mPowerAdvisor->onBootFinished();
- const bool powerHintEnabled = mFlagManager.use_adpf_cpu_hint();
- mPowerAdvisor->enablePowerHint(powerHintEnabled);
- const bool powerHintUsed = mPowerAdvisor->usePowerHintSession();
+ const bool hintSessionEnabled = mFlagManager.use_adpf_cpu_hint();
+ mPowerAdvisor->enablePowerHintSession(hintSessionEnabled);
+ const bool hintSessionUsed = mPowerAdvisor->usePowerHintSession();
ALOGD("Power hint is %s",
- powerHintUsed ? "supported" : (powerHintEnabled ? "unsupported" : "disabled"));
- if (powerHintUsed) {
+ hintSessionUsed ? "supported" : (hintSessionEnabled ? "unsupported" : "disabled"));
+ if (hintSessionUsed) {
std::optional<pid_t> renderEngineTid = getRenderEngine().getRenderEngineTid();
std::vector<int32_t> tidList;
tidList.emplace_back(gettid());
@@ -2461,16 +2457,7 @@
mPowerAdvisor->setFrameDelay(frameDelay);
mPowerAdvisor->setTotalFrameTargetWorkDuration(idealSfWorkDuration);
-
- const auto& display = FTL_FAKE_GUARD(mStateLock, getDefaultDisplayDeviceLocked()).get();
- const Period vsyncPeriod = display->getActiveMode().fps.getPeriod();
- mPowerAdvisor->setTargetWorkDuration(vsyncPeriod);
-
- // Send early hint here to make sure there's not another frame pending
- if (mPowerHintSessionMode.early) {
- // Send a rough prediction for this frame based on last frame's timing info
- mPowerAdvisor->sendPredictedWorkDuration();
- }
+ mPowerAdvisor->updateTargetWorkDuration(vsyncPeriod);
}
if (mRefreshRateOverlaySpinner) {
@@ -2658,9 +2645,7 @@
mPowerAdvisor->setSfPresentTiming(TimePoint::fromNs(mPreviousPresentFences[0]
.fenceTime->getSignalTime()),
TimePoint::now());
- if (mPowerHintSessionMode.late) {
- mPowerAdvisor->sendActualWorkDuration();
- }
+ mPowerAdvisor->reportActualWorkDuration();
}
if (mScheduler->onPostComposition(presentTime)) {
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 74d00dd..03e188b 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -1408,10 +1408,6 @@
// These classes do not store any client state but help with managing transaction callbacks
// and stats.
std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers;
- struct {
- bool late = false;
- bool early = false;
- } mPowerHintSessionMode;
TransactionHandler mTransactionHandler;
display::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos;
diff --git a/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp b/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp
deleted file mode 100644
index 513f779..0000000
--- a/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * Copyright 2022 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.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "AidlPowerHalWrapperTest"
-
-#include <android-base/stringprintf.h>
-#include <android/hardware/power/IPower.h>
-#include <android/hardware/power/IPowerHintSession.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <algorithm>
-#include <chrono>
-#include <memory>
-#include "DisplayHardware/PowerAdvisor.h"
-#include "android/hardware/power/WorkDuration.h"
-#include "binder/Status.h"
-#include "log/log_main.h"
-#include "mock/DisplayHardware/MockIPower.h"
-#include "mock/DisplayHardware/MockIPowerHintSession.h"
-#include "utils/Timers.h"
-
-using namespace android;
-using namespace android::Hwc2::mock;
-using namespace android::hardware::power;
-using namespace std::chrono_literals;
-using namespace testing;
-
-namespace android::Hwc2::impl {
-
-class AidlPowerHalWrapperTest : public testing::Test {
-public:
- void SetUp() override;
-
-protected:
- std::unique_ptr<AidlPowerHalWrapper> mWrapper = nullptr;
- sp<NiceMock<MockIPower>> mMockHal = nullptr;
- sp<NiceMock<MockIPowerHintSession>> mMockSession = nullptr;
- void verifyAndClearExpectations();
- void sendActualWorkDurationGroup(std::vector<WorkDuration> durations);
- static constexpr std::chrono::duration kStaleTimeout = 100ms;
-};
-
-void AidlPowerHalWrapperTest::SetUp() {
- mMockHal = sp<NiceMock<MockIPower>>::make();
- mMockSession = sp<NiceMock<MockIPowerHintSession>>::make();
- ON_CALL(*mMockHal.get(), getHintSessionPreferredRate(_)).WillByDefault(Return(Status::ok()));
- mWrapper = std::make_unique<AidlPowerHalWrapper>(mMockHal);
-}
-
-void AidlPowerHalWrapperTest::verifyAndClearExpectations() {
- Mock::VerifyAndClearExpectations(mMockHal.get());
- Mock::VerifyAndClearExpectations(mMockSession.get());
-}
-
-void AidlPowerHalWrapperTest::sendActualWorkDurationGroup(std::vector<WorkDuration> durations) {
- for (size_t i = 0; i < durations.size(); i++) {
- auto duration = durations[i];
- mWrapper->sendActualWorkDuration(Duration::fromNs(duration.durationNanos),
- TimePoint::fromNs(duration.timeStampNanos));
- }
-}
-
-WorkDuration toWorkDuration(std::chrono::nanoseconds durationNanos, int64_t timeStampNanos) {
- WorkDuration duration;
- duration.durationNanos = durationNanos.count();
- duration.timeStampNanos = timeStampNanos;
- return duration;
-}
-
-WorkDuration toWorkDuration(std::pair<std::chrono::nanoseconds, nsecs_t> timePair) {
- return toWorkDuration(timePair.first, timePair.second);
-}
-
-std::string printWorkDurations(const ::std::vector<WorkDuration>& durations) {
- std::ostringstream os;
- for (auto duration : durations) {
- os << duration.toString();
- os << "\n";
- }
- return os.str();
-}
-
-namespace {
-TEST_F(AidlPowerHalWrapperTest, supportsPowerHintSession) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
- Mock::VerifyAndClearExpectations(mMockHal.get());
- ON_CALL(*mMockHal.get(), getHintSessionPreferredRate(_))
- .WillByDefault(Return(Status::fromExceptionCode(Status::Exception::EX_ILLEGAL_STATE)));
- auto newWrapper = AidlPowerHalWrapper(mMockHal);
- EXPECT_FALSE(newWrapper.supportsPowerHintSession());
-}
-
-TEST_F(AidlPowerHalWrapperTest, startPowerHintSession) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
- std::vector<int32_t> threadIds = {1, 2};
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- EXPECT_TRUE(mWrapper->startPowerHintSession());
- EXPECT_FALSE(mWrapper->startPowerHintSession());
-}
-
-TEST_F(AidlPowerHalWrapperTest, restartNewPowerHintSessionWithNewThreadIds) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
-
- std::vector<int32_t> threadIds = {1, 2};
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_EQ(mWrapper->getPowerHintSessionThreadIds(), threadIds);
- ASSERT_TRUE(mWrapper->startPowerHintSession());
- verifyAndClearExpectations();
-
- threadIds = {2, 3};
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- EXPECT_CALL(*mMockSession.get(), close()).Times(1);
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_EQ(mWrapper->getPowerHintSessionThreadIds(), threadIds);
- verifyAndClearExpectations();
-
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _)).Times(0);
- EXPECT_CALL(*mMockSession.get(), close()).Times(0);
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- verifyAndClearExpectations();
-}
-
-TEST_F(AidlPowerHalWrapperTest, setTargetWorkDuration) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
-
- std::vector<int32_t> threadIds = {1, 2};
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- ASSERT_TRUE(mWrapper->startPowerHintSession());
- verifyAndClearExpectations();
-
- std::chrono::nanoseconds base = 100ms;
- // test cases with target work duration and whether it should update hint against baseline 100ms
- const std::vector<std::pair<std::chrono::nanoseconds, bool>> testCases =
- {{0ms, true}, {-1ms, true}, {200ms, true}, {2ms, true}, {100ms, false}, {109ms, true}};
-
- for (const auto& test : testCases) {
- // reset to 100ms baseline
- mWrapper->setTargetWorkDuration(1ns);
- mWrapper->setTargetWorkDuration(base);
-
- std::chrono::nanoseconds target = test.first;
- EXPECT_CALL(*mMockSession.get(), updateTargetWorkDuration(target.count()))
- .Times(test.second ? 1 : 0);
- mWrapper->setTargetWorkDuration(target);
- verifyAndClearExpectations();
- }
-}
-
-TEST_F(AidlPowerHalWrapperTest, setTargetWorkDuration_shouldReconnectOnError) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
-
- std::vector<int32_t> threadIds = {1, 2};
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- ASSERT_TRUE(mWrapper->startPowerHintSession());
- verifyAndClearExpectations();
-
- EXPECT_CALL(*mMockSession.get(), updateTargetWorkDuration(1))
- .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_ILLEGAL_STATE)));
- mWrapper->setTargetWorkDuration(1ns);
- EXPECT_TRUE(mWrapper->shouldReconnectHAL());
-}
-
-TEST_F(AidlPowerHalWrapperTest, sendActualWorkDuration) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
-
- std::vector<int32_t> threadIds = {1, 2};
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- ASSERT_TRUE(mWrapper->startPowerHintSession());
- verifyAndClearExpectations();
-
- auto base = toWorkDuration(100ms, 0);
- // test cases with actual work durations and whether it should update hint against baseline
- // 100ms
- const std::vector<std::pair<std::vector<std::pair<std::chrono::nanoseconds, nsecs_t>>, bool>>
- testCases = {{{{-1ms, 100}}, false},
- {{{50ms, 100}}, true},
- {{{100ms, 100}, {200ms, 200}}, true},
- {{{100ms, 500}, {100ms, 600}, {3ms, 600}}, true}};
-
- for (const auto& test : testCases) {
- // reset actual duration
- sendActualWorkDurationGroup({base});
-
- auto raw = test.first;
- std::vector<WorkDuration> durations(raw.size());
- std::transform(raw.begin(), raw.end(), durations.begin(),
- [](auto d) { return toWorkDuration(d); });
- for (auto& duration : durations) {
- EXPECT_CALL(*mMockSession.get(),
- reportActualWorkDuration(std::vector<WorkDuration>{duration}))
- .Times(test.second ? 1 : 0);
- }
- sendActualWorkDurationGroup(durations);
- verifyAndClearExpectations();
- }
-}
-
-TEST_F(AidlPowerHalWrapperTest, sendActualWorkDuration_shouldReconnectOnError) {
- ASSERT_TRUE(mWrapper->supportsPowerHintSession());
-
- std::vector<int32_t> threadIds = {1, 2};
- mWrapper->setPowerHintSessionThreadIds(threadIds);
- EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
- .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
- ASSERT_TRUE(mWrapper->startPowerHintSession());
- verifyAndClearExpectations();
- WorkDuration duration;
- duration.durationNanos = 1;
- EXPECT_CALL(*mMockSession.get(), reportActualWorkDuration(_))
- .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_ILLEGAL_STATE)));
- sendActualWorkDurationGroup({duration});
- EXPECT_TRUE(mWrapper->shouldReconnectHAL());
-}
-
-} // namespace
-} // namespace android::Hwc2::impl
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index df3ffd2..201d37f 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -24,7 +24,7 @@
filegroup {
name: "libsurfaceflinger_mock_sources",
srcs: [
- "mock/DisplayHardware/MockAidlPowerHalWrapper.cpp",
+ "mock/DisplayHardware/MockPowerHalController.cpp",
"mock/DisplayHardware/MockComposer.cpp",
"mock/DisplayHardware/MockHWC2.cpp",
"mock/DisplayHardware/MockIPower.cpp",
@@ -70,7 +70,6 @@
":libsurfaceflinger_mock_sources",
":libsurfaceflinger_sources",
"libsurfaceflinger_unittest_main.cpp",
- "AidlPowerHalWrapperTest.cpp",
"CompositionTest.cpp",
"DisplayIdGeneratorTest.cpp",
"DisplayTransactionTest.cpp",
@@ -196,6 +195,7 @@
"libinput",
"liblog",
"libnativewindow",
+ "libpowermanager",
"libprocessgroup",
"libprotobuf-cpp-lite",
"libSurfaceFlingerProp",
diff --git a/services/surfaceflinger/tests/unittests/PowerAdvisorTest.cpp b/services/surfaceflinger/tests/unittests/PowerAdvisorTest.cpp
index d22ce17..0d66d59 100644
--- a/services/surfaceflinger/tests/unittests/PowerAdvisorTest.cpp
+++ b/services/surfaceflinger/tests/unittests/PowerAdvisorTest.cpp
@@ -25,13 +25,15 @@
#include <ui/DisplayId.h>
#include <chrono>
#include "TestableSurfaceFlinger.h"
-#include "mock/DisplayHardware/MockAidlPowerHalWrapper.h"
+#include "mock/DisplayHardware/MockIPowerHintSession.h"
+#include "mock/DisplayHardware/MockPowerHalController.h"
using namespace android;
using namespace android::Hwc2::mock;
using namespace android::hardware::power;
using namespace std::chrono_literals;
using namespace testing;
+using namespace android::power;
namespace android::Hwc2::impl {
@@ -47,23 +49,27 @@
protected:
TestableSurfaceFlinger mFlinger;
std::unique_ptr<PowerAdvisor> mPowerAdvisor;
- NiceMock<MockAidlPowerHalWrapper>* mMockAidlWrapper;
+ MockPowerHalController* mMockPowerHalController;
+ sp<MockIPowerHintSession> mMockPowerHintSession;
};
-void PowerAdvisorTest::SetUp() FTL_FAKE_GUARD(mPowerAdvisor->mPowerHalMutex) {
- std::unique_ptr<MockAidlPowerHalWrapper> mockAidlWrapper =
- std::make_unique<NiceMock<MockAidlPowerHalWrapper>>();
- mPowerAdvisor = std::make_unique<PowerAdvisor>(*mFlinger.flinger());
- ON_CALL(*mockAidlWrapper.get(), supportsPowerHintSession()).WillByDefault(Return(true));
- ON_CALL(*mockAidlWrapper.get(), startPowerHintSession()).WillByDefault(Return(true));
- mPowerAdvisor->mHalWrapper = std::move(mockAidlWrapper);
- mMockAidlWrapper =
- reinterpret_cast<NiceMock<MockAidlPowerHalWrapper>*>(mPowerAdvisor->mHalWrapper.get());
+void PowerAdvisorTest::SetUp() {
+ mPowerAdvisor = std::make_unique<impl::PowerAdvisor>(*mFlinger.flinger());
+ mPowerAdvisor->mPowerHal = std::make_unique<NiceMock<MockPowerHalController>>();
+ mMockPowerHalController =
+ reinterpret_cast<MockPowerHalController*>(mPowerAdvisor->mPowerHal.get());
+ ON_CALL(*mMockPowerHalController, getHintSessionPreferredRate)
+ .WillByDefault(Return(HalResult<int64_t>::fromStatus(binder::Status::ok(), 16000)));
}
void PowerAdvisorTest::startPowerHintSession() {
const std::vector<int32_t> threadIds = {1, 2, 3};
- mPowerAdvisor->enablePowerHint(true);
+ mMockPowerHintSession = android::sp<NiceMock<MockIPowerHintSession>>::make();
+ ON_CALL(*mMockPowerHalController, createHintSession)
+ .WillByDefault(
+ Return(HalResult<sp<IPowerHintSession>>::fromStatus(binder::Status::ok(),
+ mMockPowerHintSession)));
+ mPowerAdvisor->enablePowerHintSession(true);
mPowerAdvisor->startPowerHintSession(threadIds);
}
@@ -76,9 +82,7 @@
void PowerAdvisorTest::fakeBasicFrameTiming(TimePoint startTime, Duration vsyncPeriod) {
mPowerAdvisor->setCommitStart(startTime);
mPowerAdvisor->setFrameDelay(0ns);
- mPowerAdvisor->setTargetWorkDuration(vsyncPeriod);
- ON_CALL(*mMockAidlWrapper, getTargetWorkDuration())
- .WillByDefault(Return(std::make_optional(vsyncPeriod)));
+ mPowerAdvisor->updateTargetWorkDuration(vsyncPeriod);
}
Duration PowerAdvisorTest::getFenceWaitDelayDuration(bool skipValidate) {
@@ -116,7 +120,10 @@
startTime += vsyncPeriod;
const Duration expectedDuration = getErrorMargin() + presentDuration + postCompDuration;
- EXPECT_CALL(*mMockAidlWrapper, sendActualWorkDuration(Eq(expectedDuration), _)).Times(1);
+ EXPECT_CALL(*mMockPowerHintSession,
+ reportActualWorkDuration(ElementsAre(
+ Field(&WorkDuration::durationNanos, Eq(expectedDuration.ns())))))
+ .Times(1);
fakeBasicFrameTiming(startTime, vsyncPeriod);
setExpectedTiming(vsyncPeriod, startTime + vsyncPeriod);
@@ -124,7 +131,7 @@
mPowerAdvisor->setHwcValidateTiming(displayIds[0], startTime + 1ms, startTime + 1500us);
mPowerAdvisor->setHwcPresentTiming(displayIds[0], startTime + 2ms, startTime + 2500us);
mPowerAdvisor->setSfPresentTiming(startTime, startTime + presentDuration);
- mPowerAdvisor->sendActualWorkDuration();
+ mPowerAdvisor->reportActualWorkDuration();
}
TEST_F(PowerAdvisorTest, hintSessionSubtractsHwcFenceTime) {
@@ -153,7 +160,10 @@
const Duration expectedDuration = getErrorMargin() + presentDuration +
getFenceWaitDelayDuration(false) - hwcBlockedDuration + postCompDuration;
- EXPECT_CALL(*mMockAidlWrapper, sendActualWorkDuration(Eq(expectedDuration), _)).Times(1);
+ EXPECT_CALL(*mMockPowerHintSession,
+ reportActualWorkDuration(ElementsAre(
+ Field(&WorkDuration::durationNanos, Eq(expectedDuration.ns())))))
+ .Times(1);
fakeBasicFrameTiming(startTime, vsyncPeriod);
setExpectedTiming(vsyncPeriod, startTime + vsyncPeriod);
@@ -163,7 +173,7 @@
// now report the fence as having fired during the display HWC time
mPowerAdvisor->setSfPresentTiming(startTime + 2ms + hwcBlockedDuration,
startTime + presentDuration);
- mPowerAdvisor->sendActualWorkDuration();
+ mPowerAdvisor->reportActualWorkDuration();
}
TEST_F(PowerAdvisorTest, hintSessionUsingSecondaryVirtualDisplays) {
@@ -192,7 +202,10 @@
startTime += vsyncPeriod;
const Duration expectedDuration = getErrorMargin() + presentDuration + postCompDuration;
- EXPECT_CALL(*mMockAidlWrapper, sendActualWorkDuration(Eq(expectedDuration), _)).Times(1);
+ EXPECT_CALL(*mMockPowerHintSession,
+ reportActualWorkDuration(ElementsAre(
+ Field(&WorkDuration::durationNanos, Eq(expectedDuration.ns())))))
+ .Times(1);
fakeBasicFrameTiming(startTime, vsyncPeriod);
setExpectedTiming(vsyncPeriod, startTime + vsyncPeriod);
@@ -202,7 +215,7 @@
mPowerAdvisor->setHwcValidateTiming(displayIds[0], startTime + 1ms, startTime + 1500us);
mPowerAdvisor->setHwcPresentTiming(displayIds[0], startTime + 2ms, startTime + 2500us);
mPowerAdvisor->setSfPresentTiming(startTime, startTime + presentDuration);
- mPowerAdvisor->sendActualWorkDuration();
+ mPowerAdvisor->reportActualWorkDuration();
}
} // namespace
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_PowerHintTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_PowerHintTest.cpp
index 7839ef0..d0290ea 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_PowerHintTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_PowerHintTest.cpp
@@ -70,7 +70,6 @@
mFlinger.setupRenderEngine(std::unique_ptr<renderengine::RenderEngine>(mRenderEngine));
mFlinger.setupTimeStats(std::shared_ptr<TimeStats>(mTimeStats));
mFlinger.setupComposer(std::unique_ptr<Hwc2::Composer>(mComposer));
- mFlinger.setPowerHintSessionMode(true, true);
mFlinger.setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor>(mPowerAdvisor));
static constexpr bool kIsPrimary = true;
FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, hal::DisplayType::PHYSICAL, kIsPrimary)
@@ -100,7 +99,7 @@
TEST_F(SurfaceFlingerPowerHintTest, sendDurationsIncludingHwcWaitTime) {
ON_CALL(*mPowerAdvisor, usePowerHintSession()).WillByDefault(Return(true));
- EXPECT_CALL(*mPowerAdvisor, setTargetWorkDuration(_)).Times(1);
+ EXPECT_CALL(*mPowerAdvisor, updateTargetWorkDuration(_)).Times(1);
EXPECT_CALL(*mDisplaySurface,
prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
.Times(1);
@@ -109,7 +108,7 @@
std::this_thread::sleep_for(kMockHwcRunTime);
return hardware::graphics::composer::V2_1::Error::NONE;
});
- EXPECT_CALL(*mPowerAdvisor, sendActualWorkDuration()).Times(1);
+ EXPECT_CALL(*mPowerAdvisor, reportActualWorkDuration()).Times(1);
const TimePoint frameTime = scheduler::SchedulerClock::now();
constexpr Period kMockVsyncPeriod = 15ms;
@@ -121,7 +120,7 @@
mDisplay->setPowerMode(hal::PowerMode::DOZE);
- EXPECT_CALL(*mPowerAdvisor, setTargetWorkDuration(_)).Times(0);
+ EXPECT_CALL(*mPowerAdvisor, updateTargetWorkDuration(_)).Times(0);
EXPECT_CALL(*mDisplaySurface,
prepareFrame(compositionengine::DisplaySurface::CompositionType::Hwc))
.Times(1);
@@ -130,7 +129,7 @@
std::this_thread::sleep_for(kMockHwcRunTime);
return hardware::graphics::composer::V2_1::Error::NONE;
});
- EXPECT_CALL(*mPowerAdvisor, sendActualWorkDuration()).Times(0);
+ EXPECT_CALL(*mPowerAdvisor, reportActualWorkDuration()).Times(0);
const TimePoint frameTime = scheduler::SchedulerClock::now();
constexpr Period kMockVsyncPeriod = 15ms;
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index fc9e653..bbb3554 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -344,10 +344,6 @@
layer->mDrawingParent = drawingParent;
}
- void setPowerHintSessionMode(bool early, bool late) {
- mFlinger->mPowerHintSessionMode = {.late = late, .early = early};
- }
-
/* ------------------------------------------------------------------------
* Forwarding for functions being tested
*/
diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.h
deleted file mode 100644
index 3ed85e0..0000000
--- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2022 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.
- */
-
-#pragma once
-
-#include <gmock/gmock.h>
-#include <scheduler/Time.h>
-
-#include "DisplayHardware/PowerAdvisor.h"
-
-namespace android {
-namespace hardware {
-namespace power {
-class IPower;
-}
-} // namespace hardware
-} // namespace android
-
-namespace android::Hwc2::mock {
-
-class MockAidlPowerHalWrapper : public Hwc2::impl::AidlPowerHalWrapper {
-public:
- MockAidlPowerHalWrapper();
- ~MockAidlPowerHalWrapper() override;
- MOCK_METHOD(bool, setExpensiveRendering, (bool enabled), (override));
- MOCK_METHOD(bool, notifyDisplayUpdateImminentAndCpuReset, (), (override));
- MOCK_METHOD(bool, supportsPowerHintSession, (), (override));
- MOCK_METHOD(bool, isPowerHintSessionRunning, (), (override));
- MOCK_METHOD(void, restartPowerHintSession, (), (override));
- MOCK_METHOD(void, setPowerHintSessionThreadIds, (const std::vector<int32_t>& threadIds),
- (override));
- MOCK_METHOD(bool, startPowerHintSession, (), (override));
- MOCK_METHOD(void, setTargetWorkDuration, (Duration targetDuration), (override));
- MOCK_METHOD(void, sendActualWorkDuration, (Duration actualDuration, TimePoint timestamp),
- (override));
- MOCK_METHOD(bool, shouldReconnectHAL, (), (override));
- MOCK_METHOD(std::vector<int32_t>, getPowerHintSessionThreadIds, (), (override));
- MOCK_METHOD(std::optional<Duration>, getTargetWorkDuration, (), (override));
-};
-
-} // namespace android::Hwc2::mock
\ No newline at end of file
diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h
index 7fc625c..3caa2b9 100644
--- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h
+++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerAdvisor.h
@@ -35,11 +35,10 @@
MOCK_METHOD(void, notifyDisplayUpdateImminentAndCpuReset, (), (override));
MOCK_METHOD(bool, usePowerHintSession, (), (override));
MOCK_METHOD(bool, supportsPowerHintSession, (), (override));
- MOCK_METHOD(bool, isPowerHintSessionRunning, (), (override));
- MOCK_METHOD(void, setTargetWorkDuration, (Duration targetDuration), (override));
- MOCK_METHOD(void, sendActualWorkDuration, (), (override));
- MOCK_METHOD(void, sendPredictedWorkDuration, (), (override));
- MOCK_METHOD(void, enablePowerHint, (bool enabled), (override));
+ MOCK_METHOD(bool, ensurePowerHintSessionRunning, (), (override));
+ MOCK_METHOD(void, updateTargetWorkDuration, (Duration targetDuration), (override));
+ MOCK_METHOD(void, reportActualWorkDuration, (), (override));
+ MOCK_METHOD(void, enablePowerHintSession, (bool enabled), (override));
MOCK_METHOD(bool, startPowerHintSession, (const std::vector<int32_t>& threadIds), (override));
MOCK_METHOD(void, setGpuFenceTime,
(DisplayId displayId, std::unique_ptr<FenceTime>&& fenceTime), (override));
diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.cpp b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.cpp
similarity index 67%
rename from services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.cpp
rename to services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.cpp
index 5049b1d..3ec5c2d 100644
--- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockAidlPowerHalWrapper.cpp
+++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2022 The Android Open Source Project
+ * Copyright (C) 2023 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.
@@ -14,13 +14,11 @@
* limitations under the License.
*/
-#include "MockAidlPowerHalWrapper.h"
-#include "MockIPower.h"
+#include "MockPowerHalController.h"
namespace android::Hwc2::mock {
-MockAidlPowerHalWrapper::MockAidlPowerHalWrapper()
- : AidlPowerHalWrapper(sp<testing::NiceMock<MockIPower>>::make()){};
-MockAidlPowerHalWrapper::~MockAidlPowerHalWrapper() = default;
+MockPowerHalController::MockPowerHalController() = default;
+MockPowerHalController::~MockPowerHalController() = default;
} // namespace android::Hwc2::mock
diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.h
new file mode 100644
index 0000000..358395d
--- /dev/null
+++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockPowerHalController.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+#include <scheduler/Time.h>
+
+#include <powermanager/PowerHalController.h>
+
+namespace android {
+namespace hardware {
+namespace power {
+class IPower;
+}
+} // namespace hardware
+} // namespace android
+
+namespace android::Hwc2::mock {
+
+using android::hardware::power::Boost;
+using android::hardware::power::Mode;
+using android::power::HalResult;
+
+class MockPowerHalController : public power::PowerHalController {
+public:
+ MockPowerHalController();
+ ~MockPowerHalController() override;
+ MOCK_METHOD(HalResult<void>, setBoost, (Boost, int32_t), (override));
+ MOCK_METHOD(HalResult<void>, setMode, (Mode, bool), (override));
+ MOCK_METHOD(HalResult<sp<hardware::power::IPowerHintSession>>, createHintSession,
+ (int32_t, int32_t, const std::vector<int32_t>&, int64_t), (override));
+ MOCK_METHOD(HalResult<int64_t>, getHintSessionPreferredRate, (), (override));
+};
+
+} // namespace android::Hwc2::mock
\ No newline at end of file