|
1 |
| -// Copyright (C) 2023 Intel Corporation |
| 1 | +// Copyright (C) 2024 Intel Corporation |
2 | 2 | // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
|
3 | 3 | // See LICENSE.TXT
|
4 | 4 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
@@ -36,6 +36,32 @@ struct urEnqueueEventsWaitWithBarrierTest : uur::urMultiQueueTest {
|
36 | 36 |
|
37 | 37 | UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueEventsWaitWithBarrierTest);
|
38 | 38 |
|
| 39 | +struct urEnqueueEventsWaitWithBarrierOrderingTest : uur::urProgramTest { |
| 40 | + void SetUp() override { |
| 41 | + program_name = "sequence"; |
| 42 | + UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::SetUp()); |
| 43 | + ASSERT_SUCCESS(urProgramBuild(context, program, nullptr)); |
| 44 | + |
| 45 | + ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, |
| 46 | + sizeof(uint32_t), nullptr, &buffer)); |
| 47 | + |
| 48 | + auto entry_points = |
| 49 | + uur::KernelsEnvironment::instance->GetEntryPointNames(program_name); |
| 50 | + std::cout << entry_points[0]; |
| 51 | + |
| 52 | + ASSERT_SUCCESS(urKernelCreate(program, "_ZTS3Add", &add_kernel)); |
| 53 | + ASSERT_SUCCESS(urKernelCreate(program, "_ZTS3Mul", &mul_kernel)); |
| 54 | + } |
| 55 | + |
| 56 | + void TearDown() override { uur::urProgramTest::TearDown(); } |
| 57 | + |
| 58 | + ur_kernel_handle_t add_kernel; |
| 59 | + ur_kernel_handle_t mul_kernel; |
| 60 | + ur_mem_handle_t buffer = nullptr; |
| 61 | +}; |
| 62 | + |
| 63 | +UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueEventsWaitWithBarrierOrderingTest); |
| 64 | + |
39 | 65 | TEST_P(urEnqueueEventsWaitWithBarrierTest, Success) {
|
40 | 66 | ur_event_handle_t event1 = nullptr;
|
41 | 67 | ur_event_handle_t waitEvent = nullptr;
|
@@ -97,3 +123,129 @@ TEST_P(urEnqueueEventsWaitWithBarrierTest, InvalidNullPtrEventWaitList) {
|
97 | 123 |
|
98 | 124 | ASSERT_SUCCESS(urEventRelease(validEvent));
|
99 | 125 | }
|
| 126 | + |
| 127 | +TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest, |
| 128 | + SuccessEventDependenciesBarrierOnly) { |
| 129 | + constexpr size_t offset = 0; |
| 130 | + constexpr size_t count = 1; |
| 131 | + ur_event_handle_t event; |
| 132 | + |
| 133 | + uur::KernelLaunchHelper addHelper(platform, context, add_kernel, queue); |
| 134 | + uur::KernelLaunchHelper mulHelper(platform, context, mul_kernel, queue); |
| 135 | + |
| 136 | + addHelper.SetBuffer1DArg(buffer, nullptr); |
| 137 | + mulHelper.SetBuffer1DArg(buffer, nullptr); |
| 138 | + |
| 139 | + for (size_t i = 0; i < 10; i++) { |
| 140 | + constexpr uint32_t ONE = 1; |
| 141 | + urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, |
| 142 | + 0, nullptr, &event); |
| 143 | + EXPECT_SUCCESS( |
| 144 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr)); |
| 145 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, |
| 146 | + &count, nullptr, 0, nullptr, |
| 147 | + &event)); |
| 148 | + EXPECT_SUCCESS( |
| 149 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr)); |
| 150 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, |
| 151 | + &count, nullptr, 0, nullptr, |
| 152 | + &event)); |
| 153 | + EXPECT_SUCCESS( |
| 154 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event, nullptr)); |
| 155 | + addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004); |
| 156 | + } |
| 157 | +} |
| 158 | + |
| 159 | +TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest, |
| 160 | + SuccessEventDependenciesLaunchOnly) { |
| 161 | + constexpr size_t offset = 0; |
| 162 | + constexpr size_t count = 1; |
| 163 | + ur_event_handle_t event; |
| 164 | + |
| 165 | + uur::KernelLaunchHelper addHelper(platform, context, add_kernel, queue); |
| 166 | + uur::KernelLaunchHelper mulHelper(platform, context, mul_kernel, queue); |
| 167 | + |
| 168 | + addHelper.SetBuffer1DArg(buffer, nullptr); |
| 169 | + mulHelper.SetBuffer1DArg(buffer, nullptr); |
| 170 | + |
| 171 | + for (size_t i = 0; i < 10; i++) { |
| 172 | + constexpr uint32_t ONE = 1; |
| 173 | + urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, |
| 174 | + 0, nullptr, nullptr); |
| 175 | + EXPECT_SUCCESS( |
| 176 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event)); |
| 177 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, |
| 178 | + &count, nullptr, 1, &event, |
| 179 | + nullptr)); |
| 180 | + EXPECT_SUCCESS( |
| 181 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event)); |
| 182 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, |
| 183 | + &count, nullptr, 1, &event, |
| 184 | + nullptr)); |
| 185 | + EXPECT_SUCCESS( |
| 186 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, &event)); |
| 187 | + addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004); |
| 188 | + } |
| 189 | +} |
| 190 | + |
| 191 | +TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest, SuccessEventDependencies) { |
| 192 | + constexpr size_t offset = 0; |
| 193 | + constexpr size_t count = 1; |
| 194 | + ur_event_handle_t event[6]; |
| 195 | + |
| 196 | + uur::KernelLaunchHelper addHelper(platform, context, add_kernel, queue); |
| 197 | + uur::KernelLaunchHelper mulHelper(platform, context, mul_kernel, queue); |
| 198 | + |
| 199 | + addHelper.SetBuffer1DArg(buffer, nullptr); |
| 200 | + mulHelper.SetBuffer1DArg(buffer, nullptr); |
| 201 | + |
| 202 | + for (size_t i = 0; i < 10; i++) { |
| 203 | + constexpr uint32_t ONE = 1; |
| 204 | + urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, |
| 205 | + 0, nullptr, &event[0]); |
| 206 | + EXPECT_SUCCESS( |
| 207 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event[0], &event[1])); |
| 208 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, |
| 209 | + &count, nullptr, 1, &event[1], |
| 210 | + &event[2])); |
| 211 | + EXPECT_SUCCESS( |
| 212 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event[2], &event[3])); |
| 213 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, |
| 214 | + &count, nullptr, 1, &event[3], |
| 215 | + &event[4])); |
| 216 | + EXPECT_SUCCESS( |
| 217 | + urEnqueueEventsWaitWithBarrier(queue, 1, &event[4], &event[5])); |
| 218 | + addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004); |
| 219 | + } |
| 220 | +} |
| 221 | + |
| 222 | +TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest, |
| 223 | + SuccessNonEventDependencies) { |
| 224 | + constexpr size_t offset = 0; |
| 225 | + constexpr size_t count = 1; |
| 226 | + |
| 227 | + uur::KernelLaunchHelper addHelper(platform, context, add_kernel, queue); |
| 228 | + uur::KernelLaunchHelper mulHelper(platform, context, mul_kernel, queue); |
| 229 | + |
| 230 | + addHelper.SetBuffer1DArg(buffer, nullptr); |
| 231 | + mulHelper.SetBuffer1DArg(buffer, nullptr); |
| 232 | + |
| 233 | + for (size_t i = 0; i < 10; i++) { |
| 234 | + constexpr uint32_t ONE = 1; |
| 235 | + urEnqueueMemBufferWrite(queue, buffer, true, 0, sizeof(uint32_t), &ONE, |
| 236 | + 0, nullptr, nullptr); |
| 237 | + EXPECT_SUCCESS( |
| 238 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr)); |
| 239 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, add_kernel, 1, &offset, |
| 240 | + &count, nullptr, 0, nullptr, |
| 241 | + nullptr)); |
| 242 | + EXPECT_SUCCESS( |
| 243 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr)); |
| 244 | + EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, mul_kernel, 1, &offset, |
| 245 | + &count, nullptr, 0, nullptr, |
| 246 | + nullptr)); |
| 247 | + EXPECT_SUCCESS( |
| 248 | + urEnqueueEventsWaitWithBarrier(queue, 0, nullptr, nullptr)); |
| 249 | + addHelper.ValidateBuffer(buffer, sizeof(uint32_t), 4004); |
| 250 | + } |
| 251 | +} |
0 commit comments