test_scoped_region.cpp

Go to the documentation of this file.

#include "kokkos-utils/callbacks/RecorderListener.hpp"
#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
 
#include "kokkos-execution/execution_space.hpp"
 
#include "tests/utils/callback_matchers.hpp"
#include "tests/utils/execution_space_context.hpp"
#include "tests/utils/functors/increment.hpp"
#include "tests/utils/sink_receiver.hpp"
#include "tests/utils/sync_wait.hpp"

 
namespace Tests::ExecutionSpaceImpl {
 
using namespace Kokkos::utils::callbacks;
 
class ScopedRegionTest
    : public Tests::Utils::ExecutionSpaceContextTest<TEST_EXECUTION_SPACE>
    , public Kokkos::utils::tests::scoped::callbacks::Manager {
   public:
    using recorder_listener_t = RecorderListener<
        EventDiscardMatcher<TEST_EXECUTION_SPACE>,
        BeginFenceEvent,
        BeginParallelForEvent,
        PushRegionEvent,
        PopRegionEvent,
        Kokkos::Execution::Impl::RecordEvent,
        Kokkos::Execution::Impl::WaitEvent
    >;
};

consteval bool test_sndr_traits() {
    using schd_sndr_t = typename ScopedRegionTest::schedule_sender_t;
 
    using scoped_region_sndr_t =
        decltype(std::declval<schd_sndr_t>() | Kokkos::Execution::Profiling::scoped_region("the name of my nice scoped region", stdexec::then(KOKKOS_LAMBDA(){})));
 
    static_assert(stdexec::__nothrow_connectable<scoped_region_sndr_t, Tests::Utils::SinkReceiver>);
 
    return true;
}
static_assert(test_sndr_traits());

TEST_F(ScopedRegionTest, many) {
    const view_s_t data(Kokkos::view_alloc("data - shared space", exec));
 
    const context_t esc{exec};
 
    auto sndr = stdexec::schedule(esc.get_scheduler())
              | Kokkos::Execution::Profiling::scoped_region(
                    "the name of my nice scoped region", THEN_INCREMENT(data) | THEN_INCREMENT(data));
 
    const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(std::move(sndr));
 
    ASSERT_THAT(recorded_events, [&]() {
        if constexpr (Kokkos::Execution::Impl::has_non_blocking_dispatch<TEST_EXECUTION_SPACE>) {
            return testing::ElementsAre(
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "push")),
                MATCHER_FOR_PUSH_REGION("the name of my nice scoped region"),
                MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
                MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
                MATCHER_FOR_RECORD_EVENT(exec),
                MATCHER_FOR_WAIT_EVENT(recorded_events.at(4)),
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "pop")),
                MATCHER_FOR_POP_REGION());
        } else {
            return testing::ElementsAre(
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "push")),
                MATCHER_FOR_PUSH_REGION("the name of my nice scoped region"),
                MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
                MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "after dispatch")),
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "pop")),
                MATCHER_FOR_POP_REGION());
        }
    }());
}
 
} // namespace Tests::ExecutionSpaceImpl