exkit.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <deque>
 
#include <memory>
#include <unordered_map>
 
#include "exkit/scheduler.hpp"
#include "exkit/task.hpp"
 
class Exkit {
public:
    Exkit(IScheduler &scheduler);
 
    void run();
 
    template <typename DependentType, typename... DependencyTypes>
    void add_dependency(TaskHandle<DependentType>& dependent, TaskHandle<DependencyTypes>&... dependencies);
 
    template <typename FunctionType>
    auto task(FunctionType&& function);
 
    template <typename FunctionType, typename... ResultTypes>
    auto task(FunctionType&& function, TaskHandle<ResultTypes>&... dependencies);
 
private:
    void _execute_task(ITask* task, std::unordered_map<ITask*, std::atomic<int>>& remaining);
 
    void _register_dependency(ITask* dependent, ITask* dependency);
 
private:
    std::deque<std::unique_ptr<ITask>> _tasks;
    std::atomic<bool> _is_running;
    IScheduler& _scheduler;
};
 
// ------------------------- Implementation of template methods -------------------------
 
template <typename DependentType, typename... DependencyTypes>
void Exkit::add_dependency(TaskHandle<DependentType>& dependent, TaskHandle<DependencyTypes>&... dependencies) {
    if (_is_running.load()) {
        throw std::runtime_error("Cannot add dependencies while Exkit is running.");
    }
 
    (_register_dependency(dependent._task, dependencies._task), ...);
}
 
template <typename FunctionType>
auto Exkit::task(FunctionType&& function) {
    if (_is_running.load()) {
        throw std::runtime_error("Cannot add tasks while Exkit is running.");
    }
 
    using ResultType = std::invoke_result_t<FunctionType>;
 
    auto task = std::make_unique<Task<ResultType>>(std::forward<FunctionType>(function));
    auto handle = TaskHandle<ResultType>(task.get());
 
    _tasks.push_back(std::move(task));
    return handle;
}
 
template <typename FunctionType, typename... ResultTypes>
auto Exkit::task(FunctionType&& function, TaskHandle<ResultTypes>&... dependencies) {
    if (_is_running.load()) {
        throw std::runtime_error("Cannot add tasks while Exkit is running.");
    }
 
    using Args = decltype(dependency_values(std::declval<TaskHandle<ResultTypes>&>()...));
    using ResultType = decltype(std::apply(std::declval<FunctionType>(), std::declval<Args>()));
 
    auto wrapper = [function = std::forward<FunctionType>(function), dependencies...]() {
        return std::apply(function, dependency_values(dependencies...));
    };
 
    auto task = std::make_unique<Task<ResultType>>(std::move(wrapper));
    (_register_dependency(task.get(), dependencies._task), ...);
 
    auto handle = TaskHandle<ResultType>(task.get());
    _tasks.push_back(std::move(task));
 
    return handle;
}