Merge "SF: Store VsyncDispatch callbacks in ftl::SmallMap" into main (036c283b) · Commits · e / devices / smdk4412 / android_frameworks_native

services/surfaceflinger/Scheduler/VSyncDispatch.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@ enum class CancelResult { Cancelled, TooLate, Error };
		*/
		class VSyncDispatch {
		public:
		using CallbackToken = StrongTyping<size_t, class CallbackTokenTag, Compare, Hash>;
		using CallbackToken = StrongTyping<size_t, class CallbackTokenTag, Compare>;

		virtual ~VSyncDispatch();

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp

+10 −11

Original line number	Diff line number	Diff line
		@@ -267,15 +267,15 @@ void VSyncDispatchTimerQueue::setTimer(nsecs_t targetTime, nsecs_t /now/) {
		}

		void VSyncDispatchTimerQueue::rearmTimer(nsecs_t now) {
		rearmTimerSkippingUpdateFor(now, mCallbacks.end());
		rearmTimerSkippingUpdateFor(now, mCallbacks.cend());
		}

		void VSyncDispatchTimerQueue::rearmTimerSkippingUpdateFor(
		nsecs_t now, CallbackMap::iterator const& skipUpdateIt) {
		nsecs_t now, CallbackMap::const_iterator skipUpdateIt) {
		std::optional<nsecs_t> min;
		std::optional<nsecs_t> targetVsync;
		std::optional<std::string_view> nextWakeupName;
		for (auto it = mCallbacks.begin(); it != mCallbacks.end(); it++) {
		for (auto it = mCallbacks.cbegin(); it != mCallbacks.cend(); ++it) {
		auto& callback = it->second;
		if (!callback->wakeupTime() && !callback->hasPendingWorkloadUpdate()) {
		continue;
		@@ -351,13 +351,12 @@ void VSyncDispatchTimerQueue::timerCallback() {
		VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback(
		Callback callback, std::string callbackName) {
		std::lock_guard lock(mMutex);
		return CallbackToken{
		mCallbacks
		.emplace(++mCallbackToken,
		return mCallbacks
		.try_emplace(CallbackToken{++mCallbackToken},
		std::make_shared<VSyncDispatchTimerQueueEntry>(std::move(callbackName),
		std::move(callback),
		mMinVsyncDistance))
		.first->first};
		.first->first;
		}

		void VSyncDispatchTimerQueue::unregisterCallback(CallbackToken token) {
		@@ -367,7 +366,7 @@ void VSyncDispatchTimerQueue::unregisterCallback(CallbackToken token) {
		auto it = mCallbacks.find(token);
		if (it != mCallbacks.end()) {
		entry = it->second;
		mCallbacks.erase(it);
		mCallbacks.erase(it->first);
		}
		}

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -16,14 +16,13 @@

		#pragma once

		#include <functional>
		#include <memory>
		#include <mutex>
		#include <string>
		#include <string_view>
		#include <unordered_map>

		#include <android-base/thread_annotations.h>
		#include <ftl/small_map.h>

		#include "VSyncDispatch.h"
		#include "VsyncSchedule.h"
		@@ -135,13 +134,14 @@ private:
		VSyncDispatchTimerQueue(const VSyncDispatchTimerQueue&) = delete;
		VSyncDispatchTimerQueue& operator=(const VSyncDispatchTimerQueue&) = delete;

		// The static capacity was chosen to exceed the expected number of callbacks.
		using CallbackMap =
		std::unordered_map<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>>;
		ftl::SmallMap<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>, 5>;

		void timerCallback();
		void setTimer(nsecs_t, nsecs_t) REQUIRES(mMutex);
		void rearmTimer(nsecs_t now) REQUIRES(mMutex);
		void rearmTimerSkippingUpdateFor(nsecs_t now, CallbackMap::iterator const& skipUpdate)
		void rearmTimerSkippingUpdateFor(nsecs_t now, CallbackMap::const_iterator skipUpdate)
		REQUIRES(mMutex);
		void cancelTimer() REQUIRES(mMutex);
		ScheduleResult scheduleLocked(CallbackToken, ScheduleTiming) REQUIRES(mMutex);