kokkos-execution 0.0.1
Loading...
Searching...
No Matches
test_continues_on.cpp
Go to the documentation of this file.
1#include "kokkos-utils/callbacks/RecorderListener.hpp"
2#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
3
4#include "kokkos-execution/execution_space.hpp"
5
6#include "tests/utils/callback_matchers.hpp"
7#include "tests/utils/check_continues_on.hpp"
8#include "tests/utils/check_rcvr_env.hpp"
9#include "tests/utils/execution_space_context.hpp"
10#include "tests/utils/functors/increment.hpp"
11#include "tests/utils/functors/labeled.hpp"
12#include "tests/utils/kokkos.hpp"
13#include "tests/utils/sink_receiver.hpp"
14#include "tests/utils/stdexec.hpp"
15#include "tests/utils/sync_wait.hpp"
16
28
29using host_execution_space = Kokkos::DefaultHostExecutionSpace;
30
31namespace Tests::ExecutionSpaceImpl {
32
33using namespace Kokkos::utils::callbacks;
34
47
49consteval bool test_schedule_from_sndr_traits() {
50 using schd_sndr_t = typename ContinuesOnTest::schedule_sender_t;
51
52 using schedule_from_sndr_t = Kokkos::Execution::ExecutionSpaceImpl::ScheduleFromSender<schd_sndr_t>;
53
54 static_assert(stdexec::__nothrow_connectable<schedule_from_sndr_t, Tests::Utils::SinkReceiver>);
55
56 return true;
57}
58static_assert(test_schedule_from_sndr_traits());
59
66static_assert(test_continues_on_sndr_traits());
67
69TEST_F(ContinuesOnTest, queryable_get_exec) {
70 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
71
72 const host_execution_space exec_h{};
73
74 const Kokkos::Execution::ExecutionSpaceContext esc_h{exec_h};
75 const context_t esc_A{exec_A}, esc_B{exec_B};
76
77 auto schs_A = stdexec::schedule(esc_A.get_scheduler());
78
80 static_assert(!stdexec::__queryable_with<decltype(stdexec::get_env(schs_A)), Kokkos::Execution::Impl::get_exec_t>);
81
82 auto schs_A_then = std::move(schs_A) | THEN_LABELED('A'); // NOLINT(performance-move-const-arg)
83
84 const auto sch_B = esc_B.get_scheduler();
85 auto schs_A_then_con_B = std::move(schs_A_then) // NOLINT(performance-move-const-arg)
86 | stdexec::continues_on(sch_B);
87
89 ASSERT_EQ(stdexec::get_completion_scheduler<stdexec::set_value_t>(stdexec::get_env(schs_A_then_con_B)), sch_B);
90
91 auto schs_A_then_con_B_then = std::move(schs_A_then_con_B) // NOLINT(performance-move-const-arg)
92 | THEN_LABELED('B');
93
94 static_assert(std::same_as<
95 stdexec::__demangle_t<decltype(schs_A_then_con_B_then)>,
96 Tests::Utils::basic_sender_t<
97 stdexec::then_t,
98 Tests::Utils::Functors::Labeled<'B'>,
99 Tests::Utils::basic_sender_t<
100 stdexec::continues_on_t,
101 scheduler_t,
102 Tests::Utils::basic_sender_t<
103 stdexec::schedule_from_t,
104 stdexec::__,
105 Tests::Utils::basic_sender_t<
106 stdexec::then_t,
107 Tests::Utils::Functors::Labeled<'A'>,
108 schedule_sender_t
109 >
110 >
111 >
112 >
113 >);
114
116 const auto sch_h = esc_h.get_scheduler();
117 auto schs_A_then_con_B_then_con_h_then = std::move(schs_A_then_con_B_then) // NOLINT(performance-move-const-arg)
118 | stdexec::continues_on(sch_h) | THEN_LABELED('h');
119 ASSERT_EQ(
120 stdexec::get_completion_scheduler<stdexec::set_value_t>(stdexec::get_env(schs_A_then_con_B_then_con_h_then)),
121 sch_h);
122
123 const auto op_state = stdexec::connect(
124 std::move(schs_A_then_con_B_then_con_h_then), // NOLINT(performance-move-const-arg)
125 Kokkos::Execution::Impl::SyncWait::Receiver<host_execution_space, std::true_type>{
126 .state = std::addressof(esc_h.m_state), .runloop_state = nullptr, .result = nullptr});
127
132 const auto& then_op_state = op_state;
133 using then_rcvr_t = Kokkos::Execution::Impl::Receiver<Kokkos::Execution::ExecutionSpaceImpl::OpStateBase<
134 Kokkos::Execution::Impl::SyncWait::Receiver<host_execution_space, std::true_type>,
135 Kokkos::Execution::ExecutionSpaceImpl::ParallelForClosure<
136 std::string_view,
137 Kokkos::Execution::ExecutionSpaceImpl::ThenWrapper<Tests::Utils::Functors::Labeled<'h'>>,
138 Kokkos::RangePolicy<host_execution_space, Kokkos::LaunchBounds<1>>
139 >
140 >>;
141 static_assert(std::same_as<decltype(then_op_state.inner_op_state.rcvr), then_rcvr_t>);
142 static_assert(!stdexec::__queryable_with<stdexec::env_of_t<then_rcvr_t>, Kokkos::Execution::Impl::get_exec_t>);
143
145 const auto& con_h_then_op_state = then_op_state.inner_op_state;
146 static_assert(stdexec::__is_instance_of<
147 std::remove_cvref_t<decltype(con_h_then_op_state)>,
148 Kokkos::Execution::ExecutionSpaceImpl::ContinuesOnOpState
149 >);
150 using con_h_then_rcvr_t = decltype(con_h_then_op_state.inner_op_state.rcvr);
151 static_assert(stdexec::__queryable_with<stdexec::env_of_t<con_h_then_rcvr_t>, Kokkos::Execution::Impl::get_exec_t>);
152 static_assert(std::same_as<
153 stdexec::env_of_t<con_h_then_rcvr_t>,
154 stdexec::env<
155 stdexec::prop<
156 Kokkos::Execution::Impl::get_exec_t,
157 Kokkos::Execution::Impl::ExecutionSpaceRef<host_execution_space>
158 >,
159 stdexec::__env::__fwd<Kokkos::Execution::Impl::SyncWait::env>
160 >
161 >);
162 ASSERT_EQ(
163 Kokkos::Execution::Impl::get_exec(stdexec::get_env(con_h_then_op_state.inner_op_state.rcvr)).get(), exec_h);
164
165 const auto& sfrom_con_h_then_op_state = con_h_then_op_state.inner_op_state;
166 static_assert(stdexec::__is_instance_of<
167 std::remove_cvref_t<decltype(sfrom_con_h_then_op_state)>,
168 Kokkos::Execution::ExecutionSpaceImpl::ScheduleFromOpState
169 >);
170 using sfrom_con_h_then_rcvr_t = decltype(sfrom_con_h_then_op_state.inner_op_state.completion_signal.rcvr);
171 static_assert(
172 !stdexec::__queryable_with<stdexec::env_of_t<sfrom_con_h_then_rcvr_t>, Kokkos::Execution::Impl::get_exec_t>);
173
174 const auto& then_sfrom_con_h_then_op_state = sfrom_con_h_then_op_state.inner_op_state;
175 static_assert(stdexec::__is_instance_of<
176 std::remove_cvref_t<decltype(then_sfrom_con_h_then_op_state)>,
177 Kokkos::Execution::ExecutionSpaceImpl::OpState
178 >);
179 using then_sfrom_con_h_then_rcvr_t = decltype(then_sfrom_con_h_then_op_state.inner_op_state.rcvr);
180 static_assert(!stdexec::__queryable_with<
181 stdexec::env_of_t<then_sfrom_con_h_then_rcvr_t>,
182 Kokkos::Execution::Impl::get_exec_t
183 >);
184
185 const auto& con_B_then_sfrom_con_h_then_op_state = then_sfrom_con_h_then_op_state.inner_op_state;
186 static_assert(stdexec::__is_instance_of<
187 std::remove_cvref_t<decltype(con_B_then_sfrom_con_h_then_op_state)>,
188 Kokkos::Execution::ExecutionSpaceImpl::ContinuesOnOpState
189 >);
190 using con_B_then_sfrom_con_h_then_rcvr_t = decltype(con_B_then_sfrom_con_h_then_op_state.inner_op_state.rcvr);
191 static_assert(stdexec::__queryable_with<
192 stdexec::env_of_t<con_B_then_sfrom_con_h_then_rcvr_t>,
193 Kokkos::Execution::Impl::get_exec_t
194 >);
195 static_assert(std::same_as<
196 stdexec::env_of_t<con_B_then_sfrom_con_h_then_rcvr_t>,
197 stdexec::env<
198 stdexec::prop<
199 Kokkos::Execution::Impl::get_exec_t,
200 Kokkos::Execution::Impl::ExecutionSpaceRef<TEST_EXECUTION_SPACE>
201 >,
202 stdexec::__env::__fwd<stdexec::env<
203 stdexec::prop<
204 Kokkos::Execution::Impl::get_exec_t,
205 Kokkos::Execution::Impl::ExecutionSpaceRef<host_execution_space>
206 >,
207 stdexec::__env::__fwd<Kokkos::Execution::Impl::SyncWait::env>
208 >>
209 >
210 >);
211 ASSERT_EQ(
212 Kokkos::Execution::Impl::get_exec(stdexec::get_env(con_B_then_sfrom_con_h_then_op_state.inner_op_state.rcvr))
213 .get(),
214 exec_B);
215
216 const auto& sfrom_con_B_then_sfrom_con_h_then_op_state = con_B_then_sfrom_con_h_then_op_state.inner_op_state;
217 static_assert(stdexec::__is_instance_of<
218 std::remove_cvref_t<decltype(sfrom_con_B_then_sfrom_con_h_then_op_state)>,
219 Kokkos::Execution::ExecutionSpaceImpl::ScheduleFromOpState
220 >);
221 using sfrom_con_B_then_sfrom_con_h_then_rcvr_t = decltype(sfrom_con_B_then_sfrom_con_h_then_op_state.inner_op_state
222 .completion_signal.rcvr);
223 static_assert(!stdexec::__queryable_with<
224 stdexec::env_of_t<sfrom_con_B_then_sfrom_con_h_then_rcvr_t>,
225 Kokkos::Execution::Impl::get_exec_t
226 >);
227
228 const auto& then_sfrom_B_then_sfrom_con_h_then_op_state = sfrom_con_B_then_sfrom_con_h_then_op_state.inner_op_state;
229 static_assert(stdexec::__is_instance_of<
230 std::remove_cvref_t<decltype(then_sfrom_B_then_sfrom_con_h_then_op_state)>,
231 Kokkos::Execution::ExecutionSpaceImpl::OpState
232 >);
233 using then_sfrom_con_B_then_sfrom_con_h_then_rcvr_t = decltype(then_sfrom_B_then_sfrom_con_h_then_op_state
234 .inner_op_state.rcvr);
235 static_assert(!stdexec::__queryable_with<
236 stdexec::env_of_t<then_sfrom_con_B_then_sfrom_con_h_then_rcvr_t>,
237 Kokkos::Execution::Impl::get_exec_t
238 >);
239}
240
242TEST_F(ContinuesOnTest, then_sync_wait) {
243 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
244
245 const context_t esc{exec};
246
247 stdexec::sender auto chain = stdexec::just() | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data);
248
249 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
250
251 ASSERT_THAT(
252 Tests::Utils::record_sync_wait<recorder_listener_t>(std::move(chain)),
253 ::testing::ElementsAre(
254 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
255 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
256
257 ASSERT_EQ(data(), 1);
258}
259
266TEST_F(ContinuesOnTest, transition_to_same_execution_space_instance) {
267 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
268
269 const context_t esc{exec};
270
271 auto chain = stdexec::just() | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data)
272 | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data)
273 | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data);
274
275 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
276
277 ASSERT_THAT(
278 Tests::Utils::record_sync_wait<recorder_listener_t>(std::move(chain)),
279 ::testing::ElementsAre(
280 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
281 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
282 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
283 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
284
285 ASSERT_EQ(data(), 3) << "A synchronization is missing.";
286}
287
292TEST_F(ContinuesOnTest, transition_to_another_execution_space_instance_and_back_same_type) {
293 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
294
295 const auto [exec_A, exec_B] = Kokkos::Experimental::partition_space(exec, 1, 1);
296
297 const context_t esc_A{exec_A};
298 Tests::Utils::show_exec_space_id(exec_A, "exec_A");
299 const context_t esc_B{exec_B};
300 Tests::Utils::show_exec_space_id(exec_B, "exec_B");
301
302 auto chain = stdexec::just() | stdexec::continues_on(esc_A.get_scheduler()) | THEN_INCREMENT(data)
303 | stdexec::continues_on(esc_B.get_scheduler()) | THEN_INCREMENT(data)
304 | stdexec::continues_on(esc_A.get_scheduler()) | THEN_INCREMENT(data);
305
306 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
307
308 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(std::move(chain));
309
310 if constexpr (Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>) {
311 ASSERT_THAT(
312 recorded_events,
313 ::testing::ElementsAre(
314 MATCHER_FOR_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
315 MATCHER_FOR_RECORD_EVENT(exec_A),
316 MATCHER_FOR_WAIT_EXEC_EVENT(exec_B, recorded_events.at(1)),
317 MATCHER_FOR_BEGIN_PFOR(exec_B, dispatch_label(exec, "then")),
318 MATCHER_FOR_RECORD_EVENT(exec_B),
319 MATCHER_FOR_WAIT_EXEC_EVENT(exec_A, recorded_events.at(4)),
320 MATCHER_FOR_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
321 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec, "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_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
328 MATCHER_FOR_BEGIN_PFOR(exec_B, dispatch_label(exec, "then")),
329 MATCHER_FOR_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
330 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec, "sync_wait"))));
331 } else {
332 ASSERT_THAT(
333 recorded_events,
334 ::testing::ElementsAre(
335 MATCHER_FOR_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
336 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec, "dependency")),
337 MATCHER_FOR_BEGIN_PFOR(exec_B, dispatch_label(exec, "then")),
338 MATCHER_FOR_BEGIN_FENCE(exec_B, dispatch_label(exec, "dependency")),
339 MATCHER_FOR_BEGIN_PFOR(exec_A, dispatch_label(exec, "then")),
340 MATCHER_FOR_BEGIN_FENCE(exec_A, dispatch_label(exec, "sync_wait"))));
341 }
342 }
343
344 ASSERT_EQ(data(), 3) << "A synchronization is missing.";
345}
346
351TEST_F(ContinuesOnTest, transition_to_another_execution_space_instance_and_back_different_type) {
352 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
353
354 const host_execution_space exec_h{};
355
356 const Kokkos::Execution::ExecutionSpaceContext esc_h{exec_h};
357 const context_t esc{exec};
358
359 Tests::Utils::show_exec_space_id(exec, "exec");
360 Tests::Utils::show_exec_space_id(exec_h, "exec_h");
361
362 using level_C_env_t = Kokkos::Execution::Impl::SyncWait::env;
363 using level_B_env_t = stdexec::__env::__fwd<stdexec::env<
364 stdexec::prop<
365 Kokkos::Execution::Impl::get_exec_t,
366 Kokkos::Execution::Impl::ExecutionSpaceRef<TEST_EXECUTION_SPACE>
367 >,
368 stdexec::__env::__fwd<level_C_env_t>
369 >>;
370 using level_A_env_t = stdexec::__env::__fwd<stdexec::env<
371 stdexec::prop<
372 Kokkos::Execution::Impl::get_exec_t,
373 Kokkos::Execution::Impl::ExecutionSpaceRef<host_execution_space>
374 >,
375 level_B_env_t
376 >>;
377 auto chain = stdexec::just() | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data)
378 | Tests::Utils::check_rcvr_env<level_A_env_t>() | stdexec::continues_on(esc_h.get_scheduler())
379 | THEN_INCREMENT(data) | Tests::Utils::check_rcvr_env<level_B_env_t>()
380 | stdexec::continues_on(esc.get_scheduler()) | THEN_INCREMENT(data)
381 | Tests::Utils::check_rcvr_env<level_C_env_t>();
382
383 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
384
385 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(std::move(chain));
386
387 if (Tests::Utils::are_same_instances(exec, exec_h)) {
388 ASSERT_THAT(
389 recorded_events,
390 ::testing::ElementsAre(
391 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
392 MATCHER_FOR_BEGIN_PFOR(exec_h, dispatch_label(exec_h, "then")),
393 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
394 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
395 } else if constexpr (
396 Kokkos::Execution::Impl::has_exec_wait_event<TEST_EXECUTION_SPACE>
397 && std::same_as<host_execution_space, TEST_EXECUTION_SPACE>) {
398 ASSERT_THAT(
399 recorded_events,
400 ::testing::ElementsAre(
401 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
402 MATCHER_FOR_RECORD_EVENT(exec),
403 MATCHER_FOR_WAIT_EXEC_EVENT(exec_h, recorded_events.at(1)),
404 MATCHER_FOR_BEGIN_PFOR(exec_h, dispatch_label(exec_h, "then")),
405 MATCHER_FOR_RECORD_EVENT(exec_h),
406 MATCHER_FOR_WAIT_EXEC_EVENT(exec, recorded_events.at(4)),
407 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
408 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
409 } else {
410 ASSERT_THAT(
411 recorded_events,
412 ::testing::ElementsAre(
413 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
414 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "dependency")),
415 MATCHER_FOR_BEGIN_PFOR(exec_h, dispatch_label(exec_h, "then")),
416 MATCHER_FOR_BEGIN_FENCE(exec_h, dispatch_label(exec_h, "dependency")),
417 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
418 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
419 }
420
421 ASSERT_EQ(data(), 3) << "A synchronization is missing.";
422}
423
425consteval bool test_sndr_nothrow_transformable() {
426 using continues_on_sndr_t =
427 decltype(stdexec::just() | stdexec::continues_on(std::declval<typename ContinuesOnTest::scheduler_t>()));
428
429 static_assert(std::same_as<
430 stdexec::__demangle_t<continues_on_sndr_t>,
431 Tests::Utils::basic_sender_t<
432 stdexec::continues_on_t,
433 typename ContinuesOnTest::scheduler_t,
434 Tests::Utils::basic_sender_t<
435 stdexec::schedule_from_t,
436 stdexec::__,
437 Tests::Utils::basic_sender_t<stdexec::just_t, stdexec::__tuple<>>
438 >
439 >
440 >);
441
442 static_assert(stdexec::__detail::__has_nothrow_transform_sender<
443 Kokkos::Execution::ExecutionSpaceImpl::Domain,
444 stdexec::set_value_t,
445 continues_on_sndr_t&&,
446 stdexec::env<>
447 >);
448
449 using schedule_from_sndr_t = decltype(stdexec::schedule_from(
450 stdexec::schedule(std::declval<typename ContinuesOnTest::scheduler_t>())));
451
452 static_assert(std::same_as<
453 stdexec::__demangle_t<schedule_from_sndr_t>,
454 Tests::Utils::basic_sender_t<
455 stdexec::schedule_from_t,
456 stdexec::__,
457 typename ContinuesOnTest::schedule_sender_t
458 >
459 >);
460
461 static_assert(stdexec::__detail::__has_nothrow_transform_sender<
462 Kokkos::Execution::ExecutionSpaceImpl::Domain,
463 stdexec::set_value_t,
464 schedule_from_sndr_t&&,
465 stdexec::env<>
466 >);
467
468 return true;
469}
470static_assert(test_sndr_nothrow_transformable());
471
472} // namespace Tests::ExecutionSpaceImpl
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_BEGIN_PFOR
#define MATCHER_FOR_BEGIN_PFOR(_exec_, _label_)
Definition callback_matchers.hpp:30
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
check_continues_on.hpp
check_rcvr_env.hpp
Tests::ExecutionSpaceImpl::ContinuesOnTest::recorder_listener_t
RecorderListener< EventDiscardMatcher< TEST_EXECUTION_SPACE >, BeginFenceEvent, BeginParallelForEvent, Kokkos::Execution::Impl::RecordEvent, Kokkos::Execution::Impl::WaitEvent > recorder_listener_t
Definition test_continues_on.cpp:39
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
host_execution_space
Kokkos::DefaultHostExecutionSpace host_execution_space
Definition test_continues_on.cpp:29
execution_space.hpp
execution_space_context.hpp
THEN_INCREMENT
#define THEN_INCREMENT(_data_)
Add a then using Tests::Utils::Functors::Increment that may throw. // NOLINTNEXTLINE(cppcoreguideline...
Definition increment.hpp:59
THEN_LABELED
#define THEN_LABELED(_id_)
Add a then using Tests::Utils::Functors::Labeled. // NOLINTNEXTLINE(cppcoreguidelines-macro-usage).
Definition labeled.hpp:18
Kokkos::Execution::Impl::get_exec
constexpr get_exec_t get_exec
Definition get_exec.hpp:19
Tests::ExecutionSpaceImpl::test_schedule_from_sndr_traits
consteval bool test_schedule_from_sndr_traits()
Definition test_continues_on.cpp:49
Tests::ExecutionSpaceImpl::test_sndr_nothrow_transformable
consteval bool test_sndr_nothrow_transformable()
Definition test_bulk.cpp:83
Tests::ExecutionSpaceImpl::test_continues_on_sndr_traits
consteval bool test_continues_on_sndr_traits()
Definition test_continues_on.cpp:61
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::check_rcvr_env
constexpr check_rcvr_env_t< ExpectedEnv > check_rcvr_env
Definition check_rcvr_env.hpp:50
Tests::Utils::are_same_instances
bool are_same_instances(const Exec &exec, const OtherExec &other_exec)
Definition kokkos.hpp:13
sink_receiver.hpp
EventDiscardMatcher
Matcher to filter out events that are just noise for tests.
Definition callback_matchers.hpp:83
Kokkos::Execution::ExecutionSpaceContext
Execution context using a Kokkos execution space under the hood.
Definition execution_space.hpp:124
Kokkos::Execution::ExecutionSpaceContext::get_scheduler
auto get_scheduler() const noexcept -> ExecutionSpaceImpl::Scheduler< Exec >
Definition execution_space.hpp:133
Kokkos::Execution::ExecutionSpaceImpl::ThenWrapper
Inspired by https://github.com/kokkos/kokkos/blob/69273c3a4e7b6adeb95066341ca201d62fe1e698/core/src/i...
Definition then.hpp:16
Kokkos::Execution::Impl::ExecutionSpaceRef
Wrap a Kokkos execution space to make it cheap to copy/move in new environments.
Definition get_exec.hpp:47
Kokkos::Execution::Impl::Receiver
Receiver for an object parent_op that implements complete.
Definition receiver.hpp:13
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::SyncWait::env
Inspired by https://github.com/NVIDIA/stdexec/blob/16076a81efa4477513e6ede9c2741fd034ecef99/include/s...
Definition sync_wait.hpp:15
Kokkos::Execution::Impl::WaitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling wait.
Definition event.hpp:75
Kokkos::Execution::Impl::get_exec_t
Definition get_exec.hpp:15
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::scheduler_t
decltype(std::declval< const context_t >().get_scheduler()) scheduler_t
Definition context.hpp:28
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::schedule_sender_t
decltype(stdexec::schedule(std::declval< scheduler_t >())) schedule_sender_t
Definition context.hpp:29
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::context_t
Kokkos::Execution::ExecutionSpaceContext< Exec > context_t
Definition context.hpp:27
sync_wait.hpp