test_event.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include "kokkos-utils/callbacks/RecorderListener.hpp"
#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
 
#include "kokkos-execution/impl/event.hpp"
 
#include "tests/utils/callback_matchers.hpp"
#include "tests/utils/execution_space_context.hpp"
#include "tests/utils/functors/no_op.hpp"

 
#if !defined(KOKKOS_EXECUTION_ENABLE_EVENT_DISPATCH)
#    error "This is not supported."
#endif
 
namespace Tests::Impl {
 
using namespace Kokkos::utils::callbacks;

class EventTestNoCallback : public Tests::Utils::ExecutionSpaceContextTest<TEST_EXECUTION_SPACE> {
   public:
    template <Kokkos::ExecutionSpace Exec>
    static constexpr bool has_support = []() {
#if defined(KOKKOS_ENABLE_CUDA)
        if constexpr (std::same_as<Exec, Kokkos::Cuda>)
            return true;
#endif
#if defined(KOKKOS_ENABLE_HIP)
        if constexpr (std::same_as<Exec, Kokkos::HIP>)
            return true;
#endif
#if defined(KOKKOS_ENABLE_HPX)
        if constexpr (std::same_as<Exec, Kokkos::Experimental::HPX>)
            return true;
#endif
#if defined(KOKKOS_ENABLE_SYCL)
        if constexpr (std::same_as<Exec, Kokkos::SYCL>)
            return true;
#endif
        return false;
    }();
};

class EventTest
    : public EventTestNoCallback
    , public Kokkos::utils::tests::scoped::callbacks::Manager {
   public:
    using recorder_listener_t = RecorderListener<
        EventDiscardMatcher<TEST_EXECUTION_SPACE>,
        Kokkos::Execution::Impl::RecordEvent,
        Kokkos::Execution::Impl::WaitEvent
    >;
};

template <Kokkos::ExecutionSpace Exec>
consteval bool test_models_event() {
    if constexpr (EventTest::has_support<Exec>) {
        return Kokkos::Execution::Impl::event<Kokkos::Execution::Impl::Event<Exec>, Exec>;
    }
    return true;
}
static_assert(test_models_event<TEST_EXECUTION_SPACE>());

template <Kokkos::ExecutionSpace Exec>
consteval bool test_support_events() {
    return Kokkos::Execution::Impl::support_events<Exec> == EventTest::has_support<Exec>;
}
static_assert(test_support_events<TEST_EXECUTION_SPACE>());
 
#define KOKKOS_EXECUTION_TESTS_IMPL_EVENT(_fixture_, _name_, _statement_)                                              \
    TEST_F(_fixture_, _name_) {                                                                                        \
        if constexpr (EventTest::has_support<TEST_EXECUTION_SPACE>) {                                                  \
            test_event_##_name_ _statement_;                                                                           \
        } else {                                                                                                       \
            GTEST_SKIP() << Kokkos::Impl::TypeInfo<TEST_EXECUTION_SPACE>::name() << " does not support events.";       \
        }                                                                                                              \
    }

template <Kokkos::ExecutionSpace Exec>
void test_event_record_and_wait(const Exec& exec) {
    const auto recorded_events = EventTest::recorder_listener_t::record([&exec]() {
        Kokkos::Execution::Impl::Event<Exec> event;
        event.record(exec);
        event.wait();
    });
 
    ASSERT_EQ(recorded_events.size(), 2);
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(exec));
    ASSERT_THAT(recorded_events.at(1), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, record_and_wait, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_record_but_dont_wait(const Exec& exec) {
    const auto recorded_events = EventTest::recorder_listener_t::record([&exec]() {
        Kokkos::Execution::Impl::Event<Exec> event;
        Kokkos::parallel_for(Kokkos::RangePolicy(exec, 0, 1), Tests::Utils::Functors::NoOp{});
        event.record(exec);
 
        exec.fence();
    });
 
    ASSERT_EQ(recorded_events.size(), 1);
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(exec));
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, record_but_dont_wait, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_record_and_wait_many_times(const Exec& exec) {
    const auto recorded_events = EventTest::recorder_listener_t::record([&exec]() {
        Kokkos::Execution::Impl::Event<Exec> event;
        event.record(exec);
        event.wait();
        event.wait();
        event.wait();
        event.wait();
        event.wait();
    });
 
    ASSERT_THAT(recorded_events, ::testing::SizeIs(6));
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(exec));
    ASSERT_THAT(recorded_events.at(1), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
    ASSERT_THAT(recorded_events.at(2), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
    ASSERT_THAT(recorded_events.at(3), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
    ASSERT_THAT(recorded_events.at(4), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
    ASSERT_THAT(recorded_events.at(5), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, record_and_wait_many_times, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_record_and_wait_and_record_and_wait(const Exec& exec) {
    const auto recorded_events = EventTest::recorder_listener_t::record([&exec]() {
        Kokkos::Execution::Impl::Event<Exec> event;
        event.record(exec);
        event.wait();
        event.record(exec);
        event.wait();
    });
 
    ASSERT_THAT(recorded_events, ::testing::SizeIs(4));
 
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(exec));
    ASSERT_THAT(recorded_events.at(1), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
 
    ASSERT_THAT(recorded_events.at(2), MATCHER_FOR_RECORD_EVENT(exec));
    ASSERT_THAT(recorded_events.at(3), MATCHER_FOR_WAIT_EVENT(recorded_events.at(2)));
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, record_and_wait_and_record_and_wait, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_record_and_wait_no_check(const Exec& exec) {
    ASSERT_THAT(Kokkos::utils::callbacks::Manager::is_initialized(), ::testing::IsFalse());
 
    Kokkos::Execution::Impl::Event<Exec> event;
    event.record(exec);
    event.wait();
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTestNoCallback, record_and_wait_no_check, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_uniqueness(const Exec& exec) {
    const auto recorded_events = EventTest::recorder_listener_t::record([&exec]() {
        Kokkos::Execution::Impl::Event<Exec> event_before, event_after;
        event_before.record(exec);
        Kokkos::parallel_for(Kokkos::RangePolicy(exec, 0, 1), Tests::Utils::Functors::NoOp{});
        event_after.record(exec);
 
        exec.fence();
    });
 
    ASSERT_THAT(recorded_events, ::testing::SizeIs(2));
 
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(exec));
    ASSERT_THAT(recorded_events.at(1), MATCHER_FOR_RECORD_EVENT(exec));
 
    ASSERT_NE(
        std::get<Kokkos::Execution::Impl::RecordEvent>(recorded_events.at(0)).event_id,
        std::get<Kokkos::Execution::Impl::RecordEvent>(recorded_events.at(1)).event_id);
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, uniqueness, (exec))
 

template <Kokkos::ExecutionSpace Exec>
void test_event_default_instance() {
    using recorder_listener_with_fence_t = RecorderListener<
        EventDiscardMatcher<TEST_EXECUTION_SPACE>,
        Kokkos::Execution::Impl::RecordEvent,
        Kokkos::Execution::Impl::WaitEvent,
        Kokkos::utils::callbacks::BeginFenceEvent
    >;
 
    static_assert(Kokkos::Execution::Impl::support_events<Exec>);
 
    const Exec default_exec{};
 
    const auto recorded_events = recorder_listener_with_fence_t::record([&default_exec]() {
        Kokkos::parallel_for(Kokkos::RangePolicy(default_exec, 0, 1), Tests::Utils::Functors::NoOp{});
        const Kokkos::Execution::Impl::Event<Exec> event{default_exec};
        event.wait();
    });
 
    ASSERT_THAT(recorded_events, ::testing::SizeIs(2));
    ASSERT_THAT(recorded_events.at(0), MATCHER_FOR_RECORD_EVENT(default_exec));
    ASSERT_THAT(recorded_events.at(1), MATCHER_FOR_WAIT_EVENT(recorded_events.at(0)));
}
 
KOKKOS_EXECUTION_TESTS_IMPL_EVENT(EventTest, default_instance, <TEST_EXECUTION_SPACE>())
 
} // namespace Tests::Impl