task.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <atomic>
#include <functional>
 
namespace co_ecs {
 
class task_t {
public:
    task_t() = default;
 
    task_t(auto&& func, task_t* parent = nullptr) : _func(std::forward<decltype(func)>(func)), _parent(parent) {
        _unfinishedTasks.store(1, std::memory_order::relaxed);
        if (_parent) {
            _parent->_unfinishedTasks.fetch_add(1, std::memory_order::relaxed);
        }
    }
 
    void execute() {
        _func();
        finish();
    }
 
    bool is_completed() const noexcept {
        return _unfinishedTasks.load(std::memory_order::relaxed) == 0;
    }
 
    task_t* parent() const noexcept {
        return _parent;
    }
 
private:
    void finish() {
        _unfinishedTasks.fetch_sub(1, std::memory_order::relaxed);
 
        if (is_completed() && _parent) {
            _parent->finish();
        }
    }
 
    std::function<void()> _func{};          
    task_t* _parent{};                      
    std::atomic<uint16_t> _unfinishedTasks; 
};
 
class task_pool {
public:
    constexpr static std::size_t max_tasks = 4096;
 
    static task_t* allocate(auto&& func, task_t* parent = nullptr) {
        auto& task = _tasks_array[_task_counter++ & (max_tasks - 1)];
        task.~task_t();
        new (&task) task_t(std::forward<decltype(func)>(func), parent);
        return &task;
    }
 
private:
    static inline thread_local std::size_t _task_counter;                  
    static inline thread_local std::array<task_t, max_tasks> _tasks_array; 
};
 
} // namespace co_ecs