Skip to content

Commit 2d3a576

Browse files
author
Fábio
authored
Add test for urEnqueueUSMPrefetch (#312)
1 parent d3c656d commit 2d3a576

File tree

3 files changed

+150
-10
lines changed

3 files changed

+150
-10
lines changed

‎test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ UUR_TEST_SUITE_P(urEnqueueUSMMemAdviseWithParamTest,
1111

1212
TEST_P(urEnqueueUSMMemAdviseWithParamTest, Success) {
1313
ur_event_handle_t advise_event = nullptr;
14-
ASSERT_SUCCESS(urEnqueueUSMMemAdvise(queue, ptr, sizeof(int),
14+
ASSERT_SUCCESS(urEnqueueUSMMemAdvise(queue, ptr, allocation_size,
1515
getParam(), &advise_event));
1616

1717
ASSERT_NE(advise_event, nullptr);
@@ -31,19 +31,19 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMMemAdviseTest);
3131

3232
TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullHandleQueue) {
3333
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
34-
urEnqueueUSMMemAdvise(nullptr, ptr, sizeof(int),
34+
urEnqueueUSMMemAdvise(nullptr, ptr, allocation_size,
3535
UR_MEM_ADVICE_DEFAULT, nullptr));
3636
}
3737

3838
TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullPointerMem) {
3939
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
40-
urEnqueueUSMMemAdvise(queue, nullptr, sizeof(int),
40+
urEnqueueUSMMemAdvise(queue, nullptr, allocation_size,
4141
UR_MEM_ADVICE_DEFAULT, nullptr));
4242
}
4343

4444
TEST_P(urEnqueueUSMMemAdviseTest, InvalidEnumeration) {
4545
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
46-
urEnqueueUSMMemAdvise(queue, ptr, sizeof(int),
46+
urEnqueueUSMMemAdvise(queue, ptr, allocation_size,
4747
UR_MEM_ADVICE_FORCE_UINT32,
4848
nullptr));
4949
}
@@ -56,6 +56,6 @@ TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeZero) {
5656

5757
TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeTooLarge) {
5858
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
59-
urEnqueueUSMMemAdvise(queue, ptr, sizeof(int) * 2,
59+
urEnqueueUSMMemAdvise(queue, ptr, allocation_size * 2,
6060
UR_MEM_ADVICE_DEFAULT, nullptr));
6161
}

‎test/conformance/enqueue/urEnqueueUSMPrefetch.cpp‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,135 @@
11
// Copyright (C) 2023 Intel Corporation
22
// SPDX-License-Identifier: MIT
3+
4+
#include <uur/fixtures.h>
5+
6+
using urEnqueueUSMPrefetchWithParamTest =
7+
uur::urUSMDeviceAllocTestWithParam<ur_usm_migration_flag_t>;
8+
9+
UUR_TEST_SUITE_P(urEnqueueUSMPrefetchWithParamTest,
10+
::testing::Values(UR_USM_MIGRATION_FLAG_DEFAULT),
11+
uur::deviceTestWithParamPrinter<ur_usm_migration_flag_t>);
12+
13+
TEST_P(urEnqueueUSMPrefetchWithParamTest, Success) {
14+
ur_event_handle_t prefetch_event = nullptr;
15+
ASSERT_SUCCESS(urEnqueueUSMPrefetch(queue, ptr, allocation_size,
16+
getParam(), 0, nullptr,
17+
&prefetch_event));
18+
19+
ASSERT_SUCCESS(urQueueFlush(queue));
20+
ASSERT_SUCCESS(urEventWait(1, &prefetch_event));
21+
22+
const auto event_status =
23+
uur::GetEventInfo<ur_event_status_t>(prefetch_event,
24+
UR_EVENT_INFO_COMMAND_EXECUTION_STATUS);
25+
ASSERT_TRUE(event_status.has_value());
26+
ASSERT_EQ(event_status.value(), UR_EVENT_STATUS_COMPLETE);
27+
ASSERT_SUCCESS(urEventRelease(prefetch_event));
28+
}
29+
30+
/**
31+
* Tests that urEnqueueUSMPrefetch() waits for its dependencies to finish before
32+
* executing.
33+
*/
34+
TEST_P(urEnqueueUSMPrefetchWithParamTest, CheckWaitEvent) {
35+
36+
ur_queue_handle_t memset_queue;
37+
ASSERT_SUCCESS(urQueueCreate(context, device, nullptr, &memset_queue));
38+
39+
size_t big_allocation = 65536;
40+
void *memset_ptr = nullptr;
41+
ASSERT_SUCCESS(
42+
urUSMDeviceAlloc(context, device, nullptr, nullptr,
43+
big_allocation, 0, &memset_ptr));
44+
45+
ur_event_handle_t memset_event;
46+
ASSERT_SUCCESS(
47+
urEnqueueUSMMemset(memset_queue, memset_ptr, 0, big_allocation, 0,
48+
nullptr, &memset_event));
49+
50+
ur_event_handle_t prefetch_event = nullptr;
51+
ASSERT_SUCCESS(urEnqueueUSMPrefetch(queue, ptr, allocation_size,
52+
getParam(), 1, &memset_event,
53+
&prefetch_event));
54+
55+
ASSERT_SUCCESS(urQueueFlush(queue));
56+
ASSERT_SUCCESS(urQueueFlush(memset_queue));
57+
ASSERT_SUCCESS(urEventWait(1, &prefetch_event));
58+
59+
const auto memset_status =
60+
uur::GetEventInfo<ur_event_status_t>(memset_event,
61+
UR_EVENT_INFO_COMMAND_EXECUTION_STATUS);
62+
ASSERT_TRUE(memset_status.has_value());
63+
ASSERT_EQ(memset_status.value(), UR_EVENT_STATUS_COMPLETE);
64+
65+
const auto event_status =
66+
uur::GetEventInfo<ur_event_status_t>(prefetch_event,
67+
UR_EVENT_INFO_COMMAND_EXECUTION_STATUS);
68+
ASSERT_TRUE(event_status.has_value());
69+
ASSERT_EQ(event_status.value(), UR_EVENT_STATUS_COMPLETE);
70+
71+
ASSERT_SUCCESS(urEventRelease(prefetch_event));
72+
ASSERT_SUCCESS(urEventRelease(memset_event));
73+
74+
ASSERT_SUCCESS(urUSMFree(context, memset_ptr));
75+
}
76+
77+
using urEnqueueUSMPrefetchTest = uur::urUSMDeviceAllocTest;
78+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMPrefetchTest);
79+
80+
TEST_P(urEnqueueUSMPrefetchTest, InvalidNullHandleQueue) {
81+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
82+
urEnqueueUSMPrefetch(nullptr, ptr, allocation_size,
83+
UR_USM_MIGRATION_FLAG_DEFAULT, 0,
84+
nullptr,
85+
nullptr));
86+
}
87+
88+
TEST_P(urEnqueueUSMPrefetchTest, InvalidNullPointerMem) {
89+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
90+
urEnqueueUSMPrefetch(queue, nullptr, allocation_size,
91+
UR_USM_MIGRATION_FLAG_DEFAULT, 0,
92+
nullptr,
93+
nullptr));
94+
}
95+
96+
TEST_P(urEnqueueUSMPrefetchTest, InvalidEnumeration) {
97+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
98+
urEnqueueUSMPrefetch(queue, ptr, allocation_size,
99+
UR_USM_MIGRATION_FLAG_FORCE_UINT32, 0,
100+
nullptr,
101+
nullptr));
102+
}
103+
104+
TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeZero) {
105+
ASSERT_EQ_RESULT(
106+
UR_RESULT_ERROR_INVALID_SIZE,
107+
urEnqueueUSMPrefetch(queue, ptr, 0, UR_USM_MIGRATION_FLAG_DEFAULT, 0,
108+
nullptr,
109+
nullptr));
110+
}
111+
112+
TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeTooLarge) {
113+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
114+
urEnqueueUSMPrefetch(queue, ptr, allocation_size * 2,
115+
UR_USM_MIGRATION_FLAG_DEFAULT, 0,
116+
nullptr,
117+
nullptr));
118+
}
119+
120+
TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) {
121+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
122+
urEnqueueUSMPrefetch(queue, ptr, allocation_size,
123+
UR_USM_MIGRATION_FLAG_DEFAULT, 1,
124+
nullptr,
125+
nullptr));
126+
127+
ur_event_handle_t validEvent;
128+
ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
129+
130+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
131+
urEnqueueUSMPrefetch(queue, ptr, allocation_size,
132+
UR_USM_MIGRATION_FLAG_DEFAULT, 0,
133+
&validEvent,
134+
nullptr));
135+
}

‎test/conformance/testing/uur/fixtures.h‎

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -343,10 +343,12 @@ struct urUSMDeviceAllocTest : urQueueTest {
343343
if (!device_usm.value()) {
344344
GTEST_SKIP() << "Device USM in not supported";
345345
}
346-
ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr, sizeof(int), 0, &ptr));
346+
ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr,
347+
allocation_size, 0, &ptr));
347348
ur_event_handle_t event = nullptr;
348349
ASSERT_SUCCESS(
349-
urEnqueueUSMMemset(queue, ptr, 0, sizeof(int), 0, nullptr, &event));
350+
urEnqueueUSMMemset(queue, ptr, 0, allocation_size, 0, nullptr,
351+
&event));
350352
EXPECT_SUCCESS(urQueueFlush(queue));
351353
ASSERT_SUCCESS(urEventWait(1, &event));
352354
EXPECT_SUCCESS(urEventRelease(event));
@@ -357,6 +359,7 @@ struct urUSMDeviceAllocTest : urQueueTest {
357359
uur::urQueueTest::TearDown();
358360
}
359361

362+
size_t allocation_size = sizeof(int);
360363
void *ptr = nullptr;
361364
};
362365

@@ -371,10 +374,13 @@ struct urUSMDeviceAllocTestWithParam : urQueueTestWithParam<T> {
371374
if (!device_sum.value()) {
372375
GTEST_SKIP() << "Device USM in not supported";
373376
}
374-
ASSERT_SUCCESS(urUSMDeviceAlloc(this->context, this->device, nullptr, nullptr, sizeof(int), 0, &ptr));
377+
ASSERT_SUCCESS(
378+
urUSMDeviceAlloc(this->context, this->device, nullptr, nullptr,
379+
allocation_size, 0, &ptr));
375380
ur_event_handle_t event = nullptr;
376-
ASSERT_SUCCESS(urEnqueueUSMMemset(this->queue, ptr, 0, sizeof(int), 0,
377-
nullptr, &event));
381+
ASSERT_SUCCESS(
382+
urEnqueueUSMMemset(this->queue, ptr, 0, allocation_size, 0,
383+
nullptr, &event));
378384
EXPECT_SUCCESS(urQueueFlush(this->queue));
379385
ASSERT_SUCCESS(urEventWait(1, &event));
380386
EXPECT_SUCCESS(urEventRelease(event));
@@ -385,6 +391,7 @@ struct urUSMDeviceAllocTestWithParam : urQueueTestWithParam<T> {
385391
uur::urQueueTestWithParam<T>::TearDown();
386392
}
387393

394+
size_t allocation_size = sizeof(int);
388395
void *ptr = nullptr;
389396
};
390397

0 commit comments

Comments
 (0)