kokkos-execution 0.0.1
Loading...
Searching...
No Matches
test_continues_on.cpp
Go to the documentation of this file.
1#include "kokkos-execution/utils/ignore_warnings.hpp"
2PRAGMA_DIAGNOSTIC_PUSH
3KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
4#include "exec/single_thread_context.hpp"
5PRAGMA_DIAGNOSTIC_POP
6
7#include "kokkos-utils/callbacks/ConjunctionMatcher.hpp"
8#include "kokkos-utils/callbacks/RecorderListener.hpp"
9#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
10
11#include "kokkos-execution/graph.hpp"
12
13#include "tests/graph/events.hpp"
14#include "tests/utils/callback_matchers.hpp"
15#include "tests/utils/category.hpp"
16#include "tests/utils/check_continues_on.hpp"
17#include "tests/utils/functors/load_check_add.hpp"
18#include "tests/utils/functors/no_op.hpp"
19#include "tests/utils/functors/throws_when_copied.hpp"
20#include "tests/utils/graph_context.hpp"
21#include "tests/utils/just_stopped.hpp"
22#include "tests/utils/sink_receiver.hpp"
23#include "tests/utils/stdexec.hpp"
24#include "tests/utils/sync_wait.hpp"
25
37
38namespace Tests::GraphImpl {
39
40using namespace Kokkos::utils::callbacks;
41
62
64consteval bool test_schedule_from_sndr_traits() {
65 using schd_sndr_t = typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t;
66
67 using schedule_from_sndr_t = Kokkos::Execution::GraphImpl::ScheduleFromSender<TEST_EXECUTION_SPACE, schd_sndr_t>;
68
69 static_assert(stdexec::__nothrow_connectable<schedule_from_sndr_t, Tests::Utils::SinkReceiver>);
70 static_assert(stdexec::__nothrow_connectable<const schedule_from_sndr_t&, Tests::Utils::SinkReceiver>);
71
72 return true;
73}
74static_assert(test_schedule_from_sndr_traits());
75
77consteval bool test_continues_on_sndr_traits() {
78 using schd_sndr_t = typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t;
79
80 using continues_on_sndr_t = Kokkos::Execution::GraphImpl::ContinuesOnSender<
81 typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t,
82 schd_sndr_t
83 >;
84
85 static_assert(stdexec::__nothrow_connectable<continues_on_sndr_t, Tests::Utils::SinkReceiver>);
86 static_assert(stdexec::__nothrow_connectable<const continues_on_sndr_t&, Tests::Utils::SinkReceiver>);
87
88 static_assert(Tests::Utils::check_continues_on<typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t>());
89
90 static_assert(
91 std::same_as<
92 stdexec::connect_result_t<continues_on_sndr_t&&, typename TEST_CATEGORY(ContinuesOnTest)::sync_wait_rcvr_t>,
93 Kokkos::Execution::GraphImpl::ContinuesOnOpState<
94 typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t,
95 typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t,
96 typename TEST_CATEGORY(ContinuesOnTest)::sync_wait_rcvr_t
97 >
98 >);
99 static_assert(std::same_as<
100 stdexec::connect_result_t<
101 const continues_on_sndr_t&,
102 typename TEST_CATEGORY(ContinuesOnTest)::sync_wait_rcvr_t
103 >,
104 Kokkos::Execution::GraphImpl::ContinuesOnOpState<
105 typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t const &,
106 typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t const &,
107 typename TEST_CATEGORY(ContinuesOnTest)::sync_wait_rcvr_t
108 >
109 >);
110
111 return true;
112}
113static_assert(test_continues_on_sndr_traits());
114
116consteval bool test_sndr_nothrow_transformable() {
117 using continues_on_sndr_t =
118 decltype(stdexec::just() | stdexec::continues_on(std::declval<typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t>()));
119
120 static_assert(std::same_as<
121 stdexec::__demangle_t<continues_on_sndr_t>,
122 Tests::Utils::basic_sender_t<
123 stdexec::continues_on_t,
124 typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t,
125 Tests::Utils::basic_sender_t<
126 stdexec::schedule_from_t,
127 stdexec::__,
128 Tests::Utils::basic_sender_t<stdexec::just_t, stdexec::__tuple<>>
129 >
130 >
131 >);
132
133 static_assert(stdexec::__detail::__has_nothrow_transform_sender<
134 Kokkos::Execution::GraphImpl::Domain,
135 stdexec::set_value_t,
136 continues_on_sndr_t&&,
137 stdexec::env<>
138 >);
139
140 using schedule_from_sndr_t = decltype(stdexec::schedule_from(
141 stdexec::schedule(std::declval<typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t>())));
142
143 static_assert(std::same_as<
144 stdexec::__demangle_t<schedule_from_sndr_t>,
145 Tests::Utils::basic_sender_t<
146 stdexec::schedule_from_t,
147 stdexec::__,
148 typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t
149 >
150 >);
151
152 static_assert(stdexec::__detail::__has_nothrow_transform_sender<
153 Kokkos::Execution::GraphImpl::Domain,
154 stdexec::set_value_t,
155 schedule_from_sndr_t&&,
156 stdexec::env<>
157 >);
158
159 return true;
160}
161static_assert(test_sndr_nothrow_transformable());
162
167TEST_F(TEST_CATEGORY(ContinuesOnTest), then_continues_on_single_thread_context_continues_on_then) {
168 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
169
170 const context_t gctx{exec};
171 experimental::execution::single_thread_context stc{};
172
173 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
174
175 auto sndr = stdexec::schedule(gctx.get_scheduler())
176 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
177 | stdexec::continues_on(stc.get_scheduler()) | stdexec::continues_on(gctx.get_scheduler())
178 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()});
179
180 using inner_sndr_t = Tests::Utils::basic_sender_t<
181 stdexec::continues_on_t,
182 typename TEST_CATEGORY(ContinuesOnTest)::scheduler_t,
183 Tests::Utils::basic_sender_t<
184 stdexec::schedule_from_t,
185 stdexec::__,
186 Tests::Utils::basic_sender_t<
187 stdexec::continues_on_t,
188 stdexec::run_loop::scheduler,
189 Tests::Utils::basic_sender_t<
190 stdexec::schedule_from_t,
191 stdexec::__,
192 Tests::Utils::basic_sender_t<
193 stdexec::then_t,
194 functor_t,
195 typename TEST_CATEGORY(ContinuesOnTest)::schedule_sender_t
196 >
197 >
198 >
199 >
200 >;
201
202 using transform_sender_result_t =
203 stdexec::transform_sender_result_t<decltype(sndr), stdexec::env_of_t<sync_wait_rcvr_t>>;
204 static_assert(std::same_as<
205 stdexec::__demangle_t<transform_sender_result_t>,
206 Kokkos::Execution::GraphImpl::ThenSender<TEST_EXECUTION_SPACE, inner_sndr_t, functor_t>
207 >);
208
209 using connect_result_t = stdexec::connect_result_t<decltype(sndr), sync_wait_rcvr_t>;
210 static_assert(std::same_as<
211 stdexec::__demangle_t<connect_result_t>,
212 Kokkos::Execution::GraphImpl::OpState<
213 inner_sndr_t,
214 sync_wait_rcvr_t,
215 Kokkos::Execution::GraphImpl::ThenClosure<TEST_EXECUTION_SPACE, functor_t>
216 >
217 >);
218
219 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
220
221 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(sndr)
222
223 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
224 std::move(sndr)); // NOLINT(performance-move-const-arg)
225
226 ASSERT_THAT(
227 recorded_events,
228 testing::ElementsAre(
229 MATCHER_FOR_GRAPH_CREATE(device_handle),
230 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle, nullptr),
231 MATCHER_FOR_GRAPH_CREATE(device_handle),
232 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle, nullptr),
233 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
234 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
235 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(2)),
236 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
237
238 ASSERT_EQ(data(), 7);
239}
240
246TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_same_graph_scheduler_instance) {
247 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
248
249 const context_t gctx{exec};
250
251 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
252
253 auto sndr = stdexec::schedule(gctx.get_scheduler())
254 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
255 | stdexec::continues_on(gctx.get_scheduler())
256 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()});
257
258 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
259
260 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
261 std::move(sndr)); // NOLINT(performance-move-const-arg)
262
263 ASSERT_THAT(
264 recorded_events,
265 testing::ElementsAre(
266 MATCHER_FOR_GRAPH_CREATE(device_handle),
267 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle, nullptr),
268 MATCHER_FOR_GRAPH_CREATE(device_handle),
269 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle, nullptr),
270 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
271 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(2)),
272 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
273
274 ASSERT_EQ(data(), 7);
275}
276
285TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_same_type) {
286 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
287
288 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
289
290 Tests::Utils::show_exec_space_id(exec_A, "exec_A");
291 Tests::Utils::show_exec_space_id(exec_B, "exec_B");
292
293 const context_t gctx_A{exec_A}, gctx_B{exec_B};
294 const device_handle_t device_handle_A{exec_A}, device_handle_B{exec_B};
295
296 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
297
298 auto sndr = stdexec::schedule(gctx_A.get_scheduler())
299 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
300 | stdexec::continues_on(gctx_B.get_scheduler())
301 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()});
302
303 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
304
305 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
306 std::move(sndr)); // NOLINT(performance-move-const-arg)
307
308 if constexpr (Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>) {
309 ASSERT_THAT(
310 recorded_events,
311 testing::ElementsAre(
312 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
313 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
314 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
315 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
316 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
317 MATCHER_FOR_RECORD_EVENT(exec_A),
318 MATCHER_FOR_WAIT_EXEC_EVENT(exec_B, recorded_events.at(5)),
319 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
320 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
321 } else {
322 if (Tests::Utils::are_same_instances(exec_A, exec_B)) {
323 ASSERT_THAT(
324 recorded_events,
325 testing::ElementsAre(
326 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
327 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
328 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
329 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
330 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
331 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
332 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
333 } else {
334 ASSERT_THAT(
335 recorded_events,
336 testing::ElementsAre(
337 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
338 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
339 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
340 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
341 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
342 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "dependency")),
343 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
344 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
345 }
346 }
347
348 ASSERT_EQ(data(), 7);
349}
350
360TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_and_back_same_type) {
361 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
362
363 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
364
365 Tests::Utils::show_exec_space_id(exec_A, "exec_A");
366 Tests::Utils::show_exec_space_id(exec_B, "exec_B");
367
368 const context_t gctx_A{exec_A}, gctx_B{exec_B};
369 const device_handle_t device_handle_A{exec_A}, device_handle_B{exec_B};
370
371 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
372
373 auto sndr = stdexec::schedule(gctx_A.get_scheduler())
374 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
375 | stdexec::continues_on(gctx_B.get_scheduler())
376 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()})
377 | stdexec::continues_on(gctx_A.get_scheduler())
378 | stdexec::then(functor_t{.prev = 7, .value = 2, .data = data.data()});
379
380 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
381
382 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
383 std::move(sndr)); // NOLINT(performance-move-const-arg)
384
385 if constexpr (Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>) {
386 ASSERT_THAT(recorded_events, testing::SizeIs(14));
387 ASSERT_THAT(
388 recorded_events,
389 testing::ElementsAre(
390 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
391 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
392 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
393 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
394 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
395 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle_A, nullptr),
396 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
397 MATCHER_FOR_RECORD_EVENT(exec_A),
398 MATCHER_FOR_WAIT_EXEC_EVENT(exec_B, recorded_events.at(7)),
399 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
400 MATCHER_FOR_RECORD_EVENT(exec_B),
401 MATCHER_FOR_WAIT_EXEC_EVENT(exec_A, recorded_events.at(10)),
402 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
403 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
404 } else {
405 if (Tests::Utils::are_same_instances(exec_A, exec_B)) {
406 ASSERT_THAT(
407 recorded_events,
408 testing::ElementsAre(
409 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
410 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
411 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
412 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
413 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
414 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle_A, nullptr),
415 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
416 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
417 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
418 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
419 } else {
420 ASSERT_THAT(recorded_events, testing::SizeIs(12));
421 ASSERT_THAT(
422 recorded_events,
423 testing::ElementsAre(
424 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
425 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle_A, nullptr),
426 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
427 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_B, nullptr),
428 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
429 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle_A, nullptr),
430 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
431 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "dependency")),
432 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
433 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "dependency")),
434 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
435 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
436 }
437 }
438
439 ASSERT_EQ(data(), 9);
440}
441
443TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_and_back_different_type) {
444 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
445
446 const Kokkos::DefaultHostExecutionSpace exec_h{};
447
448 const Kokkos::Execution::GraphContext gctx_h{exec_h};
449 const context_t gctx{exec};
450
451 const auto device_handle_h = Kokkos::Experimental::get_device_handle(exec_h);
452
453 using functor_device_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
454 using functor_host_t = Tests::Utils::Functors::LoadCheckAdd<value_t, false>;
455
456 auto sndr = stdexec::schedule(gctx.get_scheduler())
457 | stdexec::then(functor_device_t{.prev = 0, .value = 4, .data = data.data()})
458 | stdexec::continues_on(gctx_h.get_scheduler())
459 | stdexec::then(functor_host_t{.prev = 4, .value = 3, .data = data.data()})
460 | stdexec::continues_on(gctx.get_scheduler())
461 | stdexec::then(functor_device_t{.prev = 7, .value = 2, .data = data.data()});
462
463 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
464
465 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
466 std::move(sndr)); // NOLINT(performance-move-const-arg)
467
468 if (Tests::Utils::are_same_instances(exec, exec_h)) {
469 ASSERT_THAT(
470 recorded_events,
471 testing::ElementsAre(
472 MATCHER_FOR_GRAPH_CREATE(device_handle),
473 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle, nullptr),
474 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
475 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_h, nullptr),
476 MATCHER_FOR_GRAPH_CREATE(device_handle),
477 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle, nullptr),
478 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
479 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
480 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
481 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
482 } else if constexpr (
483 Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>
484 && std::same_as<Kokkos::DefaultHostExecutionSpace, TEST_EXECUTION_SPACE>) {
485 ASSERT_THAT(
486 recorded_events,
487 testing::ElementsAre(
488 MATCHER_FOR_GRAPH_CREATE(device_handle),
489 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle, nullptr),
490 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
491 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_h, nullptr),
492 MATCHER_FOR_GRAPH_CREATE(device_handle),
493 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle, nullptr),
494 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
495 MATCHER_FOR_RECORD_EVENT(exec),
496 MATCHER_FOR_WAIT_EXEC_EVENT(exec_h, recorded_events.at(7)),
497 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
498 MATCHER_FOR_RECORD_EVENT(exec_h),
499 MATCHER_FOR_WAIT_EXEC_EVENT(exec, recorded_events.at(10)),
500 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
501 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
502 } else {
503 ASSERT_THAT(
504 recorded_events,
505 testing::ElementsAre(
506 MATCHER_FOR_GRAPH_CREATE(device_handle),
507 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(0), device_handle, nullptr),
508 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
509 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(2), device_handle_h, nullptr),
510 MATCHER_FOR_GRAPH_CREATE(device_handle),
511 MATCHER_FOR_GRAPH_ADDNODE(recorded_events.at(4), device_handle, nullptr),
512 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
513 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "dependency")),
514 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
515 MATCHER_FOR_BEGIN_FENCE(exec_h, dispatch_label(exec_h, "dependency")),
516 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
517 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
518 }
519
520 ASSERT_EQ(data(), 9);
521}
522
523} // namespace Tests::GraphImpl
callback_matchers.hpp
dispatch_label
constexpr std::string dispatch_label(const Exec &, Label &&label)
Get the dispatch label from Exec and label.
Definition callback_matchers.hpp:47
MATCHER_FOR_WAIT_EXEC_EVENT
#define MATCHER_FOR_WAIT_EXEC_EVENT(_exec_, _record_event_variant_)
Definition callback_matchers.hpp:71
MATCHER_FOR_RECORD_EVENT
#define MATCHER_FOR_RECORD_EVENT(_exec_)
Definition callback_matchers.hpp:57
MATCHER_FOR_BEGIN_FENCE
#define MATCHER_FOR_BEGIN_FENCE(_exec_, _label_)
Definition callback_matchers.hpp:28
TEST_CATEGORY
#define TEST_CATEGORY(_name_)
Definition category.hpp:10
check_continues_on.hpp
Tests::GraphImpl::ContinuesOnTest::sync_wait_rcvr_t
Kokkos::Execution::Impl::SyncWait::Receiver< TEST_EXECUTION_SPACE, std::true_type > sync_wait_rcvr_t
Definition test_continues_on.cpp:60
Tests::GraphImpl::ContinuesOnTest::recorder_listener_t
RecorderListener< ConjunctionMatcher< EventDiscardMatcher< TEST_EXECUTION_SPACE >, GraphEventDiscardMatcher< TEST_EXECUTION_SPACE > >, BeginFenceEvent, BeginParallelForEvent, AllocateDataEvent, DeallocateDataEvent, Kokkos::Execution::Impl::RecordEvent, Kokkos::Execution::Impl::WaitEvent, Kokkos::Execution::GraphImpl::GraphAddNodeEvent, Kokkos::Execution::GraphImpl::GraphCreateEvent, Kokkos::Execution::GraphImpl::GraphInstantiateEvent, Kokkos::Execution::GraphImpl::GraphSubmitEvent > recorder_listener_t
Definition test_continues_on.cpp:46
Kokkos::Execution::Impl::has_exec_wait_event
Determine if the Kokkos backend can enqueue a wait for an event into an execution space instance.
Definition dependency.hpp:16
KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP
#define KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(_sndr_)
Definition context.hpp:69
graph_context.hpp
ignore_warnings.hpp
KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
#define KOKKOS_EXECUTION_STDEXEC_PRAGMA_DIAGNOSTIC_IGNORED
Basic list of ignored diagnostics when including anything from stdexec.
Definition ignore_warnings.hpp:38
just_stopped.hpp
load_check_add.hpp
Tests::GraphImpl::test_continues_on_sndr_traits
consteval bool test_continues_on_sndr_traits()
Definition test_continues_on.cpp:77
Tests::GraphImpl::test_schedule_from_sndr_traits
consteval bool test_schedule_from_sndr_traits()
Definition test_continues_on.cpp:64
Tests::Utils::basic_sender_t
typename stdexec::__basic_sender< Args... >::type basic_sender_t
See https://github.com/NVIDIA/stdexec/pull/1873#discussion_r2834863237.
Definition stdexec.hpp:12
Tests::Utils::record_sync_wait
auto record_sync_wait(Sndr &&sndr)
Definition sync_wait.hpp:14
Tests::Utils::check_continues_on
consteval bool check_continues_on()
Check how the scheduler customizes stdexec::continues_on.
Definition check_continues_on.hpp:20
Tests::Utils::show_exec_space_id
void show_exec_space_id(const Exec &exec, std::string_view label="", std::ostream &out=std::cout)
Definition kokkos.hpp:33
Tests::Utils::are_same_instances
bool are_same_instances(const Exec &exec, const OtherExec &other_exec)
Definition kokkos.hpp:13
no_op.hpp
sink_receiver.hpp
Kokkos::Execution::GraphContext
Execution context using Kokkos::Experimental::Graph under the hood.
Definition graph.hpp:117
Kokkos::Execution::GraphContext::get_scheduler
auto get_scheduler() const noexcept -> GraphImpl::Scheduler< Exec >
Definition graph.hpp:126
Kokkos::Execution::GraphImpl::ContinuesOnOpState
Operation state for stdexec::continues_on.
Definition continues_on.hpp:57
Kokkos::Execution::GraphImpl::GraphAddNodeEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when a Kokkos graph node is added.
Definition events.hpp:35
Kokkos::Execution::GraphImpl::GraphCreateEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when a Kokkos graph is created.
Definition events.hpp:16
Kokkos::Execution::GraphImpl::GraphInstantiateEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when a Kokkos graph is instantiated.
Definition events.hpp:65
Kokkos::Execution::GraphImpl::GraphSubmitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when a Kokkos graph is submitted.
Definition events.hpp:76
Kokkos::Execution::GraphImpl::OpState
Operation state that adds all closures as a sequence of nodes.
Definition operation_state.hpp:160
Kokkos::Execution::GraphImpl::ThenSender
Sender for stdexec::then.
Definition then.hpp:51
Kokkos::Execution::Impl::RecordEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling record.
Definition event.hpp:54
Kokkos::Execution::Impl::SyncWait::Receiver
Receiver for stdexec::sync_wait.
Definition sync_wait.hpp:46
Kokkos::Execution::Impl::WaitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling wait.
Definition event.hpp:75
Tests::GraphImpl::GraphEventDiscardMatcher
Similar to EventDiscardMatcher, for graph-related events.
Definition events.hpp:76
Tests::Utils::ContextTest< Kokkos::Execution::GraphContext, Exec >::scheduler_t
decltype(std::declval< const context_t >().get_scheduler()) scheduler_t
Definition context.hpp:28
Tests::Utils::ContextTest< Kokkos::Execution::GraphContext, Exec >::schedule_sender_t
decltype(stdexec::schedule(std::declval< scheduler_t >())) schedule_sender_t
Definition context.hpp:29
Tests::Utils::ContextTest< Kokkos::Execution::GraphContext, Exec >::view_s_t
Kokkos::View< value_t, Kokkos::SharedSpace > view_s_t
Definition context.hpp:32
Tests::Utils::Functors::LoadCheckAdd
Load the value at data and check it is equal to prev. Then, add value to it.
Definition load_check_add.hpp:14
Tests::Utils::GraphContextTest< TEST_EXECUTION_SPACE >::device_handle_t
Kokkos::Impl::DeviceHandle< Exec > device_handle_t
Definition graph_context.hpp:15
MATCHER_FOR_GRAPH_CREATE
#define MATCHER_FOR_GRAPH_CREATE(_device_handle_)
Definition events.hpp:17
MATCHER_FOR_GRAPH_SUBMIT
#define MATCHER_FOR_GRAPH_SUBMIT(_exec_, _graph_create_event_variant_)
Definition events.hpp:63
MATCHER_FOR_GRAPH_ADDNODE
#define MATCHER_FOR_GRAPH_ADDNODE(_graph_create_event_variant_, _device_handle_, _predecessor_)
Definition events.hpp:24
sync_wait.hpp
throws_when_copied.hpp