test_Manager.cpp

Go to the documentation of this file.

#include "gmock/gmock.h"
#include "gtest/gtest.h"
 
#include "Kokkos_Core.hpp"
 
#include "kokkos-utils/callbacks/Helpers.hpp"
#include "kokkos-utils/impl/type_traits.hpp"
#include "kokkos-utils/tests/scoped/ExecutionSpace.hpp"
#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
 
#include "tests/callbacks/TestWorkload.hpp"

 
using execution_space = Kokkos::DefaultExecutionSpace;
 
namespace Kokkos::utils::tests::callbacks
{
 
using namespace Kokkos::utils::callbacks;

constexpr bool test_singleton_traits()
{
    static_assert( ! std::is_copy_constructible_v<Manager>);
    static_assert( ! std::is_copy_assignable_v   <Manager>);
 
    static_assert( ! std::is_move_constructible_v<Manager>);
    static_assert( ! std::is_move_assignable_v   <Manager>);
 
    return true;
}
static_assert(test_singleton_traits());

TEST(Manager, initialize_finalize)
{
    ASSERT_FALSE(Manager::is_initialized());
 
    Manager::initialize();
    ASSERT_TRUE(Manager::is_initialized());
 
    const auto* ptr = std::addressof(Manager::get_instance());
 
    Manager::initialize();
    ASSERT_TRUE(Manager::is_initialized());
 
    ASSERT_EQ(ptr, std::addressof(Manager::get_instance()));
 
    Manager::initialize();
    ASSERT_TRUE(Manager::is_initialized());
 
    ASSERT_EQ(ptr, std::addressof(Manager::get_instance()));
 
    Manager::finalize();
    ASSERT_FALSE(Manager::is_initialized());
 
    Manager::finalize();
    ASSERT_FALSE(Manager::is_initialized());
 
    Manager::finalize();
    ASSERT_FALSE(Manager::is_initialized());
}

TEST(Manager, dispatch) {
    ASSERT_FALSE(Manager::is_initialized());
 
    dispatch(ProfileEvent{});
}

TEST(Manager, get_next_event_id) {
    ASSERT_FALSE(Manager::is_initialized());
 
    ASSERT_EQ(get_next_event_id(), EventTraits::invalid_event_id);
 
    Manager::initialize();
 
    ASSERT_TRUE(Manager::is_initialized());
 
    ASSERT_NE(get_next_event_id(), EventTraits::invalid_event_id);
 
    Manager::finalize();
}
 
class ManagerTest : public ::testing::Test,
                    public scoped::callbacks::Manager,
                    public scoped::ExecutionSpace<execution_space>
{};

template <Event... EventTypes>
struct TesterListener
{
    template <Kokkos::utils::impl::IsTypeOneOf<EventTypes...> EventType>
    void operator()(const EventType& event) {
        std::get<std::vector<EventType>>(events).push_back(event);
    }
 
    std::tuple<std::vector<EventTypes>...> events {};
};

TEST_F(ManagerTest, dispatch_to_call_operators_of_single_listener)
{
    const auto tester_listener = std::make_shared<TesterListener<BeginParallelForEvent, EndParallelForEvent, BeginFenceEvent>>();
 
    Kokkos::utils::callbacks::Manager::register_listener(tester_listener);
 
    MyWorkload<execution_space>{}.execute(exec);
 
    Kokkos::utils::callbacks::Manager::unregister_listener(tester_listener.get());
 
    const auto& [begin_parallel_for_events, end_parallel_for_events, begin_fence_events] = tester_listener->events;

    ASSERT_EQ(begin_parallel_for_events.size(), 1);
    ASSERT_EQ(begin_parallel_for_events[0].name, "computation - level 0 - pfor");

    ASSERT_EQ(end_parallel_for_events.size(), 1);
    ASSERT_EQ(begin_parallel_for_events[0].event_id, end_parallel_for_events[0].event_id);

    ASSERT_GT(begin_fence_events.size(), 2);
    ASSERT_THAT(
        begin_fence_events,
        ::testing::Contains(::testing::Field(&BeginFenceEvent::name, ::testing::StrEq("computation - level 0 - fence after pfor")))
    );
    ASSERT_THAT(
        begin_fence_events,
        ::testing::Contains(::testing::Field(&BeginFenceEvent::name, ::testing::StrEq("other fence after stopping the profile section")))
    );
}

TEST_F(ManagerTest, dispatch_to_call_operators_of_multiple_listeners)
{
    const auto tester_listener_a = std::make_shared<TesterListener<BeginParallelForEvent>>();
    const auto tester_listener_b = std::make_shared<TesterListener<BeginParallelForEvent, EndParallelForEvent>>();
 
    Kokkos::utils::callbacks::Manager::register_listener(tester_listener_a);
    Kokkos::utils::callbacks::Manager::register_listener(tester_listener_b);
 
    MyWorkload<execution_space>{}.execute(exec);
 
    Kokkos::utils::callbacks::Manager::unregister_listener(tester_listener_a.get());
    Kokkos::utils::callbacks::Manager::unregister_listener(tester_listener_b.get());
 
    const auto& [begin_parallel_for_events_listener_a]                                     = tester_listener_a->events;
    const auto& [begin_parallel_for_events_listener_b, end_parallel_for_events_listener_b] = tester_listener_b->events;

    ASSERT_EQ(begin_parallel_for_events_listener_a.size(), 1);
    ASSERT_EQ(begin_parallel_for_events_listener_a[0].name, "computation - level 0 - pfor");
    ASSERT_EQ(begin_parallel_for_events_listener_b.size(), 1);
    ASSERT_EQ(begin_parallel_for_events_listener_b[0].name, "computation - level 0 - pfor");

    ASSERT_EQ(end_parallel_for_events_listener_b.size(), 1);
    ASSERT_EQ(begin_parallel_for_events_listener_b[0].event_id, end_parallel_for_events_listener_b[0].event_id);
}

TEST_F(ManagerTest, listener_from_lambda)
{
    bool matched = false;
 
    using view_t = Kokkos::View<int, execution_space>;
 
    const view_t my_src_view(Kokkos::view_alloc(Kokkos::WithoutInitializing, exec, "my rank-0 src view"));
    const view_t my_dst_view(Kokkos::view_alloc(Kokkos::WithoutInitializing, exec, "my rank-0 dst view"));
 
    const auto listener_handle = Kokkos::utils::callbacks::Manager::register_listener(
        [&](const BeginDeepCopyEvent& event) {
            if (event.dst.size == sizeof(int) && event.src.ptr == my_src_view.data()
                && event.dst.ptr == my_dst_view.data()) matched = true;
        }
    );
 
    Kokkos::deep_copy(exec, my_dst_view, my_src_view);
 
    ASSERT_TRUE(matched);
 
    Kokkos::utils::callbacks::Manager::unregister_listener(listener_handle);
}
 
} // namespace Kokkos::utils::tests::callbacks