核心模板架构

Kernel/tests/renderive/renderable/Renderable_Task_Graph_Test.cpp

@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+#include <memory>
+#include <vector>
+#include "renderive/renderable/Renderable.hpp"
+#include "renderive/scene/Scene.hpp"
+struct Renderable_Task_Graph_Test_Renderable : Renderable_Base {
+    Renderable_Task_Graph_Test_Renderable(Scene_Base& scene, std::vector<int>& order, int base)
+        : Renderable_Base(scene, {.cache_enabled = false}), order(&order), base(base) {}
+    void build_task_graph(Renderable_Task_Graph& graph) override {
+        auto first = graph.emplace([this](const Scene_Render_Context&) {
+            order->push_back(base + 1);
+        }, "first");
+        auto second = graph.emplace([this](const Scene_Render_Context&) {
+            order->push_back(base + 2);
+        }, "second");
+        graph.precede(first, second);
+    }
+    std::vector<int>* order;
+    int base;
+};
+TEST(renderable_task_graph_test, combines_internal_and_external_dependencies) {
+    Scene2D_Context<> scene;
+    std::vector<int> order;
+    auto dependency = std::make_shared<Renderable_Task_Graph_Test_Renderable>(scene, order, 0);
+    auto dependent = std::make_shared<Renderable_Task_Graph_Test_Renderable>(scene, order, 10);
+    scene.attach_renderable(dependency);
+    scene.attach_renderable(dependent);
+    dependency->dependency_node.append_child(dependent->dependency_node);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_EQ(order, (std::vector<int>{1, 2, 11, 12}));
+}
+
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <thread>
+struct Renderable_Task_Graph_Concurrency_Test_Renderable : Renderable_Base {
+    Renderable_Task_Graph_Concurrency_Test_Renderable(Scene_Base& scene, std::atomic<int>& active, std::atomic<int>& maximum)
+        : Renderable_Base(scene, {.cache_enabled = false}), active(&active), maximum(&maximum) {}
+    void build_task_graph(Renderable_Task_Graph& graph) override {
+        auto work = [this](const Scene_Render_Context&) {
+            const int value = active->fetch_add(1, std::memory_order_acq_rel) + 1;
+            int observed = maximum->load(std::memory_order_acquire);
+            while (observed < value && !maximum->compare_exchange_weak(observed, value, std::memory_order_acq_rel)) {}
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            active->fetch_sub(1, std::memory_order_acq_rel);
+        };
+        graph.emplace(work, "parallel_a");
+        graph.emplace(work, "parallel_b");
+    }
+    std::atomic<int>* active;
+    std::atomic<int>* maximum;
+};
+TEST(renderable_task_graph_concurrency_test, DISABLED_runs_independent_internal_tasks_concurrently) {
+    Scene2D_Context<> scene;
+    std::atomic<int> active{};
+    std::atomic<int> maximum{};
+    auto renderable = std::make_shared<Renderable_Task_Graph_Concurrency_Test_Renderable>(scene, active, maximum);
+    scene.attach_renderable(renderable);
+    scene.render();
+    scene.wait_for_render();
+    EXPECT_GE(maximum.load(std::memory_order_acquire), 2);
+}