Debian Codegraph @

offload/unittests/OffloadAPI/queue/olWaitEvents.cpp

raw
1 //===------- Offload API tests - olWaitEvents -----------------------------===//
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 olWaitEventsTest : OffloadProgramTest {
14 void SetUp() override {
15 RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUpWith("sequence"));
16 ASSERT_SUCCESS(
17 olGetSymbol(Program, "sequence", OL_SYMBOL_KIND_KERNEL, &Kernel));
18 LaunchArgs.Dimensions = 1;
19 LaunchArgs.GroupSize = {1, 1, 1};
20 LaunchArgs.NumGroups = {1, 1, 1};
21 LaunchArgs.DynSharedMemory = 0;
22 }
23
24 void TearDown() override {
25 RETURN_ON_FATAL_FAILURE(OffloadProgramTest::TearDown());
26 }
27
28 ol_symbol_handle_t Kernel = nullptr;
29 ol_kernel_launch_size_args_t LaunchArgs{};
30 };
31 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olWaitEventsTest);
32
33 TEST_P(olWaitEventsTest, Success) {
34 constexpr size_t NUM_KERNELS = 16;
35 ol_queue_handle_t Queues[NUM_KERNELS];
36 ol_event_handle_t Events[NUM_KERNELS];
37
38 void *Mem;
39 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
40 NUM_KERNELS * sizeof(uint32_t), &Mem));
41 struct {
42 uint32_t Idx;
43 void *Mem;
44 } Args{0, Mem};
45
46 for (size_t I = 0; I < NUM_KERNELS; I++) {
47 Args.Idx = I;
48
49 ASSERT_SUCCESS(olCreateQueue(Device, &Queues[I]));
50
51 if (I > 0)
52 ASSERT_SUCCESS(olWaitEvents(Queues[I], &Events[I - 1], 1));
53
54 ASSERT_SUCCESS(olLaunchKernel(Queues[I], Device, Kernel, &Args,
55 sizeof(Args), &LaunchArgs));
56 ASSERT_SUCCESS(olCreateEvent(Queues[I], &Events[I]));
57 }
58
59 ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
60
61 uint32_t *Data = (uint32_t *)Mem;
62 for (uint32_t i = 2; i < NUM_KERNELS; i++) {
63 ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
64 }
65 }
66
67 TEST_P(olWaitEventsTest, SuccessSingleQueue) {
68 constexpr size_t NUM_KERNELS = 16;
69 ol_queue_handle_t Queue;
70 ol_event_handle_t Events[NUM_KERNELS];
71
72 ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
73
74 void *Mem;
75 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
76 NUM_KERNELS * sizeof(uint32_t), &Mem));
77 struct {
78 uint32_t Idx;
79 void *Mem;
80 } Args{0, Mem};
81
82 for (size_t I = 0; I < NUM_KERNELS; I++) {
83 Args.Idx = I;
84
85 if (I > 0)
86 ASSERT_SUCCESS(olWaitEvents(Queue, &Events[I - 1], 1));
87
88 ASSERT_SUCCESS(olLaunchKernel(Queue, Device, Kernel, &Args, sizeof(Args),
89 &LaunchArgs));
90 ASSERT_SUCCESS(olCreateEvent(Queue, &Events[I]));
91 }
92
93 ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
94
95 uint32_t *Data = (uint32_t *)Mem;
96 for (uint32_t i = 2; i < NUM_KERNELS; i++) {
97 ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
98 }
99 }
100
101 TEST_P(olWaitEventsTest, SuccessMultipleEvents) {
102 constexpr size_t NUM_KERNELS = 16;
103 ol_queue_handle_t Queues[NUM_KERNELS];
104 ol_event_handle_t Events[NUM_KERNELS];
105
106 void *Mem;
107 ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED,
108 NUM_KERNELS * sizeof(uint32_t), &Mem));
109 struct {
110 uint32_t Idx;
111 void *Mem;
112 } Args{0, Mem};
113
114 for (size_t I = 0; I < NUM_KERNELS; I++) {
115 Args.Idx = I;
116
117 ASSERT_SUCCESS(olCreateQueue(Device, &Queues[I]));
118
119 if (I > 0)
120 ASSERT_SUCCESS(olWaitEvents(Queues[I], Events, I));
121
122 ASSERT_SUCCESS(olLaunchKernel(Queues[I], Device, Kernel, &Args,
123 sizeof(Args), &LaunchArgs));
124 ASSERT_SUCCESS(olCreateEvent(Queues[I], &Events[I]));
125 }
126
127 ASSERT_SUCCESS(olSyncEvent(Events[NUM_KERNELS - 1]));
128
129 uint32_t *Data = (uint32_t *)Mem;
130 for (uint32_t i = 2; i < NUM_KERNELS; i++) {
131 ASSERT_EQ(Data[i], Data[i - 1] + Data[i - 2]);
132 }
133 }
134
135 TEST_P(olWaitEventsTest, InvalidNullQueue) {
136 ol_event_handle_t Event;
137 ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olWaitEvents(nullptr, &Event, 1));
138 }
139
140 TEST_P(olWaitEventsTest, InvalidNullEvent) {
141 ol_queue_handle_t Queue;
142 ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
143 ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olWaitEvents(Queue, nullptr, 1));
144 }
145
146 TEST_P(olWaitEventsTest, InvalidNullInnerEvent) {
147 ol_queue_handle_t Queue;
148 ASSERT_SUCCESS(olCreateQueue(Device, &Queue));
149 ol_event_handle_t Event = nullptr;
150 ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olWaitEvents(Queue, &Event, 1));
151 }