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, false>{.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_PFOR(exec, dispatch_label(exec, "then")),
71 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
72
73 ASSERT_EQ(data(), 8);
74}
75
77TEST_F(InterOpTest, transition_from_inline_scheduler) {
78 const view_s_t data(Kokkos::view_alloc("data - shared space"));
79
80 const context_t esc{exec};
81
82 Tests::Utils::show_exec_space_id(exec, "exec");
83
84 auto chain =
85 stdexec::schedule(stdexec::inline_scheduler{})
86 | stdexec::then(
87 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
88 | stdexec::continues_on(esc.get_scheduler())
89 | stdexec::then(
90 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
91
92 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
93
94 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
95 std::move(chain)); // NOLINT(performance-move-const-arg)
96
97 ASSERT_THAT(
98 recorded_events,
99 testing::ElementsAre(
100 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
101 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
102
103 ASSERT_EQ(data(), 8);
104}
105
107TEST_F(InterOpTest, transition_from_inline_scheduler_and_back) {
108 const view_s_t data(Kokkos::view_alloc("data - shared space"));
109
110 const context_t esc{exec};
111
112 Tests::Utils::show_exec_space_id(exec, "exec");
113
114 auto chain =
115 stdexec::schedule(stdexec::inline_scheduler{})
116 | stdexec::then(
117 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
118 | stdexec::continues_on(esc.get_scheduler())
119 | stdexec::then(
120 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
121 | stdexec::continues_on(stdexec::inline_scheduler{})
122 | stdexec::then(
123 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 8, .value = 4, .data = data.data()});
124
125 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
126
127 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
128 std::move(chain)); // NOLINT(performance-move-const-arg)
129
130 ASSERT_THAT(
131 recorded_events,
132 testing::ElementsAre(
133 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
134 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
135
136 ASSERT_EQ(data(), 12);
137}
138
140TEST_F(InterOpTest, transition_to_static_thread_pool) {
141 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
142
143 const context_t esc{exec};
144
145 experimental::execution::static_thread_pool pool{1};
146
147 Tests::Utils::show_exec_space_id(exec, "exec");
148
149 auto chain =
150 stdexec::schedule(esc.get_scheduler())
151 | stdexec::then(
152 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
153 | stdexec::continues_on(pool.get_scheduler())
154 | stdexec::then(
155 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()});
156
157 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
158
159 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
160 std::move(chain)); // NOLINT(performance-move-const-arg)
161
162 ASSERT_THAT(
163 recorded_events,
164 testing::ElementsAre(
165 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
166 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
167
168 ASSERT_EQ(data(), 8);
169}
170
172TEST_F(InterOpTest, transition_from_static_thread_pool) {
173 const view_s_t data(Kokkos::view_alloc("data - shared space"));
174
175 const context_t esc{exec};
176
177 experimental::execution::static_thread_pool pool{1};
178
179 Tests::Utils::show_exec_space_id(exec, "exec");
180
181 auto chain =
182 stdexec::schedule(pool.get_scheduler())
183 | stdexec::then(
184 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
185 | stdexec::continues_on(esc.get_scheduler())
186 | stdexec::then(
187 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
188
189 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
190
191 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
192
193 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
194 std::move(chain)); // NOLINT(performance-move-const-arg)
195
196 ASSERT_THAT(
197 recorded_events,
198 testing::ElementsAre(
199 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
200 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
201
202 ASSERT_EQ(data(), 8);
203}
204
206TEST_F(InterOpTest, transition_from_static_thread_pool_and_back) {
207 const view_s_t data(Kokkos::view_alloc("data - shared space"));
208
209 const context_t esc{exec};
210
211 experimental::execution::static_thread_pool pool{1};
212
213 Tests::Utils::show_exec_space_id(exec, "exec");
214
215 auto chain =
216 stdexec::schedule(pool.get_scheduler())
217 | stdexec::then(
218 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
219 | stdexec::continues_on(esc.get_scheduler())
220 | stdexec::then(
221 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
222 | stdexec::continues_on(pool.get_scheduler())
223 | stdexec::then(
224 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 8, .value = 4, .data = data.data()});
225
226 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
227
228 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
229
230 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
231 std::move(chain)); // NOLINT(performance-move-const-arg)
232
233 ASSERT_THAT(
234 recorded_events,
235 testing::ElementsAre(
236 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
237 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
238
239 ASSERT_EQ(data(), 12);
240}
241
243TEST_F(InterOpTest, transition_to_static_thread_pool_and_back) {
244 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
245
246 const context_t esc{exec};
247
248 experimental::execution::static_thread_pool pool{1};
249
250 Tests::Utils::show_exec_space_id(exec, "exec");
251
252 auto chain =
253 stdexec::schedule(esc.get_scheduler())
254 | stdexec::then(
255 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
256 | stdexec::continues_on(pool.get_scheduler())
257 | stdexec::then(
258 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()})
259 | stdexec::continues_on(esc.get_scheduler())
260 | stdexec::then(
261 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 8, .value = 4, .data = data.data()});
262
263 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
264
265 KOKKOS_EXECUTION_THREADS_THROWS_ON_SYNC_WAIT_ASSERT_AND_SKIP(chain)
266
267 const auto recorded_events = Tests::Utils::record_sync_wait<recorder_listener_t>(
268 std::move(chain)); // NOLINT(performance-move-const-arg)
269
270 ASSERT_THAT(
271 recorded_events,
272 testing::ElementsAre(
273 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
274 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
275 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
276 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
277
278 ASSERT_EQ(data(), 12);
279}
280
281} // 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_BEGIN_PFOR
#define MATCHER_FOR_BEGIN_PFOR(_exec_, _label_)
Definition callback_matchers.hpp:30
MATCHER_FOR_BEGIN_FENCE
#define MATCHER_FOR_BEGIN_FENCE(_exec_, _label_)
Definition callback_matchers.hpp:28
Tests::ExecutionSpaceImpl::InterOpTest::recorder_listener_t
RecorderListener< EventDiscardMatcher< TEST_EXECUTION_SPACE >, BeginFenceEvent, BeginParallelForEvent, 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:69
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:38
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:33
EventDiscardMatcher
Matcher to filter out events that are just noise for tests.
Definition callback_matchers.hpp:83
Kokkos::Execution::ExecutionSpaceContext::get_scheduler
auto get_scheduler() const noexcept -> ExecutionSpaceImpl::Scheduler< Exec >
Definition execution_space.hpp:133
Kokkos::Execution::Impl::RecordEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling record.
Definition event.hpp:54
Kokkos::Execution::Impl::WaitEvent
Event to be sent to Kokkos::utils::callbacks::dispatch when calling wait.
Definition event.hpp:75
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::context_t
Kokkos::Execution::ExecutionSpaceContext< Exec > context_t
Definition context.hpp:27
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
sync_wait.hpp