Skip to content

Commit 3839c4c

Browse files
RossBruntonRossBrunton
authored
[UR][CTS] Update USM tests to prevent crashes in offload adapter (#18891)
The CTS tests for USM uses `EXPECT_SUCCESS` when it should really be `ASSERT_SUCCESS` (the latter returns, which looks to have been the intended behaviour). In addition, some tests have been marked with a new `uur::Offload` known failure, as they cause liboffload to hit an abort.
1 parent bd74453 commit 3839c4c

File tree

8 files changed

+58
-44
lines changed

8 files changed

+58
-44
lines changed

‎unified-runtime/test/conformance/testing/include/uur/known_failure.h

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,11 @@ struct NativeCPU : Matcher {
9090
: Matcher(1, UR_BACKEND_NATIVE_CPU, {il.begin(), il.end()}) {}
9191
};
9292

93+
struct Offload : Matcher {
94+
Offload(std::initializer_list<std::string> il)
95+
: Matcher(1, UR_BACKEND_OFFLOAD, {il.begin(), il.end()}) {}
96+
};
97+
9398
inline bool isKnownFailureOn(ur_adapter_handle_t adapter,
9499
const std::vector<Matcher> &matchers) {
95100
auto adapterInfo = detail::getAdapterInfo(adapter);

‎unified-runtime/test/conformance/usm/urUSMDeviceAlloc.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -42,11 +42,11 @@ TEST_P(urUSMDeviceAllocTest, Success) {
4242
uint8_t pattern = 0;
4343
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
4444
allocation_size, 0, nullptr, &event));
45-
EXPECT_SUCCESS(urQueueFlush(queue));
45+
ASSERT_SUCCESS(urQueueFlush(queue));
4646
ASSERT_SUCCESS(urEventWait(1, &event));
4747

4848
ASSERT_SUCCESS(urUSMFree(context, ptr));
49-
EXPECT_SUCCESS(urEventRelease(event));
49+
ASSERT_SUCCESS(urEventRelease(event));
5050
}
5151

5252
TEST_P(urUSMDeviceAllocTest, SuccessWithDescriptors) {
@@ -70,7 +70,7 @@ TEST_P(urUSMDeviceAllocTest, SuccessWithDescriptors) {
7070
ASSERT_SUCCESS(urEventWait(1, &event));
7171

7272
ASSERT_SUCCESS(urUSMFree(context, ptr));
73-
EXPECT_SUCCESS(urEventRelease(event));
73+
ASSERT_SUCCESS(urEventRelease(event));
7474
}
7575

7676
TEST_P(urUSMDeviceAllocTest, InvalidNullHandleContext) {
@@ -160,5 +160,5 @@ TEST_P(urUSMDeviceAllocAlignmentTest, SuccessAlignedAllocations) {
160160
ASSERT_SUCCESS(urEventWait(1, &event));
161161

162162
ASSERT_SUCCESS(urUSMFree(context, ptr));
163-
EXPECT_SUCCESS(urEventRelease(event));
163+
ASSERT_SUCCESS(urEventRelease(event));
164164
}

‎unified-runtime/test/conformance/usm/urUSMFree.cpp

Lines changed: 27 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -28,10 +28,10 @@ TEST_P(urUSMFreeTest, SuccessDeviceAlloc) {
2828
ur_event_handle_t event = nullptr;
2929

3030
uint8_t pattern = 0;
31-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
31+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
3232
allocation_size, 0, nullptr, &event));
33-
EXPECT_SUCCESS(urQueueFlush(queue));
34-
EXPECT_SUCCESS(urEventWait(1, &event));
33+
ASSERT_SUCCESS(urQueueFlush(queue));
34+
ASSERT_SUCCESS(urEventWait(1, &event));
3535

3636
ASSERT_SUCCESS(urUSMFree(context, ptr));
3737
ASSERT_SUCCESS(urEventRelease(event));
@@ -53,10 +53,10 @@ TEST_P(urUSMFreeTest, SuccessHostAlloc) {
5353

5454
ur_event_handle_t event = nullptr;
5555
uint8_t pattern = 0;
56-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
56+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
5757
allocation_size, 0, nullptr, &event));
58-
EXPECT_SUCCESS(urQueueFlush(queue));
59-
EXPECT_SUCCESS(urEventWait(1, &event));
58+
ASSERT_SUCCESS(urQueueFlush(queue));
59+
ASSERT_SUCCESS(urEventWait(1, &event));
6060

6161
ASSERT_SUCCESS(urUSMFree(context, ptr));
6262
ASSERT_SUCCESS(urEventRelease(event));
@@ -84,10 +84,10 @@ TEST_P(urUSMFreeTest, SuccessSharedAlloc) {
8484

8585
ur_event_handle_t event = nullptr;
8686
uint8_t pattern = 0;
87-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
87+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
8888
allocation_size, 0, nullptr, &event));
89-
EXPECT_SUCCESS(urQueueFlush(queue));
90-
EXPECT_SUCCESS(urEventWait(1, &event));
89+
ASSERT_SUCCESS(urQueueFlush(queue));
90+
ASSERT_SUCCESS(urEventWait(1, &event));
9191

9292
ASSERT_SUCCESS(urUSMFree(context, ptr));
9393
ASSERT_SUCCESS(urEventRelease(event));
@@ -121,6 +121,9 @@ struct urUSMFreeDuringExecutionTest : uur::urKernelExecutionTest {
121121
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urUSMFreeDuringExecutionTest);
122122

123123
TEST_P(urUSMFreeDuringExecutionTest, SuccessHost) {
124+
// Causes an abort in liboffload
125+
UUR_KNOWN_FAILURE_ON(uur::Offload{});
126+
124127
ur_device_usm_access_capability_flags_t host_usm_flags = 0;
125128
ASSERT_SUCCESS(uur::GetDeviceUSMHostSupport(device, host_usm_flags));
126129
if (!(host_usm_flags & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS)) {
@@ -131,16 +134,19 @@ TEST_P(urUSMFreeDuringExecutionTest, SuccessHost) {
131134
urUSMHostAlloc(context, nullptr, nullptr, allocation_size, &allocation));
132135
ASSERT_NE(allocation, nullptr);
133136

134-
EXPECT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
135-
EXPECT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
136-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
137+
ASSERT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
138+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
139+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
137140
&array_size, nullptr, 0, nullptr, 0,
138141
nullptr, nullptr));
139142
ASSERT_SUCCESS(urUSMFree(context, allocation));
140143
ASSERT_SUCCESS(urQueueFinish(queue));
141144
}
142145

143146
TEST_P(urUSMFreeDuringExecutionTest, SuccessDevice) {
147+
// Causes an abort in liboffload
148+
UUR_KNOWN_FAILURE_ON(uur::Offload{});
149+
144150
ur_device_usm_access_capability_flags_t device_usm_flags = 0;
145151
ASSERT_SUCCESS(uur::GetDeviceUSMDeviceSupport(device, device_usm_flags));
146152
if (!(device_usm_flags & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS)) {
@@ -151,17 +157,20 @@ TEST_P(urUSMFreeDuringExecutionTest, SuccessDevice) {
151157
allocation_size, &allocation));
152158
ASSERT_NE(allocation, nullptr);
153159

154-
EXPECT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
155-
EXPECT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
160+
ASSERT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
161+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
156162

157-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
163+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
158164
&array_size, nullptr, 0, nullptr, 0,
159165
nullptr, nullptr));
160166
ASSERT_SUCCESS(urUSMFree(context, allocation));
161167
ASSERT_SUCCESS(urQueueFinish(queue));
162168
}
163169

164170
TEST_P(urUSMFreeDuringExecutionTest, SuccessShared) {
171+
// Causes an abort in liboffload
172+
UUR_KNOWN_FAILURE_ON(uur::Offload{});
173+
165174
ur_device_usm_access_capability_flags_t shared_usm_flags = 0;
166175
ASSERT_SUCCESS(
167176
uur::GetDeviceUSMSingleSharedSupport(device, shared_usm_flags));
@@ -173,9 +182,9 @@ TEST_P(urUSMFreeDuringExecutionTest, SuccessShared) {
173182
allocation_size, &allocation));
174183
ASSERT_NE(allocation, nullptr);
175184

176-
EXPECT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
177-
EXPECT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
178-
EXPECT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
185+
ASSERT_SUCCESS(urKernelSetArgPointer(kernel, 0, nullptr, allocation));
186+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, 1, sizeof(data), nullptr, &data));
187+
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 1, &wg_offset,
179188
&array_size, nullptr, 0, nullptr, 0,
180189
nullptr, nullptr));
181190
ASSERT_SUCCESS(urUSMFree(context, allocation));

‎unified-runtime/test/conformance/usm/urUSMHostAlloc.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -45,18 +45,18 @@ TEST_P(urUSMHostAllocTest, Success) {
4545
uint8_t pattern = 0;
4646
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
4747
allocation_size, 0, nullptr, &event));
48-
EXPECT_SUCCESS(urQueueFlush(queue));
48+
ASSERT_SUCCESS(urQueueFlush(queue));
4949
ASSERT_SUCCESS(urEventWait(1, &event));
50-
EXPECT_SUCCESS(urEventRelease(event));
50+
ASSERT_SUCCESS(urEventRelease(event));
5151
ASSERT_EQ(*reinterpret_cast<int *>(ptr), 0);
5252

5353
// Set 1, in all bytes of int
5454
pattern = 1;
5555
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
5656
allocation_size, 0, nullptr, &event));
57-
EXPECT_SUCCESS(urQueueFlush(queue));
57+
ASSERT_SUCCESS(urQueueFlush(queue));
5858
ASSERT_SUCCESS(urEventWait(1, &event));
59-
EXPECT_SUCCESS(urEventRelease(event));
59+
ASSERT_SUCCESS(urEventRelease(event));
6060

6161
// replicate it on host
6262
int set_data = 0;
@@ -87,7 +87,7 @@ TEST_P(urUSMHostAllocTest, SuccessWithDescriptors) {
8787
ASSERT_SUCCESS(urEventWait(1, &event));
8888

8989
ASSERT_SUCCESS(urUSMFree(context, ptr));
90-
EXPECT_SUCCESS(urEventRelease(event));
90+
ASSERT_SUCCESS(urEventRelease(event));
9191
}
9292

9393
TEST_P(urUSMHostAllocTest, InvalidNullHandleContext) {
@@ -166,5 +166,5 @@ TEST_P(urUSMHostAllocAlignmentTest, SuccessAlignedAllocations) {
166166
ASSERT_SUCCESS(urEventWait(1, &event));
167167

168168
ASSERT_SUCCESS(urUSMFree(context, ptr));
169-
EXPECT_SUCCESS(urEventRelease(event));
169+
ASSERT_SUCCESS(urEventRelease(event));
170170
}

‎unified-runtime/test/conformance/usm/urUSMPoolCreate.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ TEST_P(urUSMPoolCreateTest, Success) {
2525
ur_usm_pool_handle_t pool = nullptr;
2626
ASSERT_SUCCESS(urUSMPoolCreate(context, &pool_desc, &pool));
2727
ASSERT_NE(pool, nullptr);
28-
EXPECT_SUCCESS(urUSMPoolRelease(pool));
28+
ASSERT_SUCCESS(urUSMPoolRelease(pool));
2929
}
3030

3131
TEST_P(urUSMPoolCreateTest, SuccessWithFlag) {
@@ -36,7 +36,7 @@ TEST_P(urUSMPoolCreateTest, SuccessWithFlag) {
3636
ur_usm_pool_handle_t pool = nullptr;
3737
ASSERT_SUCCESS(urUSMPoolCreate(context, &pool_desc, &pool));
3838
ASSERT_NE(pool, nullptr);
39-
EXPECT_SUCCESS(urUSMPoolRelease(pool));
39+
ASSERT_SUCCESS(urUSMPoolRelease(pool));
4040
}
4141

4242
TEST_P(urUSMPoolCreateTest, InvalidNullHandleContext) {

‎unified-runtime/test/conformance/usm/urUSMPoolRelease.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ TEST_P(urUSMPoolReleaseTest, Success) {
2020

2121
ASSERT_LT(prevRefCount, refCount);
2222

23-
EXPECT_SUCCESS(urUSMPoolRelease(pool));
23+
ASSERT_SUCCESS(urUSMPoolRelease(pool));
2424

2525
uint32_t afterRefCount = 0;
2626
ASSERT_SUCCESS(uur::GetObjectReferenceCount(pool, afterRefCount));

‎unified-runtime/test/conformance/usm/urUSMPoolRetain.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ TEST_P(urUSMPoolRetainTest, Success) {
2121

2222
ASSERT_LT(prevRefCount, refCount);
2323

24-
EXPECT_SUCCESS(urUSMPoolRelease(pool));
24+
ASSERT_SUCCESS(urUSMPoolRelease(pool));
2525

2626
uint32_t afterRefCount = 0;
2727
ASSERT_SUCCESS(uur::GetObjectReferenceCount(pool, afterRefCount));

‎unified-runtime/test/conformance/usm/urUSMSharedAlloc.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -46,12 +46,12 @@ TEST_P(urUSMSharedAllocTest, Success) {
4646

4747
ur_event_handle_t event = nullptr;
4848
uint8_t pattern = 0;
49-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
49+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
5050
allocation_size, 0, nullptr, &event));
51-
EXPECT_SUCCESS(urEventWait(1, &event));
51+
ASSERT_SUCCESS(urEventWait(1, &event));
5252

5353
ASSERT_SUCCESS(urUSMFree(context, ptr));
54-
EXPECT_SUCCESS(urEventRelease(event));
54+
ASSERT_SUCCESS(urEventRelease(event));
5555
}
5656

5757
TEST_P(urUSMSharedAllocTest, SuccessWithDescriptors) {
@@ -74,12 +74,12 @@ TEST_P(urUSMSharedAllocTest, SuccessWithDescriptors) {
7474

7575
ur_event_handle_t event = nullptr;
7676
uint8_t pattern = 0;
77-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
77+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
7878
allocation_size, 0, nullptr, &event));
79-
EXPECT_SUCCESS(urEventWait(1, &event));
79+
ASSERT_SUCCESS(urEventWait(1, &event));
8080

8181
ASSERT_SUCCESS(urUSMFree(context, ptr));
82-
EXPECT_SUCCESS(urEventRelease(event));
82+
ASSERT_SUCCESS(urEventRelease(event));
8383
}
8484

8585
TEST_P(urUSMSharedAllocTest, SuccessWithMultipleAdvices) {
@@ -97,12 +97,12 @@ TEST_P(urUSMSharedAllocTest, SuccessWithMultipleAdvices) {
9797

9898
ur_event_handle_t event = nullptr;
9999
uint8_t pattern = 0;
100-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
100+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
101101
allocation_size, 0, nullptr, &event));
102-
EXPECT_SUCCESS(urEventWait(1, &event));
102+
ASSERT_SUCCESS(urEventWait(1, &event));
103103

104104
ASSERT_SUCCESS(urUSMFree(context, ptr));
105-
EXPECT_SUCCESS(urEventRelease(event));
105+
ASSERT_SUCCESS(urEventRelease(event));
106106
}
107107

108108
TEST_P(urUSMSharedAllocTest, InvalidNullHandleContext) {
@@ -192,10 +192,10 @@ TEST_P(urUSMSharedAllocAlignmentTest, SuccessAlignedAllocations) {
192192

193193
ur_event_handle_t event = nullptr;
194194
uint8_t pattern = 0;
195-
EXPECT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
195+
ASSERT_SUCCESS(urEnqueueUSMFill(queue, ptr, sizeof(pattern), &pattern,
196196
allocation_size, 0, nullptr, &event));
197-
EXPECT_SUCCESS(urEventWait(1, &event));
197+
ASSERT_SUCCESS(urEventWait(1, &event));
198198

199199
ASSERT_SUCCESS(urUSMFree(context, ptr));
200-
EXPECT_SUCCESS(urEventRelease(event));
200+
ASSERT_SUCCESS(urEventRelease(event));
201201
}

0 commit comments

Comments
 (0)