plan_exec_slots.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <new>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "../assert.hpp"
#include "../context.hpp"
#include "../detail/slots/layout.hpp"
#include "policies.hpp"
#include "direct_out.hpp"
 
namespace yorch {
 
namespace detail {
 
template <typename Plan, std::size_t I, bool HasLogicalOutput =
    !std::is_void_v<typename Plan::template output_type<I>>>
struct canonical_output_owner_node_impl {
    static constexpr std::size_t value = Plan::no_parent;
};
 
template <typename Plan, std::size_t I>
struct canonical_output_owner_node_impl<Plan, I, true> {
private:
    static constexpr auto storage_mode = Plan::template output_storage_mode_for<I>;
 
public:
    static constexpr std::size_t value = [] {
        if constexpr (storage_mode == detail::output_storage_mode::forwarded_prev) {
            constexpr auto parent = Plan::template parent_index<I>;
            static_assert(parent != Plan::no_parent,
                          "forward-prev nodes are not allowed at the root");
            static_assert(!std::is_void_v<typename Plan::template output_type<parent>>,
                          "forward-prev nodes require a direct parent carrying a non-void payload");
            return canonical_output_owner_node_impl<Plan, parent>::value;
        } else {
            return I;
        }
    }();
};
 
template <typename Plan, std::size_t I>
inline constexpr std::size_t canonical_output_owner_node_v =
    canonical_output_owner_node_impl<Plan, I>::value;
 
template <typename Plan, typename LayoutPolicy>
    requires detail::slot_layout_policy<LayoutPolicy>
struct plan_exec_slots_impl {
    using layout_type = detail::plan_slot_layout<Plan, LayoutPolicy>;
    using tuple_type = detail::plan_erased_slots_tuple_t<layout_type>;
 
    plan_exec_slots_impl() = default;
    plan_exec_slots_impl(const plan_exec_slots_impl&) = delete;
    plan_exec_slots_impl& operator=(const plan_exec_slots_impl&) = delete;
    plan_exec_slots_impl(plan_exec_slots_impl&&) = delete;
    plan_exec_slots_impl& operator=(plan_exec_slots_impl&&) = delete;
    ~plan_exec_slots_impl() {
        destroy_active_slots();
    }
 
    template <std::size_t I>
    using output_type = typename Plan::template output_type<I>;
 
    template <std::size_t I>
    static constexpr detail::output_storage_mode output_storage_mode =
        Plan::template output_storage_mode_for<I>;
 
    template <std::size_t I>
    static constexpr std::size_t slot_index = Plan::template slot_index<I>;
 
    template <std::size_t I>
    static constexpr detail::slot_logical_policy slot_logical_policy =
        Plan::template slot_logical_policy_for<I>;
 
    static constexpr std::size_t physical_slot_count = layout_type::physical_slot_count;
 
    template <std::size_t I>
    static constexpr std::size_t physical_slot_index =
        layout_type::template physical_slot_index<I>;
 
    template <std::size_t K>
    static constexpr detail::slot_physical_policy slot_physical_policy =
        layout_type::template physical_slot_policy<K>;
 
    template <std::size_t I>
        requires std::is_void_v<output_type<I>>
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return false;
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>) &&
                 (slot_logical_policy<I> != detail::slot_logical_policy::must_payload)
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return slot_has_value_impl<I>();
    }
 
    template <std::size_t I, typename... Args>
        requires detail::payload_node<Plan, I>
    constexpr auto emplace(Args&&... args)
        noexcept(noexcept(slot_view_for<I>().emplace(std::forward<Args>(args)...)))
        -> output_type<I>& {
        auto slot = slot_view_for<I>();
        return slot.emplace(std::forward<Args>(args)...);
    }
 
    template <std::size_t I>
        requires detail::payload_node<Plan, I>
              && (slot_logical_policy<I> == detail::slot_logical_policy::maybe_payload)
    [[nodiscard]] constexpr auto out() & noexcept -> direct_out<output_type<I>> {
        return direct_out<output_type<I>> {slot_view_for<I>()};
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>)
    [[nodiscard]] constexpr auto get() & noexcept -> output_type<I>& {
        if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return get<detail::canonical_output_owner_node_v<Plan, I>>();
        } else {
            auto slot = slot_view_for<I>();
            return slot.get();
        }
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>)
    [[nodiscard]] constexpr auto get() const& noexcept -> const output_type<I>& {
        if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return get<detail::canonical_output_owner_node_v<Plan, I>>();
        } else {
            return *slot_ptr<I>();
        }
    }
 
    template <std::size_t I>
    constexpr void destroy() noexcept {
        if constexpr (!std::is_void_v<output_type<I>> &&
                      output_storage_mode<I> == detail::output_storage_mode::owned) {
            auto slot = slot_view_for<I>();
            slot.destroy();
        }
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto prev_view_for() & {
        if constexpr (std::is_void_v<output_type<I>>) {
            return no_prev {};
        } else {
            return prev_slot(get<I>());
        }
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto prev_view_for() const& {
        if constexpr (std::is_void_v<output_type<I>>) {
            return no_prev {};
        } else {
            return prev_slot(get<I>());
        }
    }
 
private:
    tuple_type storage {};
 
    template <std::size_t I>
    using physical_slot_type =
        std::tuple_element_t<physical_slot_index<I>, tuple_type>;
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto physical_slot() & noexcept -> physical_slot_type<I>& {
        return std::get<physical_slot_index<I>>(storage);
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto physical_slot() const& noexcept -> const physical_slot_type<I>& {
        return std::get<physical_slot_index<I>>(storage);
    }
 
    template <std::size_t I>
        requires detail::payload_node<Plan, I>
    [[nodiscard]] constexpr auto slot_view_for() & noexcept -> detail::slot_view<output_type<I>> {
        return detail::slot_view<output_type<I>> {physical_slot<I>(), I};
    }
 
    template <std::size_t I>
        requires detail::payload_node<Plan, I>
    [[nodiscard]] constexpr auto slot_ptr() const noexcept -> const output_type<I>* {
        if constexpr (slot_physical_policy<physical_slot_index<I>> == detail::slot_physical_policy::maybe_payload) {
            const auto& slot = physical_slot<I>();
            const auto* engaged = slot.engaged_ptr();
            YORCH_ASSERT(engaged != nullptr && *engaged &&
                         "yorch::plan_exec_slots<...>::get() called on an empty slot");
        }
 
        return std::launder(reinterpret_cast<const output_type<I>*>(physical_slot<I>().raw_storage()));
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr bool slot_has_value_impl() const noexcept {
        if constexpr (std::is_void_v<output_type<I>>) {
            return false;
        } else if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return slot_has_value_impl<detail::canonical_output_owner_node_v<Plan, I>>();
        } else if constexpr (slot_physical_policy<physical_slot_index<I>> == detail::slot_physical_policy::maybe_payload) {
            const auto& slot = physical_slot<I>();
            const auto* engaged = slot.engaged_ptr();
            return engaged != nullptr && *engaged;
        } else {
            return true;
        }
    }
 
    template <std::size_t I = 0>
    constexpr void destroy_active_slots() noexcept {
        if constexpr (I < Plan::node_count) {
            if constexpr (detail::payload_node<Plan, I>) {
                auto& slot = physical_slot<I>();
                auto* owner_node = slot.owner_node_ptr();
                if (owner_node != nullptr && *owner_node == I) {
                    auto view = slot_view_for<I>();
                    view.destroy();
                }
            }
 
            destroy_active_slots<I + 1>();
        }
    }
};
 
template <typename Plan>
struct plan_exec_slots_impl<Plan, slot_layout_one_to_one_policy> {
    using layout_type = detail::plan_slot_layout<Plan, slot_layout_one_to_one_policy>;
    using tuple_type = detail::plan_typed_slots_tuple_t<Plan>;
 
    plan_exec_slots_impl() = default;
    plan_exec_slots_impl(const plan_exec_slots_impl&) = delete;
    plan_exec_slots_impl& operator=(const plan_exec_slots_impl&) = delete;
    plan_exec_slots_impl(plan_exec_slots_impl&&) = delete;
    plan_exec_slots_impl& operator=(plan_exec_slots_impl&&) = delete;
    ~plan_exec_slots_impl() {
        destroy_active_slots();
    }
 
    template <std::size_t I>
    using output_type = typename Plan::template output_type<I>;
 
    template <std::size_t I>
    static constexpr detail::output_storage_mode output_storage_mode =
        Plan::template output_storage_mode_for<I>;
 
    template <std::size_t I>
    static constexpr std::size_t slot_index = Plan::template slot_index<I>;
 
    template <std::size_t I>
    static constexpr detail::slot_logical_policy slot_logical_policy =
        Plan::template slot_logical_policy_for<I>;
 
    static constexpr std::size_t physical_slot_count = layout_type::physical_slot_count;
 
    template <std::size_t I>
    static constexpr std::size_t physical_slot_index =
        layout_type::template physical_slot_index<I>;
 
    template <std::size_t K>
    static constexpr detail::slot_physical_policy slot_physical_policy =
        layout_type::template physical_slot_policy<K>;
 
    template <std::size_t I>
        requires std::is_void_v<output_type<I>>
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return false;
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>) &&
                 (slot_logical_policy<I> != detail::slot_logical_policy::must_payload)
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return slot_has_value_impl<I>();
    }
 
    template <std::size_t I, typename... Args>
        requires detail::payload_node<Plan, I>
    constexpr auto emplace(Args&&... args)
        noexcept(noexcept(logical_slot<I>().emplace(std::forward<Args>(args)...)))
        -> output_type<I>& {
        auto& value = logical_slot<I>().emplace(std::forward<Args>(args)...);
        live_slots_[I] = true;
        return value;
    }
 
    template <std::size_t I>
        requires detail::payload_node<Plan, I>
              && (slot_logical_policy<I> == detail::slot_logical_policy::maybe_payload)
    [[nodiscard]] constexpr auto out() & noexcept -> direct_out<output_type<I>> {
        return direct_out<output_type<I>> {logical_slot<I>()};
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>)
    [[nodiscard]] constexpr auto get() & noexcept -> output_type<I>& {
        if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return get<detail::canonical_output_owner_node_v<Plan, I>>();
        } else {
            return logical_slot<I>().get();
        }
    }
 
    template <std::size_t I>
        requires (!std::is_void_v<output_type<I>>)
    [[nodiscard]] constexpr auto get() const& noexcept -> const output_type<I>& {
        if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return get<detail::canonical_output_owner_node_v<Plan, I>>();
        } else {
            return logical_slot<I>().get();
        }
    }
 
    template <std::size_t I>
    constexpr void destroy() noexcept {
        if constexpr (!std::is_void_v<output_type<I>> &&
                      output_storage_mode<I> == detail::output_storage_mode::owned) {
            if constexpr (slot_logical_policy<I> == detail::slot_logical_policy::maybe_payload) {
                if (logical_slot<I>().has_value()) {
                    logical_slot<I>().destroy();
                }
            } else {
                if (live_slots_[I]) {
                    logical_slot<I>().destroy();
                }
            }
 
            live_slots_[I] = false;
        }
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto prev_view_for() & {
        if constexpr (std::is_void_v<output_type<I>>) {
            return no_prev {};
        } else {
            return prev_slot(get<I>());
        }
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto prev_view_for() const& {
        if constexpr (std::is_void_v<output_type<I>>) {
            return no_prev {};
        } else {
            return prev_slot(get<I>());
        }
    }
 
private:
    tuple_type storage {};
 
    template <std::size_t I>
    using logical_slot_type =
        std::tuple_element_t<physical_slot_index<I>, tuple_type>;
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto logical_slot() & noexcept -> logical_slot_type<I>& {
        return std::get<physical_slot_index<I>>(storage);
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr auto logical_slot() const& noexcept -> const logical_slot_type<I>& {
        return std::get<physical_slot_index<I>>(storage);
    }
 
    template <std::size_t I>
    [[nodiscard]] constexpr bool slot_has_value_impl() const noexcept {
        if constexpr (std::is_void_v<output_type<I>>) {
            return false;
        } else if constexpr (detail::canonical_output_owner_node_v<Plan, I> != I) {
            return slot_has_value_impl<detail::canonical_output_owner_node_v<Plan, I>>();
        } else if constexpr (slot_logical_policy<I> == detail::slot_logical_policy::maybe_payload) {
            return logical_slot<I>().has_value();
        } else {
            return true;
        }
    }
 
    template <std::size_t I = 0>
    constexpr void destroy_active_slots() noexcept {
        if constexpr (I < Plan::node_count) {
            destroy<I>();
            destroy_active_slots<I + 1>();
        }
    }
 
    std::array<bool, Plan::node_count> live_slots_ {};
};
 
} // namespace detail
 
template <typename Plan, typename LayoutPolicy = slot_layout_one_to_one_policy>
    requires detail::slot_layout_policy<LayoutPolicy>
struct plan_exec_slots : detail::plan_exec_slots_impl<Plan, LayoutPolicy> {};
 
template <typename Plan, typename LayoutPolicy = slot_layout_one_to_one_policy>
using plan_slots = plan_exec_slots<Plan, LayoutPolicy>;
 
} // namespace yorch