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 "tests/utils/callback_matchers.hpp"
11#include "tests/utils/execution_space_context.hpp"
12#include "tests/utils/functors/load_check_add.hpp"
13#include "tests/utils/kokkos.hpp"
14
26
27namespace Tests::ExecutionSpaceImpl {
28
29using namespace Kokkos::utils::callbacks;
30
39
41TEST_F(InterOpTest, transition_to_inline_scheduler) {
42 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
43
44 const context_t esc{exec};
45
46 Tests::Utils::show_exec_space_id(exec, "exec");
47
48 auto chain =
49 stdexec::schedule(esc.get_scheduler())
50 | stdexec::then(
51 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
52 | stdexec::continues_on(stdexec::inline_scheduler{})
53 | stdexec::then(
54 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()});
55
56 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
57
58 const auto recorded_events = recorder_listener_t::record(
59 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
60 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
61 });
62
63 EXPECT_THAT(
64 recorded_events,
65 testing::ElementsAre(
66 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
67 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
68
69 ASSERT_EQ(data(), 8);
70}
71
73TEST_F(InterOpTest, transition_from_inline_scheduler) {
74 const view_s_t data(Kokkos::view_alloc("data - shared space"));
75
76 const context_t esc{exec};
77
78 Tests::Utils::show_exec_space_id(exec, "exec");
79
80 auto chain =
81 stdexec::schedule(stdexec::inline_scheduler{})
82 | stdexec::then(
83 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
84 | stdexec::continues_on(esc.get_scheduler())
85 | stdexec::then(
86 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
87
88 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
89
90 const auto recorded_events = recorder_listener_t::record(
91 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
92 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
93 });
94
95 EXPECT_THAT(
96 recorded_events,
97 testing::ElementsAre(
98 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
99 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
100
101 ASSERT_EQ(data(), 8);
102}
103
105TEST_F(InterOpTest, transition_from_inline_scheduler_and_back) {
106 const view_s_t data(Kokkos::view_alloc("data - shared space"));
107
108 const context_t esc{exec};
109
110 Tests::Utils::show_exec_space_id(exec, "exec");
111
112 auto chain =
113 stdexec::schedule(stdexec::inline_scheduler{})
114 | stdexec::then(
115 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
116 | stdexec::continues_on(esc.get_scheduler())
117 | stdexec::then(
118 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
119 | stdexec::continues_on(stdexec::inline_scheduler{})
120 | stdexec::then(
121 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 8, .value = 4, .data = data.data()});
122
123 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
124
125 const auto recorded_events = recorder_listener_t::record(
126 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
127 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
128 });
129
130 EXPECT_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 = recorder_listener_t::record(
160 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
161 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
162 });
163
164 EXPECT_THAT(
165 recorded_events,
166 testing::ElementsAre(
167 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
168 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
169
170 ASSERT_EQ(data(), 8);
171}
172
174TEST_F(InterOpTest, transition_from_static_thread_pool) {
175 const view_s_t data(Kokkos::view_alloc("data - shared space"));
176
177 const context_t esc{exec};
178
179 experimental::execution::static_thread_pool pool{1};
180
181 Tests::Utils::show_exec_space_id(exec, "exec");
182
183 auto chain =
184 stdexec::schedule(pool.get_scheduler())
185 | stdexec::then(
186 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
187 | stdexec::continues_on(esc.get_scheduler())
188 | stdexec::then(
189 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()});
190
191 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
192
193 const auto recorded_events = recorder_listener_t::record(
194 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
195 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
196 });
197
198 EXPECT_THAT(
199 recorded_events,
200 testing::ElementsAre(
201 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
202 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
203
204 ASSERT_EQ(data(), 8);
205}
206
208TEST_F(InterOpTest, transition_from_static_thread_pool_and_back) {
209 const view_s_t data(Kokkos::view_alloc("data - shared space"));
210
211 const context_t esc{exec};
212
213 experimental::execution::static_thread_pool pool{1};
214
215 Tests::Utils::show_exec_space_id(exec, "exec");
216
217 auto chain =
218 stdexec::schedule(pool.get_scheduler())
219 | stdexec::then(
220 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 0, .value = 4, .data = data.data()})
221 | stdexec::continues_on(esc.get_scheduler())
222 | stdexec::then(
223 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 4, .value = 4, .data = data.data()})
224 | stdexec::continues_on(pool.get_scheduler())
225 | stdexec::then(
226 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 8, .value = 4, .data = data.data()});
227
228 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
229
230 const auto recorded_events = recorder_listener_t::record(
231 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
232 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
233 });
234
235 EXPECT_THAT(
236 recorded_events,
237 testing::ElementsAre(
238 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
239 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from"))));
240
241 ASSERT_EQ(data(), 12);
242}
243
245TEST_F(InterOpTest, transition_to_static_thread_pool_and_back) {
246 const view_s_t data(Kokkos::view_alloc(exec, "data - shared space"));
247
248 const context_t esc{exec};
249
250 experimental::execution::static_thread_pool pool{1};
251
252 Tests::Utils::show_exec_space_id(exec, "exec");
253
254 auto chain =
255 stdexec::schedule(esc.get_scheduler())
256 | stdexec::then(
257 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 0, .value = 4, .data = data.data()})
258 | stdexec::continues_on(pool.get_scheduler())
259 | stdexec::then(
260 Tests::Utils::Functors::LoadCheckAdd<value_t, false>{.prev = 4, .value = 4, .data = data.data()})
261 | stdexec::continues_on(esc.get_scheduler())
262 | stdexec::then(
263 Tests::Utils::Functors::LoadCheckAdd<value_t, on_device>{.prev = 8, .value = 4, .data = data.data()});
264
265 ASSERT_EQ(data(), 0) << "Eager execution is not allowed.";
266
267 const auto recorded_events = recorder_listener_t::record(
268 [chain = std::move(chain)]() mutable { // NOLINT(performance-move-const-arg)
269 stdexec::sync_wait(std::move(chain)); // NOLINT(performance-move-const-arg)
270 });
271
272 EXPECT_THAT(
273 recorded_events,
274 testing::ElementsAre(
275 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
276 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "schedule_from")),
277 MATCHER_FOR_BEGIN_PFOR(exec, dispatch_label(exec, "then")),
278 MATCHER_FOR_BEGIN_FENCE(exec, dispatch_label(exec, "sync_wait"))));
279
280 ASSERT_EQ(data(), 12);
281}
282
283} // 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< BeginFenceEvent, BeginParallelForEvent > recorder_listener_t
Definition test_inter_op.cpp:35
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::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::on_device
constexpr bool on_device()
Definition kokkos.hpp:22
Kokkos::Execution::ExecutionSpaceContext::get_scheduler
auto get_scheduler() const noexcept -> ExecutionSpaceImpl::Scheduler< Exec >
Definition execution_space.hpp:136
Tests::Utils::ContextTest< Kokkos::Execution::ExecutionSpaceContext, Exec >::context_t
Kokkos::Execution::ExecutionSpaceContext< Exec > context_t
Definition context.hpp:25
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