SF: Fully disable content detection if opted out
Layer history was created but not recorded/traversed on devices without
refresh rate switching. ag/9549429 destroys stale history on traversal,
so the LayerInfo records were leaked.
Bug: 144363590
Test: Layer history is not created on crosshatch
Change-Id: I45ebc7c4f8447b2bc2bfb1af01325d562b4afed1
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index dc61e49..6896da7 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -400,11 +400,9 @@
ATRACE_CALL();
// Add this buffer from our internal queue tracker
{ // Autolock scope
- if (mFlinger->mUseSmart90ForVideo) {
- const nsecs_t presentTime = item.mIsAutoTimestamp ? 0 : item.mTimestamp;
- mFlinger->mScheduler->recordLayerHistory(this, presentTime,
- item.mHdrMetadata.validTypes != 0);
- }
+ const nsecs_t presentTime = item.mIsAutoTimestamp ? 0 : item.mTimestamp;
+ const bool isHDR = item.mHdrMetadata.validTypes != 0;
+ mFlinger->mScheduler->recordLayerHistory(this, presentTime, isHDR);
Mutex::Autolock lock(mQueueItemLock);
// Reset the frame number tracker when we receive the first buffer after
diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp
index 5768edd..33cd0dc 100644
--- a/services/surfaceflinger/BufferStateLayer.cpp
+++ b/services/surfaceflinger/BufferStateLayer.cpp
@@ -247,11 +247,8 @@
FrameTracer::FrameEvent::POST);
mCurrentState.desiredPresentTime = desiredPresentTime;
- if (mFlinger->mUseSmart90ForVideo) {
- const nsecs_t presentTime = (desiredPresentTime == -1) ? 0 : desiredPresentTime;
- mFlinger->mScheduler->recordLayerHistory(this, presentTime,
- mCurrentState.hdrMetadata.validTypes != 0);
- }
+ const bool isHDR = mCurrentState.hdrMetadata.validTypes != 0;
+ mFlinger->mScheduler->recordLayerHistory(this, desiredPresentTime, isHDR);
return true;
}
diff --git a/services/surfaceflinger/Scheduler/LayerHistory.h b/services/surfaceflinger/Scheduler/LayerHistory.h
index 15ac8ca..bd9aca1 100644
--- a/services/surfaceflinger/Scheduler/LayerHistory.h
+++ b/services/surfaceflinger/Scheduler/LayerHistory.h
@@ -28,6 +28,7 @@
namespace android {
class Layer;
+class TestableScheduler;
namespace scheduler {
@@ -59,6 +60,7 @@
private:
friend class LayerHistoryTest;
+ friend TestableScheduler;
using LayerPair = std::pair<wp<Layer>, std::unique_ptr<LayerInfo>>;
using LayerInfos = std::vector<LayerPair>;
diff --git a/services/surfaceflinger/Scheduler/LayerInfo.cpp b/services/surfaceflinger/Scheduler/LayerInfo.cpp
index f3b0d56..6d9dd43 100644
--- a/services/surfaceflinger/Scheduler/LayerInfo.cpp
+++ b/services/surfaceflinger/Scheduler/LayerInfo.cpp
@@ -25,6 +25,8 @@
: mLowRefreshRate(lowRefreshRate), mHighRefreshRate(highRefreshRate) {}
void LayerInfo::setLastPresentTime(nsecs_t lastPresentTime, nsecs_t now) {
+ lastPresentTime = std::max(lastPresentTime, static_cast<nsecs_t>(0));
+
// Buffers can come with a present time far in the future. That keeps them relevant.
mLastUpdatedTime = std::max(lastPresentTime, now);
mPresentTimeHistory.insertPresentTime(mLastUpdatedTime);
diff --git a/services/surfaceflinger/Scheduler/OneShotTimer.cpp b/services/surfaceflinger/Scheduler/OneShotTimer.cpp
index 4870a3b..a90d05e 100644
--- a/services/surfaceflinger/Scheduler/OneShotTimer.cpp
+++ b/services/surfaceflinger/Scheduler/OneShotTimer.cpp
@@ -17,6 +17,7 @@
#include "OneShotTimer.h"
#include <chrono>
+#include <sstream>
#include <thread>
namespace android {
@@ -98,7 +99,7 @@
mTimeoutCallback();
}
}
-} // namespace scheduler
+}
void OneShotTimer::reset() {
{
@@ -108,5 +109,11 @@
mCondition.notify_all();
}
+std::string OneShotTimer::dump() const {
+ std::ostringstream stream;
+ stream << mInterval.count() << " ms";
+ return stream.str();
+}
+
} // namespace scheduler
} // namespace android
diff --git a/services/surfaceflinger/Scheduler/OneShotTimer.h b/services/surfaceflinger/Scheduler/OneShotTimer.h
index 921631e..b005754 100644
--- a/services/surfaceflinger/Scheduler/OneShotTimer.h
+++ b/services/surfaceflinger/Scheduler/OneShotTimer.h
@@ -39,8 +39,6 @@
const TimeoutCallback& timeoutCallback);
~OneShotTimer();
- const Interval& interval() const { return mInterval; }
-
// Initializes and turns on the idle timer.
void start();
// Stops the idle timer and any held resources.
@@ -48,6 +46,8 @@
// Resets the wakeup time and fires the reset callback.
void reset();
+ std::string dump() const;
+
private:
// Enum to track in what state is the timer.
enum class TimerState {
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index 71b3500..55fd603 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -20,6 +20,7 @@
#include "Scheduler.h"
+#include <android-base/stringprintf.h>
#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
#include <android/hardware/configstore/1.1/ISurfaceFlingerConfigs.h>
#include <configstore/Utils.h>
@@ -66,9 +67,11 @@
mRefreshRateConfigs(refreshRateConfig) {
using namespace sysprop;
- char value[PROPERTY_VALUE_MAX];
- property_get("debug.sf.set_idle_timer_ms", value, "0");
- const int setIdleTimerMs = atoi(value);
+ if (property_get_bool("debug.sf.use_smart_90_for_video", 0) || use_smart_90_for_video(false)) {
+ mLayerHistory.emplace();
+ }
+
+ const int setIdleTimerMs = property_get_int32("debug.sf.set_idle_timer_ms", 0);
if (const auto millis = setIdleTimerMs ? setIdleTimerMs : set_idle_timer_ms(0); millis > 0) {
const auto callback = mSupportKernelTimer ? &Scheduler::kernelIdleTimerCallback
@@ -327,26 +330,28 @@
}
void Scheduler::registerLayer(Layer* layer) {
- uint32_t defaultFps, performanceFps;
- if (mRefreshRateConfigs.refreshRateSwitchingSupported()) {
- defaultFps = mRefreshRateConfigs.getRefreshRateFromType(RefreshRateType::DEFAULT).fps;
- const auto type = layer->getWindowType() == InputWindowInfo::TYPE_WALLPAPER
- ? RefreshRateType::DEFAULT
- : RefreshRateType::PERFORMANCE;
- performanceFps = mRefreshRateConfigs.getRefreshRateFromType(type).fps;
- } else {
- defaultFps = mRefreshRateConfigs.getCurrentRefreshRate().second.fps;
- performanceFps = defaultFps;
- }
- mLayerHistory.registerLayer(layer, defaultFps, performanceFps);
+ if (!mLayerHistory) return;
+
+ const auto type = layer->getWindowType() == InputWindowInfo::TYPE_WALLPAPER
+ ? RefreshRateType::DEFAULT
+ : RefreshRateType::PERFORMANCE;
+
+ const auto lowFps = mRefreshRateConfigs.getRefreshRateFromType(RefreshRateType::DEFAULT).fps;
+ const auto highFps = mRefreshRateConfigs.getRefreshRateFromType(type).fps;
+
+ mLayerHistory->registerLayer(layer, lowFps, highFps);
}
void Scheduler::recordLayerHistory(Layer* layer, nsecs_t presentTime, bool isHDR) {
- mLayerHistory.record(layer, presentTime, isHDR, systemTime());
+ if (mLayerHistory) {
+ mLayerHistory->record(layer, presentTime, isHDR, systemTime());
+ }
}
-void Scheduler::updateFpsBasedOnContent() {
- auto [refreshRate, isHDR] = mLayerHistory.summarize(systemTime());
+void Scheduler::chooseRefreshRateForContent() {
+ if (!mLayerHistory) return;
+
+ auto [refreshRate, isHDR] = mLayerHistory->summarize(systemTime());
const uint32_t refreshRateRound = std::round(refreshRate);
RefreshRateType newRefreshRateType;
{
@@ -393,7 +398,9 @@
// Touch event will boost the refresh rate to performance.
// Clear Layer History to get fresh FPS detection
- mLayerHistory.clear();
+ if (mLayerHistory) {
+ mLayerHistory->clear();
+ }
}
void Scheduler::setDisplayPowerState(bool normal) {
@@ -408,7 +415,9 @@
// Display Power event will boost the refresh rate to performance.
// Clear Layer History to get fresh FPS detection
- mLayerHistory.clear();
+ if (mLayerHistory) {
+ mLayerHistory->clear();
+ }
}
void Scheduler::kernelIdleTimerCallback(TimerState state) {
@@ -446,15 +455,17 @@
}
void Scheduler::dump(std::string& result) const {
- std::ostringstream stream;
- if (mIdleTimer) {
- stream << "+ Idle timer interval: " << mIdleTimer->interval().count() << " ms\n";
- }
- if (mTouchTimer) {
- stream << "+ Touch timer interval: " << mTouchTimer->interval().count() << " ms\n";
- }
+ using base::StringAppendF;
+ const char* const states[] = {"off", "on"};
- result.append(stream.str());
+ const bool supported = mRefreshRateConfigs.refreshRateSwitchingSupported();
+ StringAppendF(&result, "+ Refresh rate switching: %s\n", states[supported]);
+ StringAppendF(&result, "+ Content detection: %s\n", states[mLayerHistory.has_value()]);
+
+ StringAppendF(&result, "+ Idle timer: %s\n",
+ mIdleTimer ? mIdleTimer->dump().c_str() : states[0]);
+ StringAppendF(&result, "+ Touch timer: %s\n\n",
+ mTouchTimer ? mTouchTimer->dump().c_str() : states[0]);
}
template <class T>
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index c983475..346896c 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -105,8 +105,8 @@
void registerLayer(Layer*);
void recordLayerHistory(Layer*, nsecs_t presentTime, bool isHDR);
- // Updates FPS based on the most content presented.
- void updateFpsBasedOnContent();
+ // Detects content using layer history, and selects a matching refresh rate.
+ void chooseRefreshRateForContent();
// Called by Scheduler to change refresh rate.
void setChangeRefreshRateCallback(ChangeRefreshRateCallback&&);
@@ -184,8 +184,8 @@
std::unique_ptr<DispSync> mPrimaryDispSync;
std::unique_ptr<EventControlThread> mEventControlThread;
- // Historical information about individual layers. Used for predicting the refresh rate.
- scheduler::LayerHistory mLayerHistory;
+ // Used to choose refresh rate if content detection is enabled.
+ std::optional<scheduler::LayerHistory> mLayerHistory;
// Whether to use idle timer callbacks that support the kernel timer.
const bool mSupportKernelTimer;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 96c17a1..a17896b 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -356,14 +356,6 @@
auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
- mUseSmart90ForVideo = use_smart_90_for_video(false);
- property_get("debug.sf.use_smart_90_for_video", value, "0");
-
- int int_value = atoi(value);
- if (int_value) {
- mUseSmart90ForVideo = true;
- }
-
property_get("debug.sf.luma_sampling", value, "1");
mLumaSampling = atoi(value);
@@ -1643,11 +1635,7 @@
mGpuFrameMissedCount++;
}
- if (mUseSmart90ForVideo) {
- // This call is made each time SF wakes up and creates a new frame. It is part
- // of video detection feature.
- mScheduler->updateFpsBasedOnContent();
- }
+ mScheduler->chooseRefreshRateForContent();
if (performSetActiveConfig()) {
break;
@@ -3943,9 +3931,6 @@
void SurfaceFlinger::dumpVSync(std::string& result) const {
mScheduler->dump(result);
- StringAppendF(&result, "+ Refresh rate switching: %s\n",
- mRefreshRateConfigs->refreshRateSwitchingSupported() ? "on" : "off");
- StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
mRefreshRateStats->dump(result);
result.append("\n");
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index e7ad295..805da06 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -1093,7 +1093,6 @@
/* ------------------------------------------------------------------------
* Scheduler
*/
- bool mUseSmart90ForVideo = false;
std::unique_ptr<Scheduler> mScheduler;
scheduler::ConnectionHandle mAppConnectionHandle;
scheduler::ConnectionHandle mSfConnectionHandle;
diff --git a/services/surfaceflinger/tests/unittests/CompositionTest.cpp b/services/surfaceflinger/tests/unittests/CompositionTest.cpp
index 60da70f..89c5d8a 100644
--- a/services/surfaceflinger/tests/unittests/CompositionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/CompositionTest.cpp
@@ -793,6 +793,9 @@
sp<L> layer = factory();
+ // Layer should be registered with scheduler.
+ EXPECT_EQ(1, test->mFlinger.scheduler()->layerHistorySize());
+
Mock::VerifyAndClear(test->mComposer);
Mock::VerifyAndClear(test->mRenderEngine);
Mock::VerifyAndClear(test->mMessageQueue);
@@ -828,6 +831,10 @@
test->mDisplay->getCompositionDisplay()->clearOutputLayers();
test->mFlinger.mutableDrawingState().layersSortedByZ.clear();
+
+ // Layer should be unregistered with scheduler.
+ test->mFlinger.onMessageReceived(MessageQueue::INVALIDATE);
+ EXPECT_EQ(0, test->mFlinger.scheduler()->layerHistorySize());
}
};
diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
index 9a962bc..e93d31e 100644
--- a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
@@ -29,10 +29,10 @@
LayerHistoryTest() { mFlinger.resetScheduler(mScheduler); }
- LayerHistory& history() { return mScheduler->mutableLayerHistory(); }
- const LayerHistory& history() const { return mScheduler->mutableLayerHistory(); }
+ LayerHistory& history() { return *mScheduler->mutableLayerHistory(); }
+ const LayerHistory& history() const { return *mScheduler->mutableLayerHistory(); }
- size_t layerCount() const NO_THREAD_SAFETY_ANALYSIS { return history().mLayerInfos.size(); }
+ size_t layerCount() const { return mScheduler->layerHistorySize(); }
size_t activeLayerCount() const NO_THREAD_SAFETY_ANALYSIS { return history().mActiveLayersEnd; }
size_t frequentLayerCount(nsecs_t now) const NO_THREAD_SAFETY_ANALYSIS {
diff --git a/services/surfaceflinger/tests/unittests/TestableScheduler.h b/services/surfaceflinger/tests/unittests/TestableScheduler.h
index ae6aa89..40c00c4 100644
--- a/services/surfaceflinger/tests/unittests/TestableScheduler.h
+++ b/services/surfaceflinger/tests/unittests/TestableScheduler.h
@@ -21,6 +21,7 @@
#include "Scheduler/DispSync.h"
#include "Scheduler/EventThread.h"
+#include "Scheduler/LayerHistory.h"
#include "Scheduler/Scheduler.h"
namespace android {
@@ -28,18 +29,26 @@
class TestableScheduler : public Scheduler {
public:
explicit TestableScheduler(const scheduler::RefreshRateConfigs& configs)
- : Scheduler([](bool) {}, configs) {}
+ : Scheduler([](bool) {}, configs) {
+ mLayerHistory.emplace();
+ }
TestableScheduler(std::unique_ptr<DispSync> primaryDispSync,
std::unique_ptr<EventControlThread> eventControlThread,
const scheduler::RefreshRateConfigs& configs)
- : Scheduler(std::move(primaryDispSync), std::move(eventControlThread), configs) {}
+ : Scheduler(std::move(primaryDispSync), std::move(eventControlThread), configs) {
+ mLayerHistory.emplace();
+ }
// Used to inject mock event thread.
ConnectionHandle createConnection(std::unique_ptr<EventThread> eventThread) {
return Scheduler::createConnection(std::move(eventThread));
}
+ size_t layerHistorySize() const NO_THREAD_SAFETY_ANALYSIS {
+ return mLayerHistory->mLayerInfos.size();
+ }
+
/* ------------------------------------------------------------------------
* Read-write access to private data to set up preconditions and assert
* post-conditions.