callback_matchers.hpp

Go to the documentation of this file.

#ifndef KOKKOS_EXECUTION_TESTS_UTILS_CALLBACK_MATCHERS_HPP
#define KOKKOS_EXECUTION_TESTS_UTILS_CALLBACK_MATCHERS_HPP
 
#include <string>
#include <string_view>
 
#include "Kokkos_Macros.hpp"
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#else
#    include "Kokkos_Core.hpp"
#endif
 
#include "kokkos-utils/callbacks/Helpers.hpp"
 
#include "kokkos-execution/impl/type_info.hpp"

 
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
#define MATCHER_FOR_NAME(_type_, _name_)                                                                               \
    ::testing::Field(&Kokkos::utils::callbacks::_type_##Event::name, ::testing::StrEq(_name_))
 
#define MATCHER_FOR_DEV_ID(_type_, _exec_)                                                                             \
    ::testing::Field(                                                                                                  \
        &Kokkos::utils::callbacks::_type_##Event::dev_id,                                                              \
        ::testing::Eq(Kokkos::Tools::Experimental::device_id(_exec_)))
 
#define MATCHER_FOR_BEGIN_FENCE(_exec_, _label_)                                                                       \
    ABeginFenceEvent(MATCHER_FOR_NAME(BeginFence, _label_), MATCHER_FOR_DEV_ID(BeginFence, _exec_))
#define MATCHER_FOR_BEGIN_PFOR(_exec_, _label_)                                                                        \
    ABeginParallelForEvent(MATCHER_FOR_NAME(BeginParallelFor, _label_), MATCHER_FOR_DEV_ID(BeginParallelFor, _exec_))
#define MATCHER_FOR_BEGIN_PRED(_exec_, _label_)                                                                        \
    ABeginParallelReduceEvent(                                                                                         \
        MATCHER_FOR_NAME(BeginParallelReduce, _label_), MATCHER_FOR_DEV_ID(BeginParallelReduce, _exec_))
#define MATCHER_FOR_BEGIN_SINGLE(_exec_, _label_)                                                                      \
    ABeginSingleEvent(MATCHER_FOR_NAME(BeginSingle, _label_), MATCHER_FOR_DEV_ID(BeginSingle, _exec_))
#define MATCHER_FOR_PUSH_REGION(_label_) APushRegionEventWithName(::testing::StrEq(_label_))
#define MATCHER_FOR_POP_REGION()         APopRegionEvent()
 
#define MATCHER_FOR_BEGIN_DEEP_COPY(_dst_, _src_)                                                                      \
    ABeginDeepCopyEvent(                                                                                               \
        Kokkos::utils::callbacks::PartialMatcher<Kokkos::utils::callbacks::BeginDeepCopyEvent>{}(                      \
            Kokkos::utils::callbacks::BeginDeepCopyEvent{                                                              \
                .dst = KOKKOS_IMPL_STRIP_PARENS(_dst_), .src = KOKKOS_IMPL_STRIP_PARENS(_src_)}))
 
// NOLINTEND(cppcoreguidelines-macro-usage)

template <Kokkos::ExecutionSpace Exec>
constexpr std::string dispatch_label(const Exec&, const std::string_view label) {
    constexpr std::string_view prefix{Kokkos::Execution::Impl::display_string_of<Exec>()};
 
    std::string result;
    result.reserve(prefix.size() + 2 + label.size());
    result.append(prefix).append(": ").append(label);
    return result;
}
 
#if defined(KOKKOS_EXECUTION_IMPL_EVENT_HPP)
DEFINE_EVENT_MATCHER_IN(Kokkos::Execution::Impl, RecordEvent)
DEFINE_EVENT_MATCHER_IN(Kokkos::Execution::Impl, WaitEvent)
#endif
 
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
#define MATCHER_FOR_RECORD_EVENT(_exec_)                                                                               \
    ARecordEvent(                                                                                                      \
        ::testing::Field(                                                                                              \
            &Kokkos::Execution::Impl::RecordEvent::dev_id,                                                             \
            ::testing::Eq(Kokkos::Tools::Experimental::device_id(_exec_))))
 
#define MATCHER_FOR_WAIT_EVENT(_record_event_variant_)                                                                 \
    AWaitEvent(                                                                                                        \
        ::testing::Field(                                                                                              \
            &Kokkos::Execution::Impl::WaitEvent::event_id,                                                             \
            ::testing::Eq(std::get<Kokkos::Execution::Impl::RecordEvent>(_record_event_variant_).event_id)),           \
        ::testing::Field(                                                                                              \
            &Kokkos::Execution::Impl::WaitEvent::dev_id, ::testing::Eq(Kokkos::Execution::Impl::invalid_dev_id)))
 
#define MATCHER_FOR_WAIT_EXEC_EVENT(_exec_, _record_event_variant_)                                                    \
    AWaitEvent(                                                                                                        \
        ::testing::Field(                                                                                              \
            &Kokkos::Execution::Impl::WaitEvent::event_id,                                                             \
            ::testing::Eq(std::get<Kokkos::Execution::Impl::RecordEvent>(_record_event_variant_).event_id)),           \
        ::testing::Field(                                                                                              \
            &Kokkos::Execution::Impl::WaitEvent::dev_id,                                                               \
            ::testing::Eq(Kokkos::Tools::Experimental::device_id(_exec_))))
 
// NOLINTEND(cppcoreguidelines-macro-usage)

template <Kokkos::ExecutionSpace Exec>
struct EventDiscardMatcher {
#if defined(KOKKOS_ENABLE_SYCL)
    bool operator()(const Kokkos::utils::callbacks::BeginFenceEvent& event) const
        requires std::same_as<Exec, Kokkos::SYCL>
    {
        return event.name.find("Kokkos::SYCLInternal::USMObject") == std::string::npos;
    }

    bool operator()(const Kokkos::utils::callbacks::AllocateDataEvent& event) const
        requires std::same_as<Exec, Kokkos::SYCL>
    {
        return event.alloc.name.find("Kokkos::SYCL::USMObject") == std::string::npos;
    }
#endif
#if defined(KOKKOS_ENABLE_THREADS)
    bool operator()(const Kokkos::utils::callbacks::BeginFenceEvent& event) const {
        return event.name.find("Kokkos::ThreadsInternal::fence: Unnamed Instance Fence") == std::string::npos;
    }
#endif
 
#if defined(KOKKOS_ENABLE_HPX)
    static constexpr bool hpx_on_destruction(const Kokkos::utils::callbacks::BeginFenceEvent& event) noexcept {
        return event.name != "Kokkos::Experimental::HPX: fence on destruction";
    }
 
    bool operator()(const Kokkos::utils::callbacks::BeginFenceEvent& event) const noexcept
        requires std::same_as<Exec, Kokkos::Experimental::HPX>
    {
        return hpx_on_destruction(event);
    }
#endif
 
    template <Kokkos::utils::callbacks::Event EventType>
    constexpr bool operator()(const EventType&) const {
        return true;
    }
};
 
#endif // KOKKOS_EXECUTION_TESTS_UTILS_CALLBACK_MATCHERS_HPP