test_events.cpp

Go to the documentation of this file.

#include "gmock/gmock.h"
#include "gtest/gtest.h"
 
#include "kokkos-utils/callbacks/RecorderListener.hpp"
#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
 
#include "kokkos-execution/graph.hpp"
 
#include "tests/graph/events.hpp"
#include "tests/utils/graph_context.hpp"

 
#if !defined(KOKKOS_EXECUTION_ENABLE_EVENT_DISPATCH)
#    error "This is not supported."
#endif
 
namespace Tests::GraphImpl {
 
using namespace Kokkos::utils::callbacks;
 
class EventsTest
    : public Tests::Utils::GraphContextTest<TEST_EXECUTION_SPACE>
    , public Kokkos::utils::tests::scoped::callbacks::Manager {
   public:
    using recorder_listener_t = RecorderListener<
        GraphEventDiscardMatcher<TEST_EXECUTION_SPACE>,
        BeginFenceEvent,
        Kokkos::Execution::GraphImpl::GraphAddNodeEvent,
        Kokkos::Execution::GraphImpl::GraphCreateEvent,
        Kokkos::Execution::GraphImpl::GraphInstantiateEvent,
        Kokkos::Execution::GraphImpl::GraphSubmitEvent
    >;
};

consteval bool test_noexcept() {
    static_assert(
        noexcept(Kokkos::Execution::GraphImpl::get_graph_impl_ptr(std::declval<const EventsTest::graph_t::root_t&>())));
    static_assert(
        noexcept(Kokkos::Execution::GraphImpl::get_node_ptr(std::declval<const EventsTest::graph_t::root_t&>())));
 
    static_assert(
        !noexcept(Kokkos::Execution::GraphImpl::graph_create_event(std::declval<const EventsTest::graph_t&>())));
    static_assert(
        !noexcept(Kokkos::Execution::GraphImpl::create_graph(std::declval<const EventsTest::device_handle_t&>())));
 
    static_assert(!noexcept(Kokkos::Execution::GraphImpl::graph_add_node_event(
        std::declval<std::string>(),
        std::declval<const EventsTest::graph_t::root_t&>(),
        std::declval<const EventsTest::graph_t::root_t&>())));
 
    static_assert(
        !noexcept(Kokkos::Execution::GraphImpl::graph_instantiate_event(std::declval<const EventsTest::graph_t&>())));
 
    static_assert(!noexcept(Kokkos::Execution::GraphImpl::graph_submit_event(
        std::declval<const EventsTest::graph_t&>(), std::declval<const TEST_EXECUTION_SPACE&>())));
 
    static_assert(!noexcept(Kokkos::Execution::GraphImpl::submit_graph(
        std::declval<const EventsTest::graph_t&>(), std::declval<const TEST_EXECUTION_SPACE&>())));
 
    return true;
}
 
static_assert(test_noexcept());

TEST_F(EventsTest, create_instantiate_and_submit) {
    const auto recorded_events = recorder_listener_t::record([this]() {
        graph_t graph = Kokkos::Execution::GraphImpl::create_graph(device_handle);
 
        graph.instantiate();
        Kokkos::Execution::GraphImpl::graph_instantiate_event(graph);
 
        Kokkos::Execution::GraphImpl::submit_graph(graph, exec);
    });
    ASSERT_THAT(
        recorded_events.at(0),
        AGraphCreateEvent(
            testing::Field(&Kokkos::Execution::GraphImpl::GraphCreateEvent::root_node, testing::NotNull())));
 
    ASSERT_THAT(
        recorded_events,
        testing::ElementsAre(
            MATCHER_FOR_GRAPH_CREATE(device_handle),
            MATCHER_FOR_GRAPH_INSTANTIATE(recorded_events.at(0)),
            MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0))));
}

TEST_F(EventsTest, create_and_add_nodes) {
    const auto recorded_events = recorder_listener_t::record([this]() {
        const graph_t graph{device_handle};
        Kokkos::Execution::GraphImpl::graph_create_event(graph);
 
        const auto root = graph.root_node();
 
        const auto node_A = root.then(Kokkos::Experimental::node_props(device_handle), KOKKOS_LAMBDA(){});
        Kokkos::Execution::GraphImpl::graph_add_node_event("my label", root, node_A);
 
        const auto node_B = node_A.then(Kokkos::Experimental::node_props(device_handle), KOKKOS_LAMBDA(){});
        Kokkos::Execution::GraphImpl::graph_add_node_event("my label", node_A, node_B);
    });
    ASSERT_THAT(
        recorded_events,
        testing::ElementsAre(
            MATCHER_FOR_GRAPH_CREATE(device_handle),
            MATCHER_FOR_GRAPH_ADDNODE(
                recorded_events.at(0),
                device_handle,
                MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0)),
                "my label"),
            MATCHER_FOR_GRAPH_ADDNODE(
                recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_NODE_OF(recorded_events.at(1)), "my label")));
}

TEST(GraphCreateEvent, streaming_operator) {
    const Kokkos::Execution::GraphImpl::GraphCreateEvent event{
        .graph = reinterpret_cast<void*>(0x7f3a2b4c8000),
        .root_node = reinterpret_cast<void*>(0x7f6d9e1a5000),
        .dev_id = 8,
        .event_id = 666};
 
    std::ostringstream oss;
    oss << event;
 
    ASSERT_EQ(
        oss.str(),
        "GraphCreateEvent: {graph = 0x7f3a2b4c8000, root_node = 0x7f6d9e1a5000, dev_id = 8, event_id = 666}");
}

TEST(GraphAddAggregateNodeEvent, streaming_operator) {
    const Kokkos::Execution::GraphImpl::GraphAddAggregateNodeEvent event{
        .graph = reinterpret_cast<void*>(0x7f3a2b4c8000),
        .predecessors = {reinterpret_cast<void*>(0x7f6d9e1a5000), reinterpret_cast<void*>(0x7f6d9e1a5500)},
        .node = reinterpret_cast<void*>(0x7f7d9e1a5000)
    };
 
    std::ostringstream oss;
    oss << event;
 
    ASSERT_EQ(
        oss.str(),
        "GraphAddAggregateNodeEvent: {graph = 0x7f3a2b4c8000, predecessors = [0x7f6d9e1a5000, 0x7f6d9e1a5500], node = "
        "0x7f7d9e1a5000}");
}
 
} // namespace Tests::GraphImpl