event.hpp

Go to the documentation of this file.

#ifndef KOKKOS_EXECUTION_IMPL_HPX_EVENT_HPP
#define KOKKOS_EXECUTION_IMPL_HPX_EVENT_HPP
 
#include "Kokkos_Macros.hpp"
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#    include "Kokkos_Assert.hpp"
#else
#    include "Kokkos_Core.hpp"
#endif

 
#if !defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
#    error "This is not supported."
#endif
 
namespace Kokkos::Execution::Impl {
 
template <>
struct HasNonBlockingDispatch<Kokkos::Experimental::HPX> : std::true_type { };

template <>
struct Event<Kokkos::Experimental::HPX> {
    using sndr_t = hpx::execution::experimental::unique_any_sender<>;
 
    mutable std::optional<sndr_t> m_sender;
    uint64_t m_event_id = invalid_event_id;
 
    Event() = default;
    Event(const Event&) = delete;
    Event& operator=(const Event&) = delete;
    Event(Event&&) noexcept = delete;
    Event& operator=(Event&&) noexcept = delete;
    ~Event() = default;

    void record(const Kokkos::Experimental::HPX& exec) {
        KOKKOS_EXPECTS(!m_sender.has_value());
 
        auto& instance_data = exec.impl_get_instance_data();
 
        const std::scoped_lock<hpx::spinlock> lock(instance_data.m_sender_mutex);
 
        m_sender = std::move(instance_data.m_sender);
 
        instance_data.m_sender = sndr_t(hpx::execution::experimental::just());
    }

    void wait() const {
        if (m_sender.has_value()) {
            hpx::this_thread::experimental::sync_wait(std::move(*m_sender));
            m_sender = std::nullopt;
        }
    }
};
 
template <Kokkos::ExecutionSpace... Exec>
requires(std::same_as<Exec, Kokkos::Experimental::HPX> && ...)
void impl_wait(const Event<Kokkos::Experimental::HPX>& event, const Event<Exec>&... events) {
    KOKKOS_EXPECTS(event.m_sender.has_value() && (events.m_sender.has_value() && ...));
 
    hpx::this_thread::experimental::sync_wait(
        hpx::execution::experimental::when_all(std::move(*event.m_sender), std::move(*events.m_sender)...));

    event.m_sender = std::nullopt;
    ((events.m_sender = std::nullopt), ...);
}
 
template <Kokkos::ExecutionSpace... ExecFrom>
requires(std::same_as<ExecFrom, Kokkos::Experimental::HPX> && ...)
void impl_wait(const Kokkos::Experimental::HPX& exec, const Event<ExecFrom>&... events) {
    KOKKOS_EXPECTS((events.m_sender.has_value() && ...));
 
    auto& instance_data = exec.impl_get_instance_data();
 
    const std::scoped_lock<hpx::spinlock> lock(instance_data.m_sender_mutex);
 
    auto& sndr = instance_data.m_sender;
    sndr = hpx::execution::experimental::when_all(std::move(sndr), std::move(*events.m_sender)...);

    ((events.m_sender = std::nullopt), ...);
}
 
} // namespace Kokkos::Execution::Impl
 
#endif // KOKKOS_EXECUTION_IMPL_HPX_EVENT_HPP