SF: add VSyncDispatch timing objects (cc27b50f) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -166,6 +166,7 @@ filegroup {
		"Scheduler/Scheduler.cpp",
		"Scheduler/SchedulerUtils.cpp",
		"Scheduler/VSyncDispatchTimerQueue.cpp",
		"Scheduler/Timer.cpp",
		"Scheduler/VSyncModulator.cpp",
		"StartPropertySetThread.cpp",
		"SurfaceFlinger.cpp",

services/surfaceflinger/Scheduler/Timer.cpp

0 → 100644

+181 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 "SchedulerTimer"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		#include <log/log.h>
		#include <sys/epoll.h>
		#include <sys/timerfd.h>
		#include <sys/unistd.h>
		#include <utils/Trace.h>
		#include <chrono>
		#include <cstdint>

		#include "Timer.h"

		namespace android::scheduler {

		static constexpr size_t kReadPipe = 0;
		static constexpr size_t kWritePipe = 1;

		template <class T, size_t N>
		constexpr size_t arrayLen(T (&)[N]) {
		return N;
		}

		Timer::Timer()
		: mTimerFd(timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC \| TFD_NONBLOCK)),
		mEpollFd(epoll_create1(EPOLL_CLOEXEC)) {
		if (pipe2(mPipes.data(), O_CLOEXEC \| O_NONBLOCK)) {
		ALOGE("could not create TimerDispatch mPipes");
		};

		mDispatchThread = std::thread(std::bind(&Timer::dispatch, this));
		}

		Timer::~Timer() {
		endDispatch();
		mDispatchThread.join();

		close(mPipes[kWritePipe]);
		close(mPipes[kReadPipe]);
		close(mEpollFd);
		close(mTimerFd);
		}

		void Timer::endDispatch() {
		static constexpr unsigned char end = 'e';
		write(mPipes[kWritePipe], &end, sizeof(end));
		}

		nsecs_t Timer::now() const {
		return systemTime(SYSTEM_TIME_MONOTONIC);
		}

		constexpr char const* timerTraceTag = "AlarmInNs";
		void Timer::alarmIn(std::function<void()> const& cb, nsecs_t fireIn) {
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		ATRACE_INT64(timerTraceTag, fireIn);

		using namespace std::literals;
		static constexpr int ns_per_s =
		std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count();

		mCallback = cb;

		struct itimerspec old_timer;
		struct itimerspec new_timer {
		.it_interval = {.tv_sec = 0, .tv_nsec = 0},
		.it_value = {.tv_sec = static_cast<long>(fireIn / ns_per_s),
		.tv_nsec = static_cast<long>(fireIn % ns_per_s)},
		};

		if (timerfd_settime(mTimerFd, 0, &new_timer, &old_timer)) {
		ALOGW("Failed to set timerfd");
		}
		}

		void Timer::alarmCancel() {
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		ATRACE_INT64(timerTraceTag, 0);

		struct itimerspec old_timer;
		struct itimerspec new_timer {
		.it_interval = {.tv_sec = 0, .tv_nsec = 0},
		.it_value = {
		.tv_sec = 0,
		.tv_nsec = 0,
		},
		};

		if (timerfd_settime(mTimerFd, 0, &new_timer, &old_timer)) {
		ALOGW("Failed to disarm timerfd");
		}
		}

		void Timer::dispatch() {
		struct sched_param param = {0};
		param.sched_priority = 2;
		if (pthread_setschedparam(pthread_self(), SCHED_FIFO, &param) != 0) {
		ALOGW("Failed to set SCHED_FIFO on dispatch thread");
		}

		if (pthread_setname_np(pthread_self(), "TimerDispatch")) {
		ALOGW("Failed to set thread name on dispatch thread");
		}

		enum DispatchType : uint32_t { TIMER, TERMINATE, MAX_DISPATCH_TYPE };
		epoll_event timerEvent;
		timerEvent.events = EPOLLIN;
		timerEvent.data.u32 = DispatchType::TIMER;
		if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mTimerFd, &timerEvent) == -1) {
		ALOGE("Error adding timer fd to epoll dispatch loop");
		return;
		}

		epoll_event terminateEvent;
		terminateEvent.events = EPOLLIN;
		terminateEvent.data.u32 = DispatchType::TERMINATE;
		if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mPipes[kReadPipe], &terminateEvent) == -1) {
		ALOGE("Error adding control fd to dispatch loop");
		return;
		}

		uint64_t iteration = 0;
		char const traceNamePrefix[] = "TimerIteration #";
		static constexpr size_t max64print = std::numeric_limits<decltype(iteration)>::digits10;
		static constexpr size_t maxlen = arrayLen(traceNamePrefix) + max64print;
		std::array<char, maxlen> str_buffer;
		auto timing = true;
		while (timing) {
		epoll_event events[DispatchType::MAX_DISPATCH_TYPE];
		int nfds = epoll_wait(mEpollFd, events, DispatchType::MAX_DISPATCH_TYPE, -1);

		if (ATRACE_ENABLED()) {
		snprintf(str_buffer.data(), str_buffer.size(), "%s%" PRIu64, traceNamePrefix,
		iteration++);
		ATRACE_NAME(str_buffer.data());
		}

		if (nfds == -1) {
		if (errno != EINTR) {
		timing = false;
		continue;
		}
		}

		for (auto i = 0; i < nfds; i++) {
		if (events[i].data.u32 == DispatchType::TIMER) {
		static uint64_t mIgnored = 0;
		read(mTimerFd, &mIgnored, sizeof(mIgnored));
		std::function<void()> cb;
		{
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		cb = mCallback;
		}
		if (cb) {
		cb();
		}
		}
		if (events[i].data.u32 == DispatchType::TERMINATE) {
		timing = false;
		}
		}
		}
		}

		} // namespace android::scheduler

services/surfaceflinger/Scheduler/Timer.h

0 → 100644

+51 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 "TimeKeeper.h"

		#include <android-base/thread_annotations.h>
		#include <array>
		#include <thread>

		namespace android::scheduler {

		class Timer : public TimeKeeper {
		public:
		Timer();
		~Timer();
		nsecs_t now() const final;

		// NB: alarmIn and alarmCancel are threadsafe; with the last-returning function being effectual
		// Most users will want to serialize thes calls so as to be aware of the timer state.
		void alarmIn(std::function<void()> const& cb, nsecs_t fireIn) final;
		void alarmCancel() final;

		private:
		int const mTimerFd;
		int const mEpollFd;
		std::array<int, 2> mPipes;

		std::thread mDispatchThread;
		void dispatch();
		void endDispatch();

		std::mutex mMutex;
		std::function<void()> mCallback GUARDED_BY(mMutex);
		};

		} // namespace android::scheduler

services/surfaceflinger/tests/unittests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ cc_test {
		"TransactionApplicationTest.cpp",
		"StrongTypingTest.cpp",
		"VSyncDispatchTimerQueueTest.cpp",
		"VSyncDispatchRealtimeTest.cpp",
		"mock/DisplayHardware/MockComposer.cpp",
		"mock/DisplayHardware/MockDisplay.cpp",
		"mock/DisplayHardware/MockPowerAdvisor.cpp",

services/surfaceflinger/tests/unittests/VSyncDispatchRealtimeTest.cpp

0 → 100644

+201 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 "Scheduler/TimeKeeper.h"
		#include "Scheduler/Timer.h"
		#include "Scheduler/VSyncDispatchTimerQueue.h"
		#include "Scheduler/VSyncTracker.h"

		#include <gmock/gmock.h>
		#include <gtest/gtest.h>
		#include <thread>

		using namespace testing;
		using namespace std::literals;

		namespace android::scheduler {

		template <typename Rep, typename Per>
		constexpr nsecs_t toNs(std::chrono::duration<Rep, Per> const& tp) {
		return std::chrono::duration_cast<std::chrono::nanoseconds>(tp).count();
		}

		class FixedRateIdealStubTracker : public VSyncTracker {
		public:
		FixedRateIdealStubTracker() : mPeriod{toNs(3ms)} {}

		void addVsyncTimestamp(nsecs_t) final {}

		nsecs_t nextAnticipatedVSyncTimeFrom(nsecs_t timePoint) const final {
		auto const floor = timePoint % mPeriod;
		if (floor == 0) {
		return timePoint;
		}
		return timePoint - floor + mPeriod;
		}

		private:
		nsecs_t const mPeriod;
		};

		class VRRStubTracker : public VSyncTracker {
		public:
		VRRStubTracker(nsecs_t period) : mPeriod{period} {}

		void addVsyncTimestamp(nsecs_t) final {}

		nsecs_t nextAnticipatedVSyncTimeFrom(nsecs_t time_point) const final {
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		auto const normalized_to_base = time_point - mBase;
		auto const floor = (normalized_to_base) % mPeriod;
		if (floor == 0) {
		return time_point;
		}
		return normalized_to_base - floor + mPeriod + mBase;
		}

		void set_interval(nsecs_t interval, nsecs_t last_known) {
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		mPeriod = interval;
		mBase = last_known;
		}

		private:
		std::mutex mutable mMutex;
		nsecs_t mPeriod;
		nsecs_t mBase = 0;
		};

		struct VSyncDispatchRealtimeTest : testing::Test {
		static nsecs_t constexpr mDispatchGroupThreshold = toNs(100us);
		static size_t constexpr mIterations = 20;
		};

		class RepeatingCallbackReceiver {
		public:
		RepeatingCallbackReceiver(VSyncDispatch& dispatch, nsecs_t wl)
		: mWorkload(wl),
		mCallback(
		dispatch, [&](auto time) { callback_called(time); }, "repeat0") {}

		void repeatedly_schedule(size_t iterations, std::function<void(nsecs_t)> const& onEachFrame) {
		mCallbackTimes.reserve(iterations);
		mCallback.schedule(mWorkload, systemTime(SYSTEM_TIME_MONOTONIC) + mWorkload);

		for (auto i = 0u; i < iterations - 1; i++) {
		std::unique_lock<decltype(mMutex)> lk(mMutex);
		mCv.wait(lk, [&] { return mCalled; });
		mCalled = false;
		auto last = mLastTarget;
		lk.unlock();

		onEachFrame(last);

		mCallback.schedule(mWorkload, last + mWorkload);
		}

		// wait for the last callback.
		std::unique_lock<decltype(mMutex)> lk(mMutex);
		mCv.wait(lk, [&] { return mCalled; });
		}

		void with_callback_times(std::function<void(std::vector<nsecs_t> const&)> const& fn) const {
		fn(mCallbackTimes);
		}

		private:
		void callback_called(nsecs_t time) {
		std::lock_guard<decltype(mMutex)> lk(mMutex);
		mCallbackTimes.push_back(time);
		mCalled = true;
		mLastTarget = time;
		mCv.notify_all();
		}

		nsecs_t const mWorkload;
		VSyncCallbackRegistration mCallback;

		std::mutex mMutex;
		std::condition_variable mCv;
		bool mCalled = false;
		nsecs_t mLastTarget = 0;
		std::vector<nsecs_t> mCallbackTimes;
		};

		TEST_F(VSyncDispatchRealtimeTest, triple_alarm) {
		FixedRateIdealStubTracker tracker;
		VSyncDispatchTimerQueue dispatch(std::make_unique<Timer>(), tracker, mDispatchGroupThreshold);

		static size_t constexpr num_clients = 3;
		std::array<RepeatingCallbackReceiver, num_clients>
		cb_receiver{RepeatingCallbackReceiver(dispatch, toNs(1500us)),
		RepeatingCallbackReceiver(dispatch, toNs(0h)),
		RepeatingCallbackReceiver(dispatch, toNs(1ms))};

		auto const on_each_frame = [](nsecs_t) {};
		std::array<std::thread, num_clients> threads{
		std::thread([&] { cb_receiver[0].repeatedly_schedule(mIterations, on_each_frame); }),
		std::thread([&] { cb_receiver[1].repeatedly_schedule(mIterations, on_each_frame); }),
		std::thread([&] { cb_receiver[2].repeatedly_schedule(mIterations, on_each_frame); }),
		};

		for (auto it = threads.rbegin(); it != threads.rend(); it++) {
		it->join();
		}

		for (auto const& cbs : cb_receiver) {
		cbs.with_callback_times([](auto times) { EXPECT_THAT(times.size(), Eq(mIterations)); });
		}
		}

		// starts at 333hz, slides down to 43hz
		TEST_F(VSyncDispatchRealtimeTest, vascillating_vrr) {
		auto next_vsync_interval = toNs(3ms);
		VRRStubTracker tracker(next_vsync_interval);
		VSyncDispatchTimerQueue dispatch(std::make_unique<Timer>(), tracker, mDispatchGroupThreshold);

		RepeatingCallbackReceiver cb_receiver(dispatch, toNs(1ms));

		auto const on_each_frame = [&](nsecs_t last_known) {
		tracker.set_interval(next_vsync_interval += toNs(1ms), last_known);
		};

		std::thread eventThread([&] { cb_receiver.repeatedly_schedule(mIterations, on_each_frame); });
		eventThread.join();

		cb_receiver.with_callback_times([](auto times) { EXPECT_THAT(times.size(), Eq(mIterations)); });
		}

		// starts at 333hz, jumps to 200hz at frame 10
		TEST_F(VSyncDispatchRealtimeTest, fixed_jump) {
		VRRStubTracker tracker(toNs(3ms));
		VSyncDispatchTimerQueue dispatch(std::make_unique<Timer>(), tracker, mDispatchGroupThreshold);

		RepeatingCallbackReceiver cb_receiver(dispatch, toNs(1ms));

		auto jump_frame_counter = 0u;
		auto constexpr jump_frame_at = 10u;
		auto const on_each_frame = [&](nsecs_t last_known) {
		if (jump_frame_counter++ == jump_frame_at) {
		tracker.set_interval(toNs(5ms), last_known);
		}
		};
		std::thread eventThread([&] { cb_receiver.repeatedly_schedule(mIterations, on_each_frame); });
		eventThread.join();

		cb_receiver.with_callback_times([](auto times) { EXPECT_THAT(times.size(), Eq(mIterations)); });
		}
		} // namespace android::scheduler