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