TaskGraph.h

Go to the documentation of this file.

 
#pragma once
 
#include "ExceptionContext.h"
 
#include "taskflow/taskflow.hpp"
#include "ncutility/NcError.h"
 
#include <vector>
 
namespace nc::task
{
struct TaskGraphContext : StableAddress
{
    tf::Taskflow graph;
    ExceptionContext exceptionContext;
    std::vector<std::unique_ptr<tf::Taskflow>> storage;
};
 
struct Task
{
    tf::Task task;
    size_t id;
    std::vector<size_t> predecessors;
    std::vector<size_t> successors;
};
 
template<class Phase>
class TaskGraph
{
    public:
        template<std::invocable<> F>
        auto Add(size_t id,
                 std::string_view name,
                 F&& func,
                 std::vector<size_t> predecessors = {},
                 std::vector<size_t> successors = {}) -> tf::Task
        {
            return Schedule(id, Emplace(name, std::forward<F>(func)), std::move(predecessors), std::move(successors));
        }
 
        auto Add(size_t id,
                 std::string_view name,
                 std::unique_ptr<tf::Taskflow> graph,
                 std::vector<size_t> predecessors = {},
                 std::vector<size_t> successors = {}) -> tf::Task
        {
            NC_ASSERT(graph != nullptr, "Task graph should not be null.");
            return Schedule(id, Emplace(name, std::move(graph)), std::move(predecessors), std::move(successors));
        }
 
        void StoreGraph(std::unique_ptr<tf::Taskflow> graph)
        {
            m_ctx->storage.push_back(std::move(graph));
        }
 
        auto GetExceptionContext() noexcept -> ExceptionContext&
        {
            return m_ctx->exceptionContext;
        }
 
    protected:
        std::unique_ptr<TaskGraphContext> m_ctx;
        std::vector<Task> m_tasks;
 
        TaskGraph()
            : m_ctx{std::make_unique<TaskGraphContext>()}
        {
        }
 
        ~TaskGraph() noexcept = default;
 
        auto Schedule(size_t id, tf::Task handle, std::vector<size_t> predecessors, std::vector<size_t> successors) -> tf::Task
        {
            return m_tasks.emplace_back(handle, id, std::move(predecessors), std::move(successors)).task;
        }
 
        template<std::invocable<> F>
        auto Emplace(std::string_view name, F&& func) -> tf::Task
        {
            return m_ctx->graph.emplace(Guard(m_ctx->exceptionContext, std::forward<F>(func))).name(name.data());
        }
 
        auto Emplace(std::string_view name, std::unique_ptr<tf::Taskflow> graph) -> tf::Task
        {
            auto handle = m_ctx->graph.composed_of(*graph).name(name.data());
            m_ctx->storage.emplace_back(std::move(graph));
            return handle;
        }
};
 
struct UpdatePhase;
 
struct RenderPhase;
 
using UpdateTasks = TaskGraph<UpdatePhase>;
 
using RenderTasks = TaskGraph<RenderPhase>;
} // namespace nc::task