stage.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/system/system.hpp>
 
namespace co_ecs {
 
using vector_of_executors_t = std::vector<std::unique_ptr<system_executor_interface>>;
 
class stage_executor;
class schedule;
 
struct main_thread_execution_policty_t {
    explicit main_thread_execution_policty_t() = default;
};
 
inline constexpr main_thread_execution_policty_t main_thread_execution_policy{};
 
class stage {
private:
    using self_type = stage; 
 
public:
    stage(schedule& schedule, std::string_view name = {}) : _schedule(schedule), _name(name) {
    }
 
    auto end_stage() noexcept -> schedule& {
        return _schedule;
    }
 
    auto add_system(main_thread_execution_policty_t policy, auto&&... args) -> self_type& {
        _main_thread_systems.emplace_back(into_system_interface(std::forward<decltype(args)>(args)...));
        return *this;
    }
 
    auto add_system(auto&&... args) -> self_type& {
        _systems.emplace_back(into_system_interface(std::forward<decltype(args)>(args)...));
        return *this;
    }
 
    auto create_executor(registry& registry, void* user_context = nullptr) -> std::unique_ptr<stage_executor> {
        std::vector<vector_of_executors_t> executors{};
 
        while (!_systems.empty()) {
            access_pattern_t access_pattern;
            vector_of_executors_t& executor_set = executors.emplace_back();
 
            for (size_t i = 0; i < _systems.size();) {
                auto executor = _systems[i]->create_executor(registry, user_context);
                auto system_access_pattern = executor->access_pattern();
 
                if (!access_pattern.allows(system_access_pattern)) {
                    ++i;
                    continue;
                }
 
                access_pattern &= system_access_pattern;
                executor_set.emplace_back(std::move(executor));
                _systems.erase(_systems.begin() + i);
            }
        }
 
        // Main thread systems
        vector_of_executors_t main_thread_executors;
        for (auto& system : _main_thread_systems) {
            main_thread_executors.emplace_back(system->create_executor(registry, user_context));
        }
 
        return std::make_unique<stage_executor>(_name, std::move(executors), std::move(main_thread_executors));
    }
 
private:
    template<typename F>
    static auto into_system_interface(F&& func) -> std::unique_ptr<system_interface> {
        return std::make_unique<system<F>>(std::forward<F>(func));
    }
 
    template<typename S>
    static auto into_system_interface(std::unique_ptr<S> system) -> std::unique_ptr<system_interface> {
        return system;
    }
 
private:
    schedule& _schedule;
    std::string_view _name;
    std::vector<std::unique_ptr<system_interface>> _systems{};
    std::vector<std::unique_ptr<system_interface>> _main_thread_systems{};
};
 
class stage_executor {
public:
    using builder = stage; 
 
    explicit stage_executor(std::string_view name,
        std::vector<vector_of_executors_t> executor_set,
        vector_of_executors_t main_thread_executors) :
        _executor_set(std::move(executor_set)), _main_thread_executors(std::move(main_thread_executors)), _name(name) {
    }
 
    void run() {
        for (auto& executors : _executor_set) {
            execute_batch(executors);
        }
    }
 
private:
    template<typename WorkBatch>
    void execute_batch(WorkBatch&& work_batch) {
        task_t* parent{};
        thread_pool& _thread_pool = thread_pool::get();
 
        for (auto& work_item : work_batch) {
            auto task = _thread_pool.submit([&work_item]() { work_item->run(); }, parent);
            if (!parent) {
                parent = task;
            }
        }
 
        // in the meantime execute main thread systems
        for (auto& executor : _main_thread_executors) {
            executor->run();
        }
 
        if (parent) {
            _thread_pool.wait(parent);
        }
    }
 
private:
    std::vector<vector_of_executors_t> _executor_set;
    vector_of_executors_t _main_thread_executors;
    std::string_view _name;
};
 
 
} // namespace co_ecs