Execution/Planner

Author: MorganCaron

modules/Execution/Execution.mpp

@@ -1,3 +1,4 @@
 export module CppUtils.Execution;
 
 export import CppUtils.Execution.EventSystem;
+export import CppUtils.Execution.Planner;

modules/Execution/Planner.mpp

@@ -0,0 +1,37 @@
+export module CppUtils.Execution.Planner;
+
+import std;
+import CppUtils.Chrono;
+
+export namespace CppUtils::Execution
+{
+	class Planner final
+	{
+	public:
+		inline ~Planner()
+		{
+			m_active = false;
+			m_conditionVariable.notify_all();
+		}
+
+		inline auto schedule(auto&& function, CppUtils::Chrono::Duration auto delay) -> void
+		{
+			if (not m_active)
+				return;
+
+			m_threads.emplace_back(std::jthread{[this, function = std::forward<decltype(function)>(function), delay]() mutable -> void {
+				auto lockGuard = std::unique_lock{m_mutex};
+				if (m_conditionVariable.wait_for(lockGuard, delay, [this] { return not m_active.load(); }))
+					return;
+				if (m_active)
+					function();
+			}});
+		}
+
+	private:
+		std::atomic<bool> m_active = true;
+		std::vector<std::jthread> m_threads;
+		std::mutex m_mutex;
+		std::condition_variable m_conditionVariable;
+	};
+}

tests/Execution/Planner.mpp

@@ -0,0 +1,54 @@
+export module CppUtils.UnitTests.Execution.Planner;
+
+import std;
+import CppUtils;
+
+export namespace CppUtils::UnitTest::Execution::Planner
+{
+	inline auto _ = TestSuite{
+		"Execution/Planner", {"UnitTest"}, [](auto& suite) {
+		using namespace std::chrono_literals;
+
+		suite.addTest("Schedule and execute", [&] {
+			auto planner = CppUtils::Execution::Planner{};
+			auto executed = std::atomic<bool>{false};
+
+			planner.schedule([&executed] {
+				executed = true;
+			}, 50ms);
+
+			std::this_thread::sleep_for(100ms);
+
+			suite.expect(executed.load());
+		});
+
+		suite.addTest("Cancel tasks on destruction", [&] {
+			auto executed = std::atomic<bool>{false};
+
+			{
+				auto planner = CppUtils::Execution::Planner{};
+
+				planner.schedule([&executed] {
+					executed = true;
+				}, 200ms);
+			}
+
+			std::this_thread::sleep_for(300ms);
+
+			suite.expect(not executed.load());
+		});
+
+		suite.addTest("Multiple tasks", [&] {
+			auto planner = CppUtils::Execution::Planner{};
+			auto counter = std::atomic<std::size_t>{0};
+
+			planner.schedule([&counter] { ++counter; }, 10ms);
+			planner.schedule([&counter] { ++counter; }, 20ms);
+			planner.schedule([&counter] { ++counter; }, 30ms);
+
+			std::this_thread::sleep_for(50ms);
+
+			suite.expectEqual(counter.load(), 3uz);
+		});
+	}};
+}

tests/UnitTests.mpp

@@ -13,6 +13,7 @@ export import CppUtils.UnitTests.Container.Tree;
 export import CppUtils.UnitTests.Container.TypedStack;
 export import CppUtils.UnitTests.Container.Vector;
 export import CppUtils.UnitTests.Execution.EventSystem;
+export import CppUtils.UnitTests.Execution.Planner;
 export import CppUtils.UnitTests.FileSystem.Directory;
 export import CppUtils.UnitTests.FileSystem.File;
 export import CppUtils.UnitTests.FileSystem.Watcher;