kokkos-execution 0.0.1
Loading...
Searching...
No Matches
test_inter_op.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/static_thread_pool.hpp"
5PRAGMA_DIAGNOSTIC_POP
6
7#include "kokkos-utils/callbacks/RecorderListener.hpp"
8#include "kokkos-utils/tests/scoped/callbacks/Manager.hpp"
9
10#include "kokkos-execution/execution_space.hpp"
11
12#include "tests/utils/callback_matchers.hpp"
13#include "tests/utils/execution_space_context.hpp"
14#include "tests/utils/functors/load_check_add.hpp"
15#include "tests/utils/sync_wait.hpp"
16
28
29namespace Tests::ExecutionSpaceImpl {
30
31using namespace Kokkos::utils::callbacks;
32
45
47TEST_F(InterOpTest, transition_to_inline_scheduler) {
48 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
49
50 const context_t esc{exec};
51
52 Tests::Utils::show_exec_space_id(exec, "exec");
53
54 auto chain =
55 stdexec::schedule(esc.get_scheduler())
56 | stdexec::then(
57 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
58 | stdexec::continues_on(stdexec::inline_scheduler{})
59 | stdexec::then(
60 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
61
62 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
63
64 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
65 std::move(chain)); // NOLINT(performance-move-const-arg)
66
67 ASSERT_THAT(
68 recorded_events,
69 testing::ElementsAre(
70 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
71 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
72 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
73 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
74
75 ASSERT_EQ(data(), 8);
76}
77
79TEST_F(InterOpTest, transition_from_inline_scheduler) {
80 const view_s_t data(Kokkos::view_alloc("data - shared space"));
81
82 const context_t esc{exec};
83
84 Tests::Utils::show_exec_space_id(exec, "exec");
85
86 auto chain =
87 stdexec::schedule(stdexec::inline_scheduler{})
88 | stdexec::then(
89 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
90 | stdexec::continues_on(esc.get_scheduler())
91 | stdexec::then(
92 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
93
94 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
95
96 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
97 std::move(chain)); // NOLINT(performance-move-const-arg)
98
99 ASSERT_THAT(
100 recorded_events,
101 testing::ElementsAre(
102 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
103 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
104
105 ASSERT_EQ(data(), 8);
106}
107
109TEST_F(InterOpTest, transition_from_inline_scheduler_and_back) {
110 const view_s_t data(Kokkos::view_alloc("data - shared space"));
111
112 const context_t esc{exec};
113
114 Tests::Utils::show_exec_space_id(exec, "exec");
115
116 auto chain =
117 stdexec::schedule(stdexec::inline_scheduler{})
118 | stdexec::then(
119 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
120 | stdexec::continues_on(esc.get_scheduler())
121 | stdexec::then(
122 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
123 | stdexec::continues_on(stdexec::inline_scheduler{})
124 | stdexec::then(
125 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 8, .value = 4, .data = data.data()});
126
127 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
128
129 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
130 std::move(chain)); // NOLINT(performance-move-const-arg)
131
132 ASSERT_THAT(
133 recorded_events,
134 testing::ElementsAre(
135 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
136 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
137 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
138 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
139
140 ASSERT_EQ(data(), 12);
141}
142
144TEST_F(InterOpTest, transition_to_static_thread_pool) {
145 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
146
147 const context_t esc{exec};
148
149 experimental::execution::static_thread_pool pool{1};
150
151 Tests::Utils::show_exec_space_id(exec, "exec");
152
153 auto chain =
154 stdexec::schedule(esc.get_scheduler())
155 | stdexec::then(
156 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
157 | stdexec::continues_on(pool.get_scheduler())
158 | stdexec::then(
159 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()});
160
161 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
162
163 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
164 std::move(chain)); // NOLINT(performance-move-const-arg)
165
166 ASSERT_THAT(
167 recorded_events,
168 testing::ElementsAre(
169 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
170 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
171
172 ASSERT_EQ(data(), 8);
173}
174
176TEST_F(InterOpTest, transition_from_static_thread_pool) {
177 const view_s_t data(Kokkos::view_alloc("data - shared space"));
178
179 const context_t esc{exec};
180
181 experimental::execution::static_thread_pool pool{1};
182
183 Tests::Utils::show_exec_space_id(exec, "exec");
184
185 auto chain =
186 stdexec::schedule(pool.get_scheduler())
187 | stdexec::then(
188 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
189 | stdexec::continues_on(esc.get_scheduler())
190 | stdexec::then(
191 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
192
193 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
194
195 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
196
197 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
198 std::move(chain)); // NOLINT(performance-move-const-arg)
199
200 ASSERT_THAT(
201 recorded_events,
202 testing::ElementsAre(
203 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
204 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
205
206 ASSERT_EQ(data(), 8);
207}
208
210TEST_F(InterOpTest, transition_from_static_thread_pool_and_back) {
211 const view_s_t data(Kokkos::view_alloc("data - shared space"));
212
213 const context_t esc{exec};
214
215 experimental::execution::static_thread_pool pool{1};
216
217 Tests::Utils::show_exec_space_id(exec, "exec");
218
219 auto chain =
220 stdexec::schedule(pool.get_scheduler())
221 | stdexec::then(
222 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
223 | stdexec::continues_on(esc.get_scheduler())
224 | stdexec::then(
225 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
226 | stdexec::continues_on(pool.get_scheduler())
227 | stdexec::then(
228 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 8, .value = 4, .data = data.data()});
229
230 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
231
232 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
233
234 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
235 std::move(chain)); // NOLINT(performance-move-const-arg)
236
237 ASSERT_THAT(
238 recorded_events,
239 testing::ElementsAre(
240 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
241 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
242
243 ASSERT_EQ(data(), 12);
244}
245
247TEST_F(InterOpTest, transition_to_static_thread_pool_and_back) {
248 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
249
250 const context_t esc{exec};
251
252 experimental::execution::static_thread_pool pool{1};
253
254 Tests::Utils::show_exec_space_id(exec, "exec");
255
256 auto chain =
257 stdexec::schedule(esc.get_scheduler())
258 | stdexec::then(
259 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
260 | stdexec::continues_on(pool.get_scheduler())
261 | stdexec::then(
262 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()})
263 | stdexec::continues_on(esc.get_scheduler())
264 | stdexec::then(
265 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 8, .value = 4, .data = data.data()});
266
267 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
268
269 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
270
271 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
272 std::move(chain)); // NOLINT(performance-move-const-arg)
273
274 ASSERT_THAT(
275 recorded_events,
276 testing::ElementsAre(
277 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
278 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
279 MATCHER_FOR_BEGIN_SINGLE(exec, dispatch_label(exec, "then")),
280 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
281
282 ASSERT_EQ(data(), 12);
283}
284
285} // namespace Tests::ExecutionSpaceImpl
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_BEGIN_SINGLE
#define MATCHER_FOR_BEGIN_SINGLE(_exec_, _label_)
Definition callback_matchers.hpp:42
MATCHER_FOR_BEGIN_FENCE
#define MATCHER_FOR_BEGIN_FENCE(_exec_, _label_)
Definition callback_matchers.hpp:35
Tests::ExecutionSpaceImpl::InterOpTest::recorder_listener_t
RecorderListener< EventDiscardMatcher< TEST_EXECUTION_SPACE >, BeginFenceEvent, BeginSingleEvent, Kokkos::Execution::Impl::RecordEvent, Kokkos::Execution::Impl::WaitEvent > recorder_listener_t
Definition test_inter_op.cpp:37
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
execution_space.hpp
execution_space_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
load_check_add.hpp
Tests::Utils::record_sync_wait
auto record_sync_wait(Sndr &&sndr)
Definition sync_wait.hpp:14
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
EventDiscardMatcher
Matcher to filter out events that are just noise for tests.
Definition callback_matchers.hpp:99
Kokkos::Execution::ExecutionSpaceContext::get_scheduler
auto get_scheduler() const noexcept -> ExecutionSpaceImpl::Scheduler< execution_space >
Definition execution_space.hpp:141
Kokkos::Execution::Impl::RecordEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling record.
Definition event.hpp:59
Kokkos::Execution::Impl::WaitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling wait.
Definition event.hpp:80
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::context_t
Kokkos::Execution::ExecutionSpaceContext< Exec > context_t
Definition context.hpp:33
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
sync_wait.hpp