Debian Codegraph @

offload/unittests/OffloadAPI/kernel/olLaunchKernel.cpp

raw
1 //===------- Offload API tests - olLaunchKernel --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "../common/Fixtures.hpp"
10 #include <OffloadAPI.h>
11 #include <gtest/gtest.h>
12
13 struct LaunchKernelTestBase : OffloadQueueTest {
14 void SetUpProgram(const char *program) {
15 RETURN_ON_FATAL_FAILURE(OffloadQueueTest::SetUp());
16 ASSERT_TRUE(TestEnvironment::loadDeviceBinary(program, Device, DeviceBin));
17 ASSERT_GE(DeviceBin->getBufferSize(), 0lu);
18 ASSERT_SUCCESS(olCreateProgram(Device, DeviceBin->getBufferStart(),
19 DeviceBin->getBufferSize(), &Program));
20
21 LaunchArgs.Dimensions = 1;
22 LaunchArgs.GroupSize = {64, 1, 1};
23 LaunchArgs.NumGroups = {1, 1, 1};
24
25 LaunchArgs.DynSharedMemory = 0;
26 }
27
28 void TearDown() override {
29 if (Program) {
30 olDestroyProgram(Program);
31 }
32 RETURN_ON_FATAL_FAILURE(OffloadQueueTest::TearDown());
33 }
34
35 std::unique_ptr<llvm::MemoryBuffer> DeviceBin;
36 ol_program_handle_t Program = nullptr;
37 ol_kernel_launch_size_args_t LaunchArgs{};
38 };
39
40 struct LaunchSingleKernelTestBase : LaunchKernelTestBase {
41 void SetUpKernel(const char *kernel) {
42 RETURN_ON_FATAL_FAILURE(SetUpProgram(kernel));
43 ASSERT_SUCCESS(
44 olGetSymbol(Program, kernel, OL_SYMBOL_KIND_KERNEL, &Kernel));
45 }
46
47 ol_symbol_handle_t Kernel = nullptr;
48 };
49
50 #define KERNEL_TEST(NAME, KERNEL) \
51 struct olLaunchKernel##NAME##Test : LaunchSingleKernelTestBase { \
52 void SetUp() override { SetUpKernel(#KERNEL); } \
53 }; \
54 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olLaunchKernel##NAME##Test);
55
56 KERNEL_TEST(Foo, foo)
57 KERNEL_TEST(NoArgs, noargs)
58 KERNEL_TEST(MultiArgs, multiargs)
59 KERNEL_TEST(Byte, byte)
60 KERNEL_TEST(LocalMem, localmem)
61 KERNEL_TEST(LocalMemReduction, localmem_reduction)
62 KERNEL_TEST(LocalMemStatic, localmem_static)
63 KERNEL_TEST(GlobalCtor, global_ctor)
64 KERNEL_TEST(GlobalDtor, global_dtor)
65
66 struct LaunchMultipleKernelTestBase : LaunchKernelTestBase {
67 void SetUpKernels(const char *program, std::vector<const char *> kernels) {
68 RETURN_ON_FATAL_FAILURE(SetUpProgram(program));
69
70 Kernels.resize(kernels.size());
71 size_t I = 0;
72 for (auto K : kernels)
73 ASSERT_SUCCESS(
74 olGetSymbol(Program, K, OL_SYMBOL_KIND_KERNEL, &Kernels[I++]));
75 }
76
77 std::vector<ol_symbol_handle_t> Kernels;
78 };
79
80 #define KERNEL_MULTI_TEST(NAME, PROGRAM, ...) \
81 struct olLaunchKernel##NAME##Test : LaunchMultipleKernelTestBase { \
82 void SetUp() override { SetUpKernels(#PROGRAM, {__VA_ARGS__}); } \
83 }; \
84 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olLaunchKernel##NAME##Test);
85
86 KERNEL_MULTI_TEST(Global, global, "write", "read")
87
88 TEST_P(olLaunchKernelFooTest, Success) {
89 void *Mem;
90 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
91 LaunchArgs.GroupSize.x * sizeof(uint32_t), &Mem));
92 struct {
93 void *Mem;
94 } Args{Mem};
95
96 ASSERT_SUCCESS(
97 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
98
99 ASSERT_SUCCESS(olSyncQueue(Queue));
100
101 uint32_t *Data = (uint32_t *)Mem;
102 for (uint32_t i = 0; i < 64; i++) {
103 ASSERT_EQ(Data[i], i);
104 }
105
106 ASSERT_SUCCESS(olMemFree(Mem));
107 }
108
109 TEST_P(olLaunchKernelFooTest, SuccessThreaded) {
110 threadify([&](size_t) {
111 void *Mem;
112 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
113 LaunchArgs.GroupSize.x * sizeof(uint32_t), &Mem));
114 struct {
115 void *Mem;
116 } Args{Mem};
117
118 ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
119 &LaunchArgs));
120
121 ASSERT_SUCCESS(olSyncQueue(Queue));
122
123 uint32_t *Data = (uint32_t *)Mem;
124 for (uint32_t i = 0; i < 64; i++) {
125 ASSERT_EQ(Data[i], i);
126 }
127
128 ASSERT_SUCCESS(olMemFree(Mem));
129 });
130 }
131
132 TEST_P(olLaunchKernelNoArgsTest, Success) {
133 ASSERT_SUCCESS(
134 olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs));
135
136 ASSERT_SUCCESS(olSyncQueue(Queue));
137 }
138
139 TEST_P(olLaunchKernelMultiArgsTest, Success) {
140 struct {
141 char A;
142 int *B;
143 short C;
144 } Args{0, nullptr, 0};
145
146 ASSERT_SUCCESS(
147 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
148
149 ASSERT_SUCCESS(olSyncQueue(Queue));
150 }
151
152 TEST_P(olLaunchKernelFooTest, SuccessSynchronous) {
153 void *Mem;
154 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
155 LaunchArgs.GroupSize.x * sizeof(uint32_t), &Mem));
156
157 struct {
158 void *Mem;
159 } Args{Mem};
160
161 ASSERT_SUCCESS(olLaunchKernel(nullptr, Device, Kernel, &Args, sizeof(Args),
162 &LaunchArgs));
163
164 uint32_t *Data = (uint32_t *)Mem;
165 for (uint32_t i = 0; i < 64; i++) {
166 ASSERT_EQ(Data[i], i);
167 }
168
169 ASSERT_SUCCESS(olMemFree(Mem));
170 }
171
172 TEST_P(olLaunchKernelLocalMemTest, Success) {
173 LaunchArgs.NumGroups.x = 4;
174 LaunchArgs.DynSharedMemory = 64 * sizeof(uint32_t);
175
176 void *Mem;
177 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
178 LaunchArgs.GroupSize.x * LaunchArgs.NumGroups.x *
179 sizeof(uint32_t),
180 &Mem));
181 struct {
182 void *Mem;
183 } Args{Mem};
184
185 ASSERT_SUCCESS(
186 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
187
188 ASSERT_SUCCESS(olSyncQueue(Queue));
189
190 uint32_t *Data = (uint32_t *)Mem;
191 for (uint32_t i = 0; i < LaunchArgs.GroupSize.x * LaunchArgs.NumGroups.x; i++)
192 ASSERT_EQ(Data[i], (i % 64) * 2);
193
194 ASSERT_SUCCESS(olMemFree(Mem));
195 }
196
197 TEST_P(olLaunchKernelLocalMemReductionTest, Success) {
198 LaunchArgs.NumGroups.x = 4;
199 LaunchArgs.DynSharedMemory = 64 * sizeof(uint32_t);
200
201 void *Mem;
202 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
203 LaunchArgs.NumGroups.x * sizeof(uint32_t), &Mem));
204 struct {
205 void *Mem;
206 } Args{Mem};
207
208 ASSERT_SUCCESS(
209 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
210
211 ASSERT_SUCCESS(olSyncQueue(Queue));
212
213 uint32_t *Data = (uint32_t *)Mem;
214 for (uint32_t i = 0; i < LaunchArgs.NumGroups.x; i++)
215 ASSERT_EQ(Data[i], 2 * LaunchArgs.GroupSize.x);
216
217 ASSERT_SUCCESS(olMemFree(Mem));
218 }
219
220 TEST_P(olLaunchKernelLocalMemStaticTest, Success) {
221 LaunchArgs.NumGroups.x = 4;
222 LaunchArgs.DynSharedMemory = 0;
223
224 void *Mem;
225 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
226 LaunchArgs.NumGroups.x * sizeof(uint32_t), &Mem));
227 struct {
228 void *Mem;
229 } Args{Mem};
230
231 ASSERT_SUCCESS(
232 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
233
234 ASSERT_SUCCESS(olSyncQueue(Queue));
235
236 uint32_t *Data = (uint32_t *)Mem;
237 for (uint32_t i = 0; i < LaunchArgs.NumGroups.x; i++)
238 ASSERT_EQ(Data[i], 2 * LaunchArgs.GroupSize.x);
239
240 ASSERT_SUCCESS(olMemFree(Mem));
241 }
242
243 TEST_P(olLaunchKernelGlobalTest, Success) {
244 void *Mem;
245 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
246 LaunchArgs.GroupSize.x * sizeof(uint32_t), &Mem));
247 struct {
248 void *Mem;
249 } Args{Mem};
250
251 ASSERT_SUCCESS(
252 olLaunchKernel(Queue, Device, Kernels[0], nullptr, 0, &LaunchArgs));
253 ASSERT_SUCCESS(olSyncQueue(Queue));
254 ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernels[1], &Args, sizeof(Args),
255 &LaunchArgs));
256 ASSERT_SUCCESS(olSyncQueue(Queue));
257
258 uint32_t *Data = (uint32_t *)Mem;
259 for (uint32_t i = 0; i < 64; i++) {
260 ASSERT_EQ(Data[i], i * 2);
261 }
262
263 ASSERT_SUCCESS(olMemFree(Mem));
264 }
265
266 TEST_P(olLaunchKernelGlobalTest, InvalidNotAKernel) {
267 ol_symbol_handle_t Global = nullptr;
268 ASSERT_SUCCESS(
269 olGetSymbol(Program, "global", OL_SYMBOL_KIND_GLOBAL_VARIABLE, &Global));
270 ASSERT_ERROR(OL_ERRC_SYMBOL_KIND,
271 olLaunchKernel(Queue, Device, Global, nullptr, 0, &LaunchArgs));
272 }
273
274 TEST_P(olLaunchKernelGlobalCtorTest, Success) {
275 void *Mem;
276 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
277 LaunchArgs.GroupSize.x * sizeof(uint32_t), &Mem));
278 struct {
279 void *Mem;
280 } Args{Mem};
281
282 ASSERT_SUCCESS(
283 olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args), &LaunchArgs));
284 ASSERT_SUCCESS(olSyncQueue(Queue));
285
286 uint32_t *Data = (uint32_t *)Mem;
287 for (uint32_t i = 0; i < 64; i++) {
288 ASSERT_EQ(Data[i], i + 100);
289 }
290
291 ASSERT_SUCCESS(olMemFree(Mem));
292 }
293
294 TEST_P(olLaunchKernelGlobalDtorTest, Success) {
295 // TODO: We can't inspect the result of a destructor yet, once we
296 // find/implement a way, update this test. For now we just check that nothing
297 // crashes
298 ASSERT_SUCCESS(
299 olLaunchKernel(Queue, Device, Kernel, nullptr, 0, &LaunchArgs));
300 ASSERT_SUCCESS(olSyncQueue(Queue));
301 }