test_ensure_started.cpp

Go to the documentation of this file.

#include "kokkos-execution/utils/ignore_warnings.hpp"
PRAGMA_DIAGNOSTIC_PUSH
KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
#include "exec/ensure_started.hpp"
PRAGMA_DIAGNOSTIC_POP
 
#include "kokkos-execution/execution_space.hpp"
 
#include "kokkos-utils/callbacks/RecorderListener.hpp"
#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
 
#include "tests/utils/callback_matchers.hpp"
#include "tests/utils/execution_space_context.hpp"
#include "tests/utils/functors/increment.hpp"
#include "tests/utils/stdexec.hpp"

 
namespace Tests::ExecutionSpaceImpl {
 
using namespace Kokkos::utils::callbacks;
 
class EnsureStartedTest
    : 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,
        Kokkos::Execution::Impl::RecordEvent,
        Kokkos::Execution::Impl::WaitEvent
    >;
};

TEST_F(EnsureStartedTest, then) {
    const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
 
    const context_t esc{exec};
 
    const auto recorder_listener = std::make_shared<recorder_listener_t>();
 
    Kokkos::utils::callbacks::Manager::register_listener(recorder_listener);
    {
        auto sndr = stdexec::schedule(esc.get_scheduler()) | THEN_INCREMENT(data)
                  | experimental::execution::ensure_started();
 
        using sndr_t = decltype(sndr);
 
        ASSERT_THAT(recorder_listener->recorded_events, ::testing::SizeIs(2));
        ASSERT_THAT(data(), ::testing::Eq(1));
        ASSERT_THAT(
            recorder_listener->recorded_events,
            testing::ElementsAre(
                MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
                MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "after dispatch"))));

        static_assert(!stdexec::__decay_copyable<sndr_t&>);
 
        stdexec::sync_wait(std::move(sndr));
 
        ASSERT_THAT(recorder_listener->recorded_events, ::testing::SizeIs(2));

        static_assert(std::same_as<stdexec::__domain_of_t<stdexec::env_of_t<sndr_t>>, stdexec::default_domain>);
        static_assert(std::same_as<
                      stdexec::__detail::__completing_domain_t<stdexec::set_value_t, sndr_t, stdexec::env<>>,
                      stdexec::default_domain
        >);

        static_assert(!Tests::Utils::has_completion_scheduler_for<sndr_t, stdexec::set_value_t, stdexec::env<>>);
    }
    Kokkos::utils::callbacks::Manager::unregister_listener(recorder_listener.get());
}
 
} // namespace Tests::ExecutionSpaceImpl