Move VsyncConfiguration from SF to Scheduler
This is part of the long term goal, tracked in b/241285191, of moving
scheduling logic/state from SF to Scheduler. It also paves the way for
a cleaner version of Ib927935de6ba2b7b8d5037b42eb635ae92019634.
Bring RefreshRateStats along to Scheduler, since it is updated along
with work that belongs in Scheduler.
Mostly this is intended to not change behavior, but there are some
exceptions:
- the ordering of dumpsys SurfaceFlinger has changed, as some components
are now internal to Scheduler, so they are dumped along with it.
- two extra calls to update the RefreshRateStats along with
updatePhaseConfiguration. The missing calls appear to be an oversight,
and it's more natural to include the update in its new location.
Move construction of VsyncModulator into Scheduler, since it is
constructed from the VsyncConfiguration, now constructed in Scheduler.
Add TestableScheduler.cpp, to prevent adding a circular dependency, now
that the class's constructor references TestableSurfaceFlinger.
Add Dumper::out for simplicity in updating dump calls.
Bug: 241285191
Bug: 255601557
Bug: 256196556
Bug: 259132483
Test: libscheduler_test
Test: libsurfaceflinger_unittest
Change-Id: I01c93cfc3d2342cfbaaf8fe47dc2cd57d0e1fc43
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index bfc47e6..5f772ac 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -51,8 +51,12 @@
#include "FrameRateOverrideMappings.h"
#include "FrontEnd/LayerHandle.h"
#include "OneShotTimer.h"
+#include "RefreshRateStats.h"
+#include "SurfaceFlingerFactory.h"
#include "SurfaceFlingerProperties.h"
+#include "TimeStats/TimeStats.h"
#include "VSyncTracker.h"
+#include "VsyncConfiguration.h"
#include "VsyncController.h"
#include "VsyncSchedule.h"
@@ -67,10 +71,14 @@
namespace android::scheduler {
Scheduler::Scheduler(ICompositor& compositor, ISchedulerCallback& callback, FeatureFlags features,
- sp<VsyncModulator> modulatorPtr, IVsyncTrackerCallback& vsyncTrackerCallback)
- : impl::MessageQueue(compositor),
+ surfaceflinger::Factory& factory, Fps activeRefreshRate, TimeStats& timeStats,
+ IVsyncTrackerCallback& vsyncTrackerCallback)
+ : android::impl::MessageQueue(compositor),
mFeatures(features),
- mVsyncModulator(std::move(modulatorPtr)),
+ mVsyncConfiguration(factory.createVsyncConfiguration(activeRefreshRate)),
+ mVsyncModulator(sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs())),
+ mRefreshRateStats(std::make_unique<RefreshRateStats>(timeStats, activeRefreshRate,
+ hal::PowerMode::OFF)),
mSchedulerCallback(callback),
mVsyncTrackerCallback(vsyncTrackerCallback) {}
@@ -307,9 +315,10 @@
frametimeline::TokenManager* tokenManager,
std::chrono::nanoseconds workDuration,
std::chrono::nanoseconds readyDuration) {
- auto eventThread = std::make_unique<impl::EventThread>(cycle == Cycle::Render ? "app" : "appSf",
- getVsyncSchedule(), tokenManager, *this,
- workDuration, readyDuration);
+ auto eventThread =
+ std::make_unique<android::impl::EventThread>(cycle == Cycle::Render ? "app" : "appSf",
+ getVsyncSchedule(), tokenManager, *this,
+ workDuration, readyDuration);
auto& handle = cycle == Cycle::Render ? mAppConnectionHandle : mSfConnectionHandle;
handle = createConnection(std::move(eventThread));
@@ -495,8 +504,23 @@
thread->setDuration(workDuration, readyDuration);
}
-void Scheduler::setVsyncConfigSet(const VsyncConfigSet& configs, Period vsyncPeriod) {
- setVsyncConfig(mVsyncModulator->setVsyncConfigSet(configs), vsyncPeriod);
+void Scheduler::updatePhaseConfiguration(Fps refreshRate) {
+ mRefreshRateStats->setRefreshRate(refreshRate);
+ mVsyncConfiguration->setRefreshRateFps(refreshRate);
+ setVsyncConfig(mVsyncModulator->setVsyncConfigSet(mVsyncConfiguration->getCurrentConfigs()),
+ refreshRate.getPeriod());
+}
+
+void Scheduler::resetPhaseConfiguration(Fps refreshRate) {
+ // Cancel the pending refresh rate change, if any, before updating the phase configuration.
+ mVsyncModulator->cancelRefreshRateChange();
+
+ mVsyncConfiguration->reset();
+ updatePhaseConfiguration(refreshRate);
+}
+
+void Scheduler::setActiveDisplayPowerModeForRefreshRateStats(hal::PowerMode powerMode) {
+ mRefreshRateStats->setPowerMode(powerMode);
}
void Scheduler::setVsyncConfig(const VsyncConfig& config, Period vsyncPeriod) {
@@ -869,6 +893,12 @@
mFrameRateOverrideMappings.dump(dumper);
dumper.eol();
+ mVsyncConfiguration->dump(dumper.out());
+ dumper.eol();
+
+ mRefreshRateStats->dump(dumper.out());
+ dumper.eol();
+
{
utils::Dumper::Section section(dumper, "Frame Targeting"sv);
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index a29d153..8c77739 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -88,23 +88,30 @@
namespace android {
class FenceTime;
+class TimeStats;
namespace frametimeline {
class TokenManager;
} // namespace frametimeline
+namespace surfaceflinger {
+class Factory;
+} // namespace surfaceflinger
+
namespace scheduler {
using GlobalSignals = RefreshRateSelector::GlobalSignals;
+class RefreshRateStats;
+class VsyncConfiguration;
class VsyncSchedule;
class Scheduler : public IEventThreadCallback, android::impl::MessageQueue {
using Impl = android::impl::MessageQueue;
public:
- Scheduler(ICompositor&, ISchedulerCallback&, FeatureFlags, sp<VsyncModulator>,
- IVsyncTrackerCallback&);
+ Scheduler(ICompositor&, ISchedulerCallback&, FeatureFlags, surfaceflinger::Factory&,
+ Fps activeRefreshRate, TimeStats&, IVsyncTrackerCallback&);
virtual ~Scheduler();
void startTimers();
@@ -201,7 +208,10 @@
}
}
- void setVsyncConfigSet(const VsyncConfigSet&, Period vsyncPeriod);
+ void updatePhaseConfiguration(Fps);
+ void resetPhaseConfiguration(Fps) REQUIRES(kMainThreadContext);
+
+ const VsyncConfiguration& getVsyncConfiguration() const { return *mVsyncConfiguration; }
// Sets the render rate for the scheduler to run at.
void setRenderRate(PhysicalDisplayId, Fps);
@@ -249,8 +259,10 @@
// Indicates that touch interaction is taking place.
void onTouchHint();
- void setDisplayPowerMode(PhysicalDisplayId, hal::PowerMode powerMode)
- REQUIRES(kMainThreadContext);
+ void setDisplayPowerMode(PhysicalDisplayId, hal::PowerMode) REQUIRES(kMainThreadContext);
+
+ // TODO(b/255635821): Track this per display.
+ void setActiveDisplayPowerModeForRefreshRateStats(hal::PowerMode) REQUIRES(kMainThreadContext);
ConstVsyncSchedulePtr getVsyncSchedule(std::optional<PhysicalDisplayId> = std::nullopt) const
EXCLUDES(mDisplayLock);
@@ -464,9 +476,14 @@
const FeatureFlags mFeatures;
+ // Stores phase offsets configured per refresh rate.
+ const std::unique_ptr<VsyncConfiguration> mVsyncConfiguration;
+
// Shifts the VSYNC phase during certain transactions and refresh rate changes.
const sp<VsyncModulator> mVsyncModulator;
+ const std::unique_ptr<RefreshRateStats> mRefreshRateStats;
+
// Used to choose refresh rate if content detection is enabled.
LayerHistory mLayerHistory;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 2503efc..4d04aad 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -1108,7 +1108,7 @@
outMode.peakRefreshRate = peakFps.getValue();
outMode.vsyncRate = mode->getVsyncRate().getValue();
- const auto vsyncConfigSet = mVsyncConfiguration->getConfigsForRefreshRate(
+ const auto vsyncConfigSet = mScheduler->getVsyncConfiguration().getConfigsForRefreshRate(
Fps::fromValue(outMode.peakRefreshRate));
outMode.appVsyncOffset = vsyncConfigSet.late.appOffset;
outMode.sfVsyncOffset = vsyncConfigSet.late.sfOffset;
@@ -1267,7 +1267,7 @@
mScheduler->modulateVsync(displayId, &VsyncModulator::onRefreshRateChangeInitiated);
if (displayId == mActiveDisplayId) {
- updatePhaseConfiguration(mode.fps);
+ mScheduler->updatePhaseConfiguration(mode.fps);
}
mScheduler->setModeChangePending(true);
@@ -1276,8 +1276,7 @@
mScheduler->setRenderRate(displayId, mode.fps);
if (displayId == mActiveDisplayId) {
- updatePhaseConfiguration(mode.fps);
- mRefreshRateStats->setRefreshRate(mode.fps);
+ mScheduler->updatePhaseConfiguration(mode.fps);
}
if (emitEvent) {
@@ -1369,8 +1368,7 @@
activeMode.fps);
if (displayId == mActiveDisplayId) {
- mRefreshRateStats->setRefreshRate(activeMode.fps);
- updatePhaseConfiguration(activeMode.fps);
+ mScheduler->updatePhaseConfiguration(activeMode.fps);
}
if (pendingModeOpt->emitEvent) {
@@ -1399,7 +1397,7 @@
mScheduler->setRenderRate(displayId, renderFps);
if (displayId == mActiveDisplayId) {
- updatePhaseConfiguration(renderFps);
+ mScheduler->updatePhaseConfiguration(renderFps);
}
}
@@ -2756,7 +2754,8 @@
if (!getHwComposer().getComposer()->isSupported(
Hwc2::Composer::OptionalFeature::ExpectedPresentTime) &&
pacesetterTarget.wouldPresentEarly(minFramePeriod)) {
- const auto hwcMinWorkDuration = mVsyncConfiguration->getCurrentConfigs().hwcMinWorkDuration;
+ const auto hwcMinWorkDuration =
+ mScheduler->getVsyncConfiguration().getCurrentConfigs().hwcMinWorkDuration;
// TODO(b/255601557): Calculate and pass per-display values for each FrameTarget.
refreshArgs.earliestPresentTime =
@@ -3064,7 +3063,8 @@
const auto schedule = mScheduler->getVsyncSchedule();
const TimePoint vsyncDeadline = schedule->vsyncDeadlineAfter(presentTime);
const Period vsyncPeriod = schedule->period();
- const nsecs_t vsyncPhase = mVsyncConfiguration->getCurrentConfigs().late.sfOffset;
+ const nsecs_t vsyncPhase =
+ mScheduler->getVsyncConfiguration().getCurrentConfigs().late.sfOffset;
const CompositorTiming compositorTiming(vsyncDeadline.ns(), vsyncPeriod.ns(), vsyncPhase,
presentLatency.ns());
@@ -3741,7 +3741,7 @@
// TODO(b/175678251) Call a listener instead.
if (currentState.physical->hwcDisplayId == getHwComposer().getPrimaryHwcDisplayId()) {
- resetPhaseConfiguration(display->getActiveMode().fps);
+ mScheduler->resetPhaseConfiguration(display->getActiveMode().fps);
}
}
return;
@@ -3777,15 +3777,6 @@
}
}
-void SurfaceFlinger::resetPhaseConfiguration(Fps refreshRate) {
- // Cancel the pending refresh rate change, if any, before updating the phase configuration.
- mScheduler->vsyncModulator().cancelRefreshRateChange();
-
- mVsyncConfiguration->reset();
- updatePhaseConfiguration(refreshRate);
- mRefreshRateStats->setRefreshRate(refreshRate);
-}
-
void SurfaceFlinger::processDisplayChangesLocked() {
// here we take advantage of Vector's copy-on-write semantics to
// improve performance by skipping the transaction entirely when
@@ -4202,10 +4193,6 @@
const auto activeMode = display->refreshRateSelector().getActiveMode();
const Fps activeRefreshRate = activeMode.fps;
- mRefreshRateStats =
- std::make_unique<RefreshRateStats>(*mTimeStats, activeRefreshRate, hal::PowerMode::OFF);
-
- mVsyncConfiguration = getFactory().createVsyncConfiguration(activeRefreshRate);
FeatureFlags features;
@@ -4232,11 +4219,9 @@
features |= Feature::kBackpressureGpuComposition;
}
- auto modulatorPtr = sp<VsyncModulator>::make(mVsyncConfiguration->getCurrentConfigs());
-
mScheduler = std::make_unique<Scheduler>(static_cast<ICompositor&>(*this),
static_cast<ISchedulerCallback&>(*this), features,
- std::move(modulatorPtr),
+ getFactory(), activeRefreshRate, *mTimeStats,
static_cast<IVsyncTrackerCallback&>(*this));
mScheduler->registerDisplay(display->getPhysicalId(), display->holdRefreshRateSelector());
if (FlagManager::getInstance().vrr_config()) {
@@ -4244,7 +4229,7 @@
}
mScheduler->startTimers();
- const auto configs = mVsyncConfiguration->getCurrentConfigs();
+ const auto configs = mScheduler->getVsyncConfiguration().getCurrentConfigs();
mAppConnectionHandle =
mScheduler->createEventThread(Scheduler::Cycle::Render,
@@ -4266,12 +4251,6 @@
mFpsReporter = sp<FpsReporter>::make(*mFrameTimeline, *this);
}
-void SurfaceFlinger::updatePhaseConfiguration(Fps refreshRate) {
- mVsyncConfiguration->setRefreshRateFps(refreshRate);
- mScheduler->setVsyncConfigSet(mVsyncConfiguration->getCurrentConfigs(),
- refreshRate.getPeriod());
-}
-
void SurfaceFlinger::doCommitTransactions() {
ATRACE_CALL();
@@ -6026,7 +6005,7 @@
if (displayId == mActiveDisplayId) {
mTimeStats->setPowerMode(mode);
- mRefreshRateStats->setPowerMode(mode);
+ mScheduler->setActiveDisplayPowerModeForRefreshRateStats(mode);
}
mScheduler->setDisplayPowerMode(displayId, mode);
@@ -6191,10 +6170,6 @@
dumper.dump("debugDisplayModeSetByBackdoor"sv, mDebugDisplayModeSetByBackdoor);
dumper.eol();
- mRefreshRateStats->dump(result);
- dumper.eol();
-
- mVsyncConfiguration->dump(result);
StringAppendF(&result,
" present offset: %9" PRId64 " ns\t VSYNC period: %9" PRId64
" ns\n\n",
@@ -8634,7 +8609,8 @@
}
int SurfaceFlinger::getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const {
- const auto vsyncConfig = mVsyncConfiguration->getConfigsForRefreshRate(refreshRate).late;
+ const auto vsyncConfig =
+ mScheduler->getVsyncConfiguration().getConfigsForRefreshRate(refreshRate).late;
const auto presentLatency = vsyncConfig.appWorkDuration + vsyncConfig.sfWorkDuration;
return calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
}
@@ -8727,7 +8703,7 @@
mActiveDisplayId = activeDisplay.getPhysicalId();
activeDisplay.getCompositionDisplay()->setLayerCachingTexturePoolEnabled(true);
- resetPhaseConfiguration(activeDisplay.getActiveMode().fps);
+ mScheduler->resetPhaseConfiguration(activeDisplay.getActiveMode().fps);
// TODO(b/255635711): Check for pending mode changes on other displays.
mScheduler->setModeChangePending(false);
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 72003cd..5846214 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -82,7 +82,6 @@
#include "MutexUtils.h"
#include "Scheduler/ISchedulerCallback.h"
#include "Scheduler/RefreshRateSelector.h"
-#include "Scheduler/RefreshRateStats.h"
#include "Scheduler/Scheduler.h"
#include "SurfaceFlingerFactory.h"
#include "ThreadContext.h"
@@ -785,9 +784,6 @@
void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
- void resetPhaseConfiguration(Fps) REQUIRES(mStateLock, kMainThreadContext);
- void updatePhaseConfiguration(Fps) REQUIRES(mStateLock);
-
/*
* Transactions
*/
@@ -1374,10 +1370,6 @@
scheduler::ConnectionHandle mAppConnectionHandle;
scheduler::ConnectionHandle mSfConnectionHandle;
- // Stores phase offsets configured per refresh rate.
- std::unique_ptr<scheduler::VsyncConfiguration> mVsyncConfiguration;
-
- std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
bool mLumaSampling = true;
diff --git a/services/surfaceflinger/Utils/Dumper.h b/services/surfaceflinger/Utils/Dumper.h
index ee94217..62d2ebb 100644
--- a/services/surfaceflinger/Utils/Dumper.h
+++ b/services/surfaceflinger/Utils/Dumper.h
@@ -35,6 +35,8 @@
void eol() { mOut += '\n'; }
+ std::string& out() { return mOut; }
+
void dump(std::string_view name, std::string_view value = {}) {
using namespace std::string_view_literals;
diff --git a/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h b/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
index 4fc39cc..04c1977 100644
--- a/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
+++ b/services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h
@@ -224,20 +224,13 @@
class TestableScheduler : public Scheduler, private ICompositor {
public:
- TestableScheduler(const std::shared_ptr<scheduler::RefreshRateSelector>& selectorPtr,
- sp<VsyncModulator> modulatorPtr, ISchedulerCallback& callback,
- IVsyncTrackerCallback& vsyncTrackerCallback)
- : TestableScheduler(std::make_unique<android::mock::VsyncController>(),
- std::make_shared<android::mock::VSyncTracker>(), selectorPtr,
- std::move(modulatorPtr), callback, vsyncTrackerCallback) {}
-
TestableScheduler(std::unique_ptr<VsyncController> controller,
VsyncSchedule::TrackerPtr tracker,
std::shared_ptr<RefreshRateSelector> selectorPtr,
- sp<VsyncModulator> modulatorPtr, ISchedulerCallback& callback,
- IVsyncTrackerCallback& vsyncTrackerCallback)
- : Scheduler(*this, callback, Feature::kContentDetection, std::move(modulatorPtr),
- vsyncTrackerCallback) {
+ surfaceflinger::Factory& factory, TimeStats& timeStats,
+ ISchedulerCallback& callback, IVsyncTrackerCallback& vsyncTrackerCallback)
+ : Scheduler(*this, callback, Feature::kContentDetection, factory,
+ selectorPtr->getActiveMode().fps, timeStats, vsyncTrackerCallback) {
const auto displayId = selectorPtr->getActiveMode().modePtr->getPhysicalDisplayId();
registerDisplayInternal(displayId, std::move(selectorPtr),
std::shared_ptr<VsyncSchedule>(
@@ -671,19 +664,11 @@
}
mRefreshRateSelector = std::make_shared<scheduler::RefreshRateSelector>(modes, kModeId60);
- const auto fps = mRefreshRateSelector->getActiveMode().modePtr->getVsyncRate();
- mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
-
- mFlinger->mRefreshRateStats =
- std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
- hal::PowerMode::OFF);
-
- auto modulatorPtr = sp<scheduler::VsyncModulator>::make(
- mFlinger->mVsyncConfiguration->getCurrentConfigs());
mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
std::move(vsyncTracker), mRefreshRateSelector,
- std::move(modulatorPtr), *(callback ?: this),
+ mFactory, *mFlinger->mTimeStats,
+ *(callback ?: this),
*(vsyncTrackerCallback ?: this));
mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
diff --git a/services/surfaceflinger/fuzzer/surfaceflinger_scheduler_fuzzer.cpp b/services/surfaceflinger/fuzzer/surfaceflinger_scheduler_fuzzer.cpp
index 649ad25..0a0533c 100644
--- a/services/surfaceflinger/fuzzer/surfaceflinger_scheduler_fuzzer.cpp
+++ b/services/surfaceflinger/fuzzer/surfaceflinger_scheduler_fuzzer.cpp
@@ -24,6 +24,7 @@
#include "Scheduler/OneShotTimer.h"
#include "Scheduler/RefreshRateSelector.h"
+#include "Scheduler/RefreshRateStats.h"
#include "Scheduler/VSyncDispatchTimerQueue.h"
#include "Scheduler/VSyncPredictor.h"
#include "Scheduler/VSyncReactor.h"
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index c75f902..5809ea0 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -118,6 +118,7 @@
"RefreshRateSelectorTest.cpp",
"RefreshRateStatsTest.cpp",
"RegionSamplingTest.cpp",
+ "TestableScheduler.cpp",
"TimeStatsTest.cpp",
"FrameTracerTest.cpp",
"TransactionApplicationTest.cpp",
diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryIntegrationTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryIntegrationTest.cpp
index e9d2319..734fddb 100644
--- a/services/surfaceflinger/tests/unittests/LayerHistoryIntegrationTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerHistoryIntegrationTest.cpp
@@ -167,10 +167,10 @@
mock::SchedulerCallback mSchedulerCallback;
mock::VsyncTrackerCallback mVsyncTrackerCallback;
- TestableScheduler* mScheduler =
- new TestableScheduler(mSelector, mSchedulerCallback, mVsyncTrackerCallback);
-
TestableSurfaceFlinger mFlinger;
+
+ TestableScheduler* mScheduler =
+ new TestableScheduler(mSelector, mFlinger, mSchedulerCallback, mVsyncTrackerCallback);
};
namespace {
diff --git a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
index 0ae3ca3..9456e37 100644
--- a/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerHistoryTest.cpp
@@ -148,10 +148,9 @@
mock::SchedulerCallback mSchedulerCallback;
mock::VsyncTrackerCallback mVsyncTrackerCallback;
- TestableScheduler* mScheduler =
- new TestableScheduler(mSelector, mSchedulerCallback, mVsyncTrackerCallback);
-
TestableSurfaceFlinger mFlinger;
+ TestableScheduler* mScheduler =
+ new TestableScheduler(mSelector, mFlinger, mSchedulerCallback, mVsyncTrackerCallback);
};
namespace {
diff --git a/services/surfaceflinger/tests/unittests/LayerInfoTest.cpp b/services/surfaceflinger/tests/unittests/LayerInfoTest.cpp
index 07a522a..22cfbd8 100644
--- a/services/surfaceflinger/tests/unittests/LayerInfoTest.cpp
+++ b/services/surfaceflinger/tests/unittests/LayerInfoTest.cpp
@@ -65,9 +65,9 @@
DisplayModeId(0));
mock::SchedulerCallback mSchedulerCallback;
mock::VsyncTrackerCallback mVsyncTrackerCallback;
- TestableScheduler* mScheduler =
- new TestableScheduler(mSelector, mSchedulerCallback, mVsyncTrackerCallback);
TestableSurfaceFlinger mFlinger;
+ TestableScheduler* mScheduler =
+ new TestableScheduler(mSelector, mFlinger, mSchedulerCallback, mVsyncTrackerCallback);
};
namespace {
diff --git a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
index 7fdca71..6986689 100644
--- a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp
@@ -96,15 +96,14 @@
mock::SchedulerCallback mSchedulerCallback;
mock::VsyncTrackerCallback mVsyncTrackerCallback;
+ TestableSurfaceFlinger mFlinger;
TestableScheduler* mScheduler =
- new TestableScheduler{mSelector, mSchedulerCallback, mVsyncTrackerCallback};
+ new TestableScheduler{mSelector, mFlinger, mSchedulerCallback, mVsyncTrackerCallback};
surfaceflinger::frontend::LayerHierarchyBuilder mLayerHierarchyBuilder;
ConnectionHandle mConnectionHandle;
MockEventThread* mEventThread;
sp<MockEventThreadConnection> mEventThreadConnection;
-
- TestableSurfaceFlinger mFlinger;
};
SchedulerTest::SchedulerTest() {
@@ -575,7 +574,8 @@
TestableScheduler scheduler{std::make_unique<android::mock::VsyncController>(),
vrrTracker,
vrrSelectorPtr,
- sp<VsyncModulator>::make(VsyncConfigSet{}),
+ mFlinger.getFactory(),
+ mFlinger.getTimeStats(),
mSchedulerCallback,
mVsyncTrackerCallback};
diff --git a/services/surfaceflinger/tests/unittests/TestableScheduler.cpp b/services/surfaceflinger/tests/unittests/TestableScheduler.cpp
new file mode 100644
index 0000000..e0b7366
--- /dev/null
+++ b/services/surfaceflinger/tests/unittests/TestableScheduler.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright 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.
+ */
+
+#include "TestableScheduler.h"
+#include "TestableSurfaceFlinger.h"
+
+namespace android::scheduler {
+
+TestableScheduler::TestableScheduler(RefreshRateSelectorPtr selectorPtr,
+ TestableSurfaceFlinger& testableSurfaceFlinger,
+ ISchedulerCallback& callback,
+ IVsyncTrackerCallback& vsyncTrackerCallback)
+ : TestableScheduler(std::make_unique<android::mock::VsyncController>(),
+ std::make_shared<android::mock::VSyncTracker>(), std::move(selectorPtr),
+ testableSurfaceFlinger.getFactory(),
+ testableSurfaceFlinger.getTimeStats(), callback, vsyncTrackerCallback) {}
+
+} // namespace android::scheduler
diff --git a/services/surfaceflinger/tests/unittests/TestableScheduler.h b/services/surfaceflinger/tests/unittests/TestableScheduler.h
index 2a1b88e..6213713 100644
--- a/services/surfaceflinger/tests/unittests/TestableScheduler.h
+++ b/services/surfaceflinger/tests/unittests/TestableScheduler.h
@@ -32,25 +32,27 @@
#include "mock/MockVSyncTracker.h"
#include "mock/MockVsyncController.h"
+namespace android {
+class TestableSurfaceFlinger;
+} // namespace android
+
namespace android::scheduler {
class TestableScheduler : public Scheduler, private ICompositor {
public:
- TestableScheduler(RefreshRateSelectorPtr selectorPtr, ISchedulerCallback& callback,
- IVsyncTrackerCallback& vsyncTrackerCallback)
- : TestableScheduler(std::make_unique<mock::VsyncController>(),
- std::make_shared<mock::VSyncTracker>(), std::move(selectorPtr),
- sp<VsyncModulator>::make(VsyncConfigSet{}), callback,
- vsyncTrackerCallback) {}
+ TestableScheduler(RefreshRateSelectorPtr selectorPtr,
+ TestableSurfaceFlinger& testableSurfaceFlinger, ISchedulerCallback& callback,
+ IVsyncTrackerCallback& vsyncTrackerCallback);
TestableScheduler(std::unique_ptr<VsyncController> controller,
std::shared_ptr<VSyncTracker> tracker, RefreshRateSelectorPtr selectorPtr,
- sp<VsyncModulator> modulatorPtr, ISchedulerCallback& schedulerCallback,
+ surfaceflinger::Factory& factory, TimeStats& timeStats,
+ ISchedulerCallback& schedulerCallback,
IVsyncTrackerCallback& vsyncTrackerCallback)
: Scheduler(*this, schedulerCallback,
(FeatureFlags)Feature::kContentDetection |
Feature::kSmallDirtyContentDetection,
- std::move(modulatorPtr), vsyncTrackerCallback) {
+ factory, selectorPtr->getActiveMode().fps, timeStats, vsyncTrackerCallback) {
const auto displayId = selectorPtr->getActiveMode().modePtr->getPhysicalDisplayId();
registerDisplay(displayId, std::move(selectorPtr), std::move(controller),
std::move(tracker));
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 27030d1..28549a6 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -216,6 +216,10 @@
using DisplayModesVariant = std::variant<DefaultDisplayMode, RefreshRateSelectorPtr>;
+ surfaceflinger::Factory& getFactory() { return mFactory; }
+
+ TimeStats& getTimeStats() { return *mFlinger->mTimeStats; }
+
void setupScheduler(
std::unique_ptr<scheduler::VsyncController> vsyncController,
std::shared_ptr<scheduler::VSyncTracker> vsyncTracker,
@@ -234,13 +238,6 @@
},
[](RefreshRateSelectorPtr selectorPtr) { return selectorPtr; });
- const auto fps = selectorPtr->getActiveMode().fps;
- mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
-
- mFlinger->mRefreshRateStats =
- std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
- hal::PowerMode::OFF);
-
mTokenManager = std::make_unique<frametimeline::impl::TokenManager>();
using ISchedulerCallback = scheduler::ISchedulerCallback;
@@ -254,23 +251,21 @@
? static_cast<VsyncTrackerCallback&>(mNoOpVsyncTrackerCallback)
: static_cast<VsyncTrackerCallback&>(mVsyncTrackerCallback);
- auto modulatorPtr = sp<scheduler::VsyncModulator>::make(
- mFlinger->mVsyncConfiguration->getCurrentConfigs());
-
if (useNiceMock) {
mScheduler =
new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
std::move(vsyncTracker),
std::move(selectorPtr),
- std::move(modulatorPtr),
+ mFactory,
+ *mFlinger->mTimeStats,
schedulerCallback,
vsyncTrackerCallback);
} else {
mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
std::move(vsyncTracker),
- std::move(selectorPtr),
- std::move(modulatorPtr),
- schedulerCallback, vsyncTrackerCallback);
+ std::move(selectorPtr), mFactory,
+ *mFlinger->mTimeStats, schedulerCallback,
+ vsyncTrackerCallback);
}
mScheduler->initVsync(mScheduler->getVsyncSchedule()->getDispatch(), *mTokenManager, 0ms);