Merge "SF: Set up libscheduler and libscheduler_test" (c862a8a7) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -189,7 +189,6 @@ filegroup {
		"Scheduler/MessageQueue.cpp",
		"Scheduler/RefreshRateConfigs.cpp",
		"Scheduler/Scheduler.cpp",
		"Scheduler/Timer.cpp",
		"Scheduler/VSyncDispatchTimerQueue.cpp",
		"Scheduler/VSyncPredictor.cpp",
		"Scheduler/VSyncReactor.cpp",

services/surfaceflinger/Scheduler/Android.bp

+29 −1

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@ cc_defaults {
		],
		shared_libs: [
		"libbase",
		"libcutils",
		"liblog",
		"libutils",
		],
		}
		@@ -26,10 +28,36 @@ cc_library_headers {
		export_include_dirs: ["include"],
		}

		// TODO(b/185535769): Remove libsurfaceflinger_unittest's dependency on AsyncCallRecorder.
		cc_library_headers {
		name: "libscheduler_test_headers",
		defaults: ["libscheduler_defaults"],
		export_include_dirs: ["tests"],
		}

		cc_library_static {
		name: "libscheduler",
		defaults: ["libscheduler_defaults"],
		srcs: [],
		srcs: [
		"src/Timer.cpp",
		],
		local_include_dirs: ["include"],
		export_include_dirs: ["include"],
		}

		cc_test {
		name: "libscheduler_test",
		test_suites: ["device-tests"],
		defaults: ["libscheduler_defaults"],
		srcs: [
		"tests/TimerTest.cpp",
		],
		static_libs: [
		"libgmock",
		"libgtest",
		"libscheduler",
		],
		sanitize: {
		address: true,
		},
		}

services/surfaceflinger/Scheduler/VSyncDispatch.h

+9 −14

Original line number	Diff line number	Diff line
		@@ -16,17 +16,15 @@

		#pragma once

		#include <utils/Log.h>
		#include <utils/Timers.h>
		#include <functional>
		#include <optional>
		#include <string>

		#include <utils/Timers.h>

		#include "StrongTyping.h"

		namespace android::scheduler {
		class TimeKeeper;
		class VSyncTracker;

		using ScheduleResult = std::optional<nsecs_t>;

		@@ -64,8 +62,7 @@ public:
		* invocation of callbackFn.
		*
		*/
		virtual CallbackToken registerCallback(Callback const& callbackFn,
		std::string callbackName) = 0;
		virtual CallbackToken registerCallback(Callback, std::string callbackName) = 0;

		/*
		* Unregisters a callback.
		@@ -142,8 +139,9 @@ public:

		protected:
		VSyncDispatch() = default;
		VSyncDispatch(VSyncDispatch const&) = delete;
		VSyncDispatch& operator=(VSyncDispatch const&) = delete;

		VSyncDispatch(const VSyncDispatch&) = delete;
		VSyncDispatch& operator=(const VSyncDispatch&) = delete;
		};

		/*
		@@ -152,11 +150,11 @@ protected:
		*/
		class VSyncCallbackRegistration {
		public:
		VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback const& callbackFn,
		std::string const& callbackName);
		VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback, std::string callbackName);
		~VSyncCallbackRegistration();

		VSyncCallbackRegistration(VSyncCallbackRegistration&&);
		VSyncCallbackRegistration& operator=(VSyncCallbackRegistration&&);
		~VSyncCallbackRegistration();

		// See documentation for VSyncDispatch::schedule.
		ScheduleResult schedule(VSyncDispatch::ScheduleTiming scheduleTiming);
		@@ -165,9 +163,6 @@ public:
		CancelResult cancel();

		private:
		VSyncCallbackRegistration(VSyncCallbackRegistration const&) = delete;
		VSyncCallbackRegistration& operator=(VSyncCallbackRegistration const&) = delete;

		std::reference_wrapper<VSyncDispatch> mDispatch;
		VSyncDispatch::CallbackToken mToken;
		bool mValidToken;

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp

+14 −12

Original line number	Diff line number	Diff line
		@@ -22,7 +22,8 @@
		#include <ftl/concat.h>
		#include <utils/Trace.h>

		#include "TimeKeeper.h"
		#include <scheduler/TimeKeeper.h>

		#include "VSyncDispatchTimerQueue.h"
		#include "VSyncTracker.h"

		@@ -31,6 +32,7 @@ namespace android::scheduler {
		using base::StringAppendF;

		namespace {

		nsecs_t getExpectedCallbackTime(nsecs_t nextVsyncTime,
		const VSyncDispatch::ScheduleTiming& timing) {
		return nextVsyncTime - timing.readyDuration - timing.workDuration;
		@@ -42,17 +44,17 @@ nsecs_t getExpectedCallbackTime(VSyncTracker& tracker, nsecs_t now,
		std::max(timing.earliestVsync, now + timing.workDuration + timing.readyDuration));
		return getExpectedCallbackTime(nextVsyncTime, timing);
		}

		} // namespace

		VSyncDispatch::~VSyncDispatch() = default;
		VSyncTracker::~VSyncTracker() = default;
		TimeKeeper::~TimeKeeper() = default;

		VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string const& name,
		VSyncDispatch::Callback const& cb,
		VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string name,
		VSyncDispatch::Callback callback,
		nsecs_t minVsyncDistance)
		: mName(name),
		mCallback(cb),
		: mName(std::move(name)),
		mCallback(std::move(callback)),
		mMinVsyncDistance(minVsyncDistance) {}

		std::optional<nsecs_t> VSyncDispatchTimerQueueEntry::lastExecutedVsyncTarget() const {
		@@ -301,13 +303,13 @@ void VSyncDispatchTimerQueue::timerCallback() {
		}

		VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback(
		Callback const& callbackFn, std::string callbackName) {
		Callback callback, std::string callbackName) {
		std::lock_guard lock(mMutex);
		return CallbackToken{
		mCallbacks
		.emplace(++mCallbackToken,
		std::make_shared<VSyncDispatchTimerQueueEntry>(callbackName,
		callbackFn,
		std::make_shared<VSyncDispatchTimerQueueEntry>(std::move(callbackName),
		std::move(callback),
		mMinVsyncDistance))
		.first->first};
		}
		@@ -402,10 +404,10 @@ void VSyncDispatchTimerQueue::dump(std::string& result) const {
		}

		VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncDispatch& dispatch,
		VSyncDispatch::Callback const& callbackFn,
		std::string const& callbackName)
		VSyncDispatch::Callback callback,
		std::string callbackName)
		: mDispatch(dispatch),
		mToken(dispatch.registerCallback(callbackFn, callbackName)),
		mToken(dispatch.registerCallback(std::move(callback), std::move(callbackName))),
		mValidToken(true) {}

		VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncCallbackRegistration&& other)

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h

+19 −17

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@

		#pragma once

		#include <android-base/thread_annotations.h>
		#include <functional>
		#include <memory>
		#include <mutex>
		@@ -24,10 +23,14 @@
		#include <string_view>
		#include <unordered_map>

		#include <android-base/thread_annotations.h>

		#include "VSyncDispatch.h"

		namespace android::scheduler {

		class VSyncTracker;

		// VSyncDispatchTimerQueueEntry is a helper class representing internal state for each entry in
		// VSyncDispatchTimerQueue hoisted to public for unit testing.
		class VSyncDispatchTimerQueueEntry {
		@@ -36,7 +39,7 @@ public:
		// Valid transition: disarmed -> armed ( when scheduled )
		// Valid transition: armed -> running -> disarmed ( when timer is called)
		// Valid transition: armed -> disarmed ( when cancelled )
		VSyncDispatchTimerQueueEntry(std::string const& name, VSyncDispatch::Callback const& fn,
		VSyncDispatchTimerQueueEntry(std::string name, VSyncDispatch::Callback,
		nsecs_t minVsyncDistance);
		std::string_view name() const;

		@@ -45,10 +48,9 @@ public:
		std::optional<nsecs_t> lastExecutedVsyncTarget() const;

		// This moves the state from disarmed->armed and will calculate the wakeupTime.
		ScheduleResult schedule(VSyncDispatch::ScheduleTiming timing, VSyncTracker& tracker,
		nsecs_t now);
		ScheduleResult schedule(VSyncDispatch::ScheduleTiming, VSyncTracker&, nsecs_t now);
		// This will update armed entries with the latest vsync information. Entry remains armed.
		void update(VSyncTracker& tracker, nsecs_t now);
		void update(VSyncTracker&, nsecs_t now);

		// This will return empty if not armed, or the next calculated wakeup time if armed.
		// It will not update the wakeupTime.
		@@ -81,11 +83,11 @@ public:
		void dump(std::string& result) const;

		private:
		std::string const mName;
		VSyncDispatch::Callback const mCallback;
		const std::string mName;
		const VSyncDispatch::Callback mCallback;

		VSyncDispatch::ScheduleTiming mScheduleTiming;
		nsecs_t const mMinVsyncDistance;
		const nsecs_t mMinVsyncDistance;

		struct ArmingInfo {
		nsecs_t mActualWakeupTime;
		@@ -115,19 +117,19 @@ public:
		// should be grouped into one wakeup.
		// \param[in] minVsyncDistance The minimum distance between two vsync estimates before the
		// vsyncs are considered the same vsync event.
		explicit VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper> tk, VSyncTracker& tracker,
		nsecs_t timerSlack, nsecs_t minVsyncDistance);
		VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper>, VSyncTracker&, nsecs_t timerSlack,
		nsecs_t minVsyncDistance);
		~VSyncDispatchTimerQueue();

		CallbackToken registerCallback(Callback const& callbackFn, std::string callbackName) final;
		void unregisterCallback(CallbackToken token) final;
		ScheduleResult schedule(CallbackToken token, ScheduleTiming scheduleTiming) final;
		CancelResult cancel(CallbackToken token) final;
		void dump(std::string& result) const final;
		CallbackToken registerCallback(Callback, std::string callbackName) final;
		void unregisterCallback(CallbackToken) final;
		ScheduleResult schedule(CallbackToken, ScheduleTiming) final;
		CancelResult cancel(CallbackToken) final;
		void dump(std::string&) const final;

		private:
		VSyncDispatchTimerQueue(VSyncDispatchTimerQueue const&) = delete;
		VSyncDispatchTimerQueue& operator=(VSyncDispatchTimerQueue const&) = delete;
		VSyncDispatchTimerQueue(const VSyncDispatchTimerQueue&) = delete;
		VSyncDispatchTimerQueue& operator=(const VSyncDispatchTimerQueue&) = delete;

		using CallbackMap =
		std::unordered_map<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>>;