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(
231 recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
232 MATCHER_FOR_GRAPH_CREATE(device_handle),
233 MATCHER_FOR_GRAPH_ADDNODE(
234 recorded_events.at(2), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
235 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
236 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
237 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(2)),
238 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
239
240 ASSERT_EQ(data(), 7);
241}
242
248TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_same_graph_scheduler_instance) {
249 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
250
251 const context_t gctx{exec};
252
253 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
254
255 auto sndr = stdexec::schedule(gctx.get_scheduler())
256 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
257 | stdexec::continues_on(gctx.get_scheduler())
258 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()});
259
260 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
261
262 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
263 std::move(sndr)); // NOLINT(performance-move-const-arg)
264
265 ASSERT_THAT(
266 recorded_events,
267 testing::ElementsAre(
268 MATCHER_FOR_GRAPH_CREATE(device_handle),
269 MATCHER_FOR_GRAPH_ADDNODE(
270 recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
271 MATCHER_FOR_GRAPH_CREATE(device_handle),
272 MATCHER_FOR_GRAPH_ADDNODE(
273 recorded_events.at(2), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
274 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
275 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(2)),
276 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
277
278 ASSERT_EQ(data(), 7);
279}
280
289TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_same_type) {
290 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
291
292 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
293
294 Tests::Utils::show_exec_space_id(exec_A, "exec_A");
295 Tests::Utils::show_exec_space_id(exec_B, "exec_B");
296
297 const context_t gctx_A{exec_A}, gctx_B{exec_B};
298 const device_handle_t device_handle_A{exec_A}, device_handle_B{exec_B};
299
300 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
301
302 auto sndr = stdexec::schedule(gctx_A.get_scheduler())
303 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
304 | stdexec::continues_on(gctx_B.get_scheduler())
305 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()});
306
307 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
308
309 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
310 std::move(sndr)); // NOLINT(performance-move-const-arg)
311
312 if constexpr (Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>) {
313 ASSERT_THAT(
314 recorded_events,
315 testing::ElementsAre(
316 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
317 MATCHER_FOR_GRAPH_ADDNODE(
318 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
319 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
320 MATCHER_FOR_GRAPH_ADDNODE(
321 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
322 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
323 MATCHER_FOR_RECORD_EVENT(exec_A),
324 MATCHER_FOR_WAIT_EXEC_EVENT(exec_B, recorded_events.at(5)),
325 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
326 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
327 } else {
328 if (Tests::Utils::are_same_instances(exec_A, exec_B)) {
329 ASSERT_THAT(
330 recorded_events,
331 testing::ElementsAre(
332 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
333 MATCHER_FOR_GRAPH_ADDNODE(
334 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
335 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
336 MATCHER_FOR_GRAPH_ADDNODE(
337 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
338 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
339 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
340 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
341 } else {
342 ASSERT_THAT(
343 recorded_events,
344 testing::ElementsAre(
345 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
346 MATCHER_FOR_GRAPH_ADDNODE(
347 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
348 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
349 MATCHER_FOR_GRAPH_ADDNODE(
350 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
351 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
352 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "dependency")),
353 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
354 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "sync_wait"))));
355 }
356 }
357
358 ASSERT_EQ(data(), 7);
359}
360
370TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_and_back_same_type) {
371 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
372
373 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
374
375 Tests::Utils::show_exec_space_id(exec_A, "exec_A");
376 Tests::Utils::show_exec_space_id(exec_B, "exec_B");
377
378 const context_t gctx_A{exec_A}, gctx_B{exec_B};
379 const device_handle_t device_handle_A{exec_A}, device_handle_B{exec_B};
380
381 using functor_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
382
383 auto sndr = stdexec::schedule(gctx_A.get_scheduler())
384 | stdexec::then(functor_t{.prev = 0, .value = 4, .data = data.data()})
385 | stdexec::continues_on(gctx_B.get_scheduler())
386 | stdexec::then(functor_t{.prev = 4, .value = 3, .data = data.data()})
387 | stdexec::continues_on(gctx_A.get_scheduler())
388 | stdexec::then(functor_t{.prev = 7, .value = 2, .data = data.data()});
389
390 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
391
392 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
393 std::move(sndr)); // NOLINT(performance-move-const-arg)
394
395 if constexpr (Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>) {
396 ASSERT_THAT(recorded_events, testing::SizeIs(14));
397 ASSERT_THAT(
398 recorded_events,
399 testing::ElementsAre(
400 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
401 MATCHER_FOR_GRAPH_ADDNODE(
402 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
403 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
404 MATCHER_FOR_GRAPH_ADDNODE(
405 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
406 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
407 MATCHER_FOR_GRAPH_ADDNODE(
408 recorded_events.at(4), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
409 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
410 MATCHER_FOR_RECORD_EVENT(exec_A),
411 MATCHER_FOR_WAIT_EXEC_EVENT(exec_B, recorded_events.at(7)),
412 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
413 MATCHER_FOR_RECORD_EVENT(exec_B),
414 MATCHER_FOR_WAIT_EXEC_EVENT(exec_A, recorded_events.at(10)),
415 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
416 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
417 } else {
418 if (Tests::Utils::are_same_instances(exec_A, exec_B)) {
419 ASSERT_THAT(
420 recorded_events,
421 testing::ElementsAre(
422 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
423 MATCHER_FOR_GRAPH_ADDNODE(
424 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
425 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
426 MATCHER_FOR_GRAPH_ADDNODE(
427 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
428 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
429 MATCHER_FOR_GRAPH_ADDNODE(
430 recorded_events.at(4), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
431 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
432 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
433 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
434 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
435 } else {
436 ASSERT_THAT(recorded_events, testing::SizeIs(12));
437 ASSERT_THAT(
438 recorded_events,
439 testing::ElementsAre(
440 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
441 MATCHER_FOR_GRAPH_ADDNODE(
442 recorded_events.at(0), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
443 MATCHER_FOR_GRAPH_CREATE(device_handle_B),
444 MATCHER_FOR_GRAPH_ADDNODE(
445 recorded_events.at(2), device_handle_B, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
446 MATCHER_FOR_GRAPH_CREATE(device_handle_A),
447 MATCHER_FOR_GRAPH_ADDNODE(
448 recorded_events.at(4), device_handle_A, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
449 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(0)),
450 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "dependency")),
451 MATCHER_FOR_GRAPH_SUBMIT(exec_B, recorded_events.at(2)),
452 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec_B, "dependency")),
453 MATCHER_FOR_GRAPH_SUBMIT(exec_A, recorded_events.at(4)),
454 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec_A, "sync_wait"))));
455 }
456 }
457
458 ASSERT_EQ(data(), 9);
459}
460
462TEST_F(TEST_CATEGORY(ContinuesOnTest), transition_to_another_graph_scheduler_instance_and_back_different_type) {
463 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
464
465 const Kokkos::DefaultHostExecutionSpace exec_h{};
466
467 const Kokkos::Execution::GraphContext gctx_h{exec_h};
468 const context_t gctx{exec};
469
470 const auto device_handle_h = Kokkos::Experimental::get_device_handle(exec_h);
471
472 using functor_device_t = Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>;
473 using functor_host_t = Tests::Utils::Functors::LoadCheckAdd<value_t, false>;
474
475 auto sndr = stdexec::schedule(gctx.get_scheduler())
476 | stdexec::then(functor_device_t{.prev = 0, .value = 4, .data = data.data()})
477 | stdexec::continues_on(gctx_h.get_scheduler())
478 | stdexec::then(functor_host_t{.prev = 4, .value = 3, .data = data.data()})
479 | stdexec::continues_on(gctx.get_scheduler())
480 | stdexec::then(functor_device_t{.prev = 7, .value = 2, .data = data.data()});
481
482 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
483
484 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
485 std::move(sndr)); // NOLINT(performance-move-const-arg)
486
487 if (Tests::Utils::are_same_instances(exec, exec_h)) {
488 ASSERT_THAT(
489 recorded_events,
490 testing::ElementsAre(
491 MATCHER_FOR_GRAPH_CREATE(device_handle),
492 MATCHER_FOR_GRAPH_ADDNODE(
493 recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
494 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
495 MATCHER_FOR_GRAPH_ADDNODE(
496 recorded_events.at(2), device_handle_h, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
497 MATCHER_FOR_GRAPH_CREATE(device_handle),
498 MATCHER_FOR_GRAPH_ADDNODE(
499 recorded_events.at(4), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
500 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
501 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
502 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
503 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
504 } else if constexpr (
505 Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>
506 && std::same_as<Kokkos::DefaultHostExecutionSpace, TEST_EXECUTION_SPACE>) {
507 ASSERT_THAT(
508 recorded_events,
509 testing::ElementsAre(
510 MATCHER_FOR_GRAPH_CREATE(device_handle),
511 MATCHER_FOR_GRAPH_ADDNODE(
512 recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
513 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
514 MATCHER_FOR_GRAPH_ADDNODE(
515 recorded_events.at(2), device_handle_h, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
516 MATCHER_FOR_GRAPH_CREATE(device_handle),
517 MATCHER_FOR_GRAPH_ADDNODE(
518 recorded_events.at(4), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
519 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
520 MATCHER_FOR_RECORD_EVENT(exec),
521 MATCHER_FOR_WAIT_EXEC_EVENT(exec_h, recorded_events.at(7)),
522 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
523 MATCHER_FOR_RECORD_EVENT(exec_h),
524 MATCHER_FOR_WAIT_EXEC_EVENT(exec, recorded_events.at(10)),
525 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
526 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
527 } else {
528 ASSERT_THAT(
529 recorded_events,
530 testing::ElementsAre(
531 MATCHER_FOR_GRAPH_CREATE(device_handle),
532 MATCHER_FOR_GRAPH_ADDNODE(
533 recorded_events.at(0), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(0))),
534 MATCHER_FOR_GRAPH_CREATE(device_handle_h),
535 MATCHER_FOR_GRAPH_ADDNODE(
536 recorded_events.at(2), device_handle_h, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(2))),
537 MATCHER_FOR_GRAPH_CREATE(device_handle),
538 MATCHER_FOR_GRAPH_ADDNODE(
539 recorded_events.at(4), device_handle, MATCHER_FOR_GRAPH_ROOT_NODE_OF(recorded_events.at(4))),
540 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(0)),
541 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "dependency")),
542 MATCHER_FOR_GRAPH_SUBMIT(exec_h, recorded_events.at(2)),
543 MATCHER_FOR_BEGIN_FENCE(exec_h, dispatch_label(exec_h, "dependency")),
544 MATCHER_FOR_GRAPH_SUBMIT(exec, recorded_events.at(4)),
545 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
546 }
547
548 ASSERT_EQ(data(), 9);
549}
550
551} // 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::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
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
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:125
Kokkos::Execution::GraphContext::get_scheduler
auto get_scheduler() const noexcept -> GraphImpl::Scheduler< Exec >
Definition graph.hpp:134
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:36
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:66
Kokkos::Execution::GraphImpl::GraphSubmitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when a Kokkos graph is submitted.
Definition events.hpp:77
Kokkos::Execution::GraphImpl::OpState
Operation state that adds all closures as a sequence of nodes.
Definition operation_state.hpp:163
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:80
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:67
MATCHER_FOR_GRAPH_ADDNODE
#define MATCHER_FOR_GRAPH_ADDNODE(_graph_create_event_variant_, _device_handle_, _predecessor_)
Definition events.hpp:24
MATCHER_FOR_GRAPH_ROOT_NODE_OF
#define MATCHER_FOR_GRAPH_ROOT_NODE_OF(_graph_create_event_)
Definition events.hpp:47
sync_wait.hpp
throws_when_copied.hpp