execution_space.hpp

Go to the documentation of this file.

#ifndef KOKKOS_EXECUTION_EXECUTION_SPACE_HPP
#define KOKKOS_EXECUTION_EXECUTION_SPACE_HPP
 
#include "kokkos-execution/stdexec.hpp"
 
#include "Kokkos_Macros.hpp"
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#else
#    include "Kokkos_Core.hpp"
#endif
 
#include "kokkos-execution/execution_space/bulk.hpp"
#include "kokkos-execution/execution_space/continues_on.hpp"
#include "kokkos-execution/execution_space/domain.hpp"
#include "kokkos-execution/execution_space/env.hpp"
#include "kokkos-execution/execution_space/parallel_for.hpp"
#include "kokkos-execution/execution_space/parallel_reduce.hpp"
#include "kokkos-execution/execution_space/schedule_from.hpp"
#include "kokkos-execution/execution_space/scoped_region.hpp"
#include "kokkos-execution/execution_space/sync_wait.hpp"
#include "kokkos-execution/execution_space/then.hpp"
#include "kokkos-execution/execution_space/when_all.hpp"
#include "kokkos-execution/impl/state.hpp"
 
namespace Kokkos::Execution {
 
namespace ExecutionSpaceImpl {

template <Kokkos::ExecutionSpace Exec>
struct Scheduler {
    using scheduler_concept = stdexec::scheduler_t;
 
    using execution_space = Exec;
 
    template <stdexec::receiver Rcvr>
    struct OpState {
        using operation_state_concept = stdexec::operation_state_tag;
 
        Rcvr rcvr;

        void start() & noexcept {
            stdexec::set_value(std::move(rcvr));
        }
    };
 
    struct Sender {
        using sender_concept = stdexec::sender_tag;
 
        using completion_signatures = stdexec::completion_signatures<stdexec::set_value_t()>;

        struct Attributes {
            template <typename... Env>
            [[nodiscard]]
            constexpr auto
                query(stdexec::get_completion_scheduler_t<stdexec::set_value_t>, Env...) const noexcept -> Scheduler {
                return {state};
            }
 
            template <typename... Env>
            [[nodiscard]]
            constexpr auto
                query(stdexec::get_completion_domain_t<stdexec::set_value_t>, Env...) const noexcept -> Domain {
                return {};
            }
 
            Impl::State<Exec>* state;
        };
 
        template <stdexec::receiver_of<completion_signatures> Rcvr>
        [[nodiscard]]
        OpState<Rcvr> connect(Rcvr rcvr) && noexcept(std::is_nothrow_move_constructible_v<Rcvr>) {
            return {std::move(rcvr)};
        }
 
        template <stdexec::receiver_of<completion_signatures> Rcvr>
        [[nodiscard]]
        OpState<Rcvr> connect(Rcvr rcvr) const & noexcept(std::is_nothrow_move_constructible_v<Rcvr>) {
            return {std::move(rcvr)};
        }
 
        [[nodiscard]]
        constexpr auto get_env() const noexcept -> const Attributes& {
            return env;
        }
 
        Attributes env;
    };
 
    [[nodiscard]]
    constexpr auto schedule() const noexcept -> Sender {
        return {state};
    }
 
    [[nodiscard]]
    constexpr auto query(stdexec::get_completion_domain_t<stdexec::set_value_t>) const noexcept -> Domain {
        return {};
    }
 
    [[nodiscard]]
    constexpr auto query(stdexec::get_completion_scheduler_t<stdexec::set_value_t>) const noexcept -> Scheduler {
        return {state};
    }
 
    [[nodiscard]]
    friend bool operator==(const Scheduler&, const Scheduler&) noexcept = default;
 
    Impl::State<Exec>* state;
};
 
} // namespace ExecutionSpaceImpl

template <Kokkos::ExecutionSpace Exec>
struct ExecutionSpaceContext {
    using execution_space = Exec;
 
    using state_t = Impl::State<execution_space>;
 
    state_t m_state;
 
    explicit ExecutionSpaceContext(execution_space exec) // NOLINT(performance-unnecessary-value-param)
        : m_state{std::move(exec)} {
    }
 
    auto get_scheduler() const noexcept -> ExecutionSpaceImpl::Scheduler<execution_space> {
        return {const_cast<state_t*>(&m_state)};
    }
};
 
} // namespace Kokkos::Execution
 
#endif // KOKKOS_EXECUTION_EXECUTION_SPACE_HPP