Differential D3848 Diff 17391 source/ps/tests/test_ThreadPool.h

Changeset View

Standalone View

source/ps/tests/test_ThreadPool.h

This file was added.

				/* Copyright (C) 2021 Wildfire Games.
				* This file is part of 0 A.D.
				*
				* 0 A.D. is free software: you can redistribute it and/or modify
				* it under the terms of the GNU General Public License as published by
				* the Free Software Foundation, either version 2 of the License, or
				* (at your option) any later version.
				*
				* 0 A.D. is distributed in the hope that it will be useful,
				* but WITHOUT ANY WARRANTY; without even the implied warranty of
				* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
				* GNU General Public License for more details.
				*
				* You should have received a copy of the GNU General Public License
				* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
				*/

				#include "lib/self_test.h"

				#include "ps/Future.h"
				#include "ps/ThreadPool.h"

				#include <atomic>
				#include <condition_variable>
				#include <mutex>

				class TestThreadPool : public CxxTest::TestSuite
				{
				public:
				void test_basic()
				{
				ThreadPool::TaskManager& taskManager = ThreadPool::TaskManager::Instance();
				// There is a minimum of 3.
				TS_ASSERT(taskManager.GetNbOfWorkers() >= 3);

				std::atomic<int> tasks_run = 0;
				auto increment_run = [&tasks_run]() { tasks_run++; };
				Future future = taskManager.GetWorker().Submit(increment_run);
				future.Wait();
				TS_ASSERT_EQUALS(tasks_run.load(), 1);

				// Test Execute.
				std::condition_variable cv;
				std::mutex mutex;
				std::atomic<bool> go = false;
				future = taskManager.GetWorker().Submit([&]() {
				std::unique_lock<std::mutex> lock(mutex);
				cv.wait(lock, [&go]() -> bool { return go; });
				lock.unlock();
				increment_run();
				lock.lock();
				go = false;
				lock.unlock();
				cv.notify_all();
				});
				TS_ASSERT_EQUALS(tasks_run.load(), 1);
				std::unique_lock<std::mutex> lock(mutex);
				go = true;
				lock.unlock();
				cv.notify_all();
				lock.lock();
				cv.wait(lock, [&go]() -> bool { return !go; });
				TS_ASSERT_EQUALS(tasks_run.load(), 2);
				// Wait on the future before the mutex/cv go out of scope.
				future.Wait();
				}

				void test_PoolExecutor()
				{
				ThreadPool::TaskManager& taskManager = ThreadPool::TaskManager::Instance();
				// Push a blocked task on all workers.
				std::condition_variable cv;
				std::mutex mutex;
				bool go = false;
				std::atomic<int> tasks_run = 0;
				std::vector<Future<void>> preTasks;
				for (ThreadPool::ThreadExecutor& exec : taskManager.GetAllWorkers())
				preTasks.emplace_back(exec.Submit([&tasks_run, &cv, &mutex, &go]() {
				std::unique_lock<std::mutex> lock(mutex);
				cv.wait(lock, [&go]() { return go; });
				tasks_run++;
				}));
				// Then push general tasks
				auto increment_run = [&tasks_run]() { tasks_run++; };
				Future future = taskManager.GetExecutor().Submit(increment_run);
				Future futureLow = taskManager.GetLowPriorityExecutor().Submit(increment_run);
				// Then start the pre-tasks, which ought start all of them.
				{
				std::unique_lock<std::mutex> lock(mutex);
				go = true;
				}
				cv.notify_all();
				future.Wait();
				futureLow.Wait();
				for (Future<void>& task : preTasks)
				task.Wait();
				TS_ASSERT_EQUALS(tasks_run.load(), preTasks.size() + 2);
				// Also check with no waiting expected.
				taskManager.GetExecutor().Submit(increment_run).Wait();
				TS_ASSERT_EQUALS(tasks_run.load(), preTasks.size() + 3);
				taskManager.GetLowPriorityExecutor().Submit(increment_run).Wait();
				TS_ASSERT_EQUALS(tasks_run.load(), preTasks.size() + 4);
				}

				void test_Load()
				{
				ThreadPool::TaskManager& taskManager = ThreadPool::TaskManager::Instance();

				#define STAT 100000
				vladislavbelovUnsubmitted Done Inline Actions The name should be more clear. vladislavbelov: The name should be more clear.
				std::vector<Future<int>> futures;
				futures.resize(STAT);
				std::vector<u32> values(STAT);

				auto f1 = taskManager.GetWorker().Submit([&taskManager, &futures]() {
				for (u32 i = 0; i < STAT; i+=3)
				futures[i] = taskManager.GetExecutor().Submit([]() { return 5; });
				});

				auto f2 = taskManager.GetWorker().Submit([&taskManager, &futures]() {
				for (u32 i = 1; i < STAT; i+=3)
				futures[i] = taskManager.GetLowPriorityExecutor().Submit([]() { return 5; });
				});

				auto f3 = taskManager.GetWorker().Submit([&taskManager, &futures]() {
				for (u32 i = 2; i < STAT; i+=3)
				futures[i] = taskManager.GetWorker().Submit([]() { return 5; });
				});

				f1.Wait();
				f2.Wait();
				f3.Wait();

				for (size_t i = 0; i < STAT; ++i)
				TS_ASSERT_EQUALS(futures[i].Get(), 5);
				#undef STAT
				}
				};