Skip to content

Commit 2352ec4

Browse files
kbenziekbenzie
authored
Merge pull request #1269 from npmiller/plugins-tests
[CTS] Initial port of old PI tests to UR CTS
2 parents 5b3750d + 6eb886e commit 2352ec4

File tree

4 files changed

+140
-21
lines changed

4 files changed

+140
-21
lines changed

‎test/conformance/enqueue/urEnqueueMemBufferMap.cpp‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,57 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
9999
}
100100
}
101101

102+
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
103+
const size_t memSize = sizeof(int);
104+
const int value = 20;
105+
106+
ur_mem_handle_t memObj;
107+
ASSERT_SUCCESS(urMemBufferCreate(
108+
context, UR_MEM_FLAG_READ_WRITE | UR_MEM_FLAG_ALLOC_HOST_POINTER,
109+
memSize, nullptr, &memObj));
110+
111+
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, true, 0, sizeof(int),
112+
&value, 0, nullptr, nullptr));
113+
114+
int *host_ptr = nullptr;
115+
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, memObj, true, UR_MAP_FLAG_READ,
116+
0, sizeof(int), 0, nullptr, nullptr,
117+
(void **)&host_ptr));
118+
119+
ASSERT_EQ(*host_ptr, value);
120+
ASSERT_SUCCESS(
121+
urEnqueueMemUnmap(queue, memObj, host_ptr, 0, nullptr, nullptr));
122+
123+
ASSERT_SUCCESS(urMemRelease(memObj));
124+
}
125+
126+
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
127+
const size_t memSize = sizeof(int);
128+
const int value = 30;
129+
130+
ur_mem_handle_t memObj;
131+
ASSERT_SUCCESS(urMemBufferCreate(
132+
context, UR_MEM_FLAG_READ_WRITE | UR_MEM_FLAG_ALLOC_HOST_POINTER,
133+
memSize, nullptr, &memObj));
134+
135+
int *host_ptr = nullptr;
136+
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, memObj, true, UR_MAP_FLAG_WRITE,
137+
0, sizeof(int), 0, nullptr, nullptr,
138+
(void **)&host_ptr));
139+
140+
*host_ptr = value;
141+
142+
ASSERT_SUCCESS(
143+
urEnqueueMemUnmap(queue, memObj, host_ptr, 0, nullptr, nullptr));
144+
145+
int read_value = 0;
146+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, true, 0, sizeof(int),
147+
&read_value, 0, nullptr, nullptr));
148+
149+
ASSERT_EQ(read_value, value);
150+
ASSERT_SUCCESS(urMemRelease(memObj));
151+
}
152+
102153
TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
103154
const std::vector<uint32_t> input(count, 0);
104155
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,

‎test/conformance/enqueue/urEnqueueMemBufferRead.cpp‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,63 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidSize) {
6565
nullptr));
6666
}
6767

68+
TEST_P(urEnqueueMemBufferReadTest, Blocking) {
69+
constexpr const size_t memSize = 10u;
70+
constexpr const size_t bytes = memSize * sizeof(int);
71+
const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
72+
int output[memSize] = {};
73+
74+
ur_mem_handle_t memObj;
75+
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, bytes,
76+
nullptr, &memObj));
77+
78+
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, true, 0, bytes, data,
79+
0, nullptr, nullptr));
80+
81+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, true, 0, bytes, output,
82+
0, nullptr, nullptr));
83+
84+
bool isSame =
85+
std::equal(std::begin(output), std::end(output), std::begin(data));
86+
EXPECT_TRUE(isSame);
87+
if (!isSame) {
88+
std::for_each(std::begin(output), std::end(output),
89+
[](int &elem) { std::cout << elem << ","; });
90+
std::cout << std::endl;
91+
}
92+
}
93+
94+
TEST_P(urEnqueueMemBufferReadTest, NonBlocking) {
95+
constexpr const size_t memSize = 10u;
96+
constexpr const size_t bytes = memSize * sizeof(int);
97+
const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
98+
int output[memSize] = {};
99+
100+
ur_mem_handle_t memObj;
101+
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, bytes,
102+
nullptr, &memObj));
103+
104+
ur_event_handle_t cpIn, cpOut;
105+
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, false, 0, bytes, data,
106+
0, nullptr, &cpIn));
107+
ASSERT_NE(cpIn, nullptr);
108+
109+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, false, 0, bytes,
110+
output, 0, nullptr, &cpOut));
111+
ASSERT_NE(cpOut, nullptr);
112+
113+
ASSERT_SUCCESS(urEventWait(1, &cpOut));
114+
115+
bool isSame =
116+
std::equal(std::begin(output), std::end(output), std::begin(data));
117+
EXPECT_TRUE(isSame);
118+
if (!isSame) {
119+
std::for_each(std::begin(output), std::end(output),
120+
[](int &elem) { std::cout << elem << ","; });
121+
std::cout << std::endl;
122+
}
123+
}
124+
68125
using urEnqueueMemBufferReadMultiDeviceTest =
69126
uur::urMultiDeviceMemBufferQueueTest;
70127

‎test/conformance/memory/memory_adapter_level_zero.match‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,7 @@
1-
urMemBufferCreateTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
1+
urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_READ_WRITE
2+
urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_WRITE_ONLY
3+
urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_READ_ONLY
4+
urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_ALLOC_HOST_POINTER
25
urMemBufferPartitionTest.InvalidBufferSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
36
urMemBufferPartitionTest.InvalidValueCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
47
urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_

‎test/conformance/memory/urMemBufferCreate.cpp‎

Lines changed: 28 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -4,34 +4,42 @@
44
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
55
#include <uur/fixtures.h>
66

7-
using urMemBufferCreateTest = uur::urContextTest;
8-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemBufferCreateTest);
7+
using urMemBufferCreateTestWithFlagsParam =
8+
uur::urContextTestWithParam<ur_mem_flag_t>;
99

10-
TEST_P(urMemBufferCreateTest, Success) {
10+
using urMemBufferCreateWithFlagsTest = urMemBufferCreateTestWithFlagsParam;
11+
UUR_TEST_SUITE_P(urMemBufferCreateWithFlagsTest,
12+
::testing::Values(UR_MEM_FLAG_READ_WRITE,
13+
UR_MEM_FLAG_WRITE_ONLY,
14+
UR_MEM_FLAG_READ_ONLY,
15+
UR_MEM_FLAG_ALLOC_HOST_POINTER),
16+
uur::deviceTestWithParamPrinter<ur_mem_flag_t>);
17+
18+
TEST_P(urMemBufferCreateWithFlagsTest, Success) {
1119
ur_mem_handle_t buffer = nullptr;
12-
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 4096,
13-
nullptr, &buffer));
20+
ASSERT_SUCCESS(
21+
urMemBufferCreate(context, getParam(), 4096, nullptr, &buffer));
1422
ASSERT_NE(nullptr, buffer);
1523
ASSERT_SUCCESS(urMemRelease(buffer));
1624
}
1725

18-
TEST_P(urMemBufferCreateTest, InvalidNullHandleContext) {
26+
TEST_P(urMemBufferCreateWithFlagsTest, InvalidNullHandleContext) {
1927
ur_mem_handle_t buffer = nullptr;
20-
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
21-
urMemBufferCreate(nullptr, UR_MEM_FLAG_READ_WRITE, 4096,
22-
nullptr, &buffer));
28+
ASSERT_EQ_RESULT(
29+
UR_RESULT_ERROR_INVALID_NULL_HANDLE,
30+
urMemBufferCreate(nullptr, getParam(), 4096, nullptr, &buffer));
2331
}
2432

33+
using urMemBufferCreateTest = uur::urContextTest;
34+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemBufferCreateTest);
35+
2536
TEST_P(urMemBufferCreateTest, InvalidEnumerationFlags) {
2637
ur_mem_handle_t buffer = nullptr;
2738
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
2839
urMemBufferCreate(context, UR_MEM_FLAG_FORCE_UINT32, 4096,
2940
nullptr, &buffer));
3041
}
3142

32-
using urMemBufferCreateTestWithFlagsParam =
33-
uur::urContextTestWithParam<ur_mem_flag_t>;
34-
3543
using urMemBufferCreateWithHostPtrFlagsTest =
3644
urMemBufferCreateTestWithFlagsParam;
3745
UUR_TEST_SUITE_P(urMemBufferCreateWithHostPtrFlagsTest,
@@ -46,15 +54,15 @@ TEST_P(urMemBufferCreateWithHostPtrFlagsTest, InvalidHostPtr) {
4654
urMemBufferCreate(context, getParam(), 4096, nullptr, &buffer));
4755
}
4856

49-
TEST_P(urMemBufferCreateTest, InvalidNullPointerBuffer) {
50-
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
51-
urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 4096,
52-
nullptr, nullptr));
57+
TEST_P(urMemBufferCreateWithFlagsTest, InvalidNullPointerBuffer) {
58+
ASSERT_EQ_RESULT(
59+
UR_RESULT_ERROR_INVALID_NULL_POINTER,
60+
urMemBufferCreate(context, getParam(), 4096, nullptr, nullptr));
5361
}
5462

55-
TEST_P(urMemBufferCreateTest, InvalidBufferSizeZero) {
63+
TEST_P(urMemBufferCreateWithFlagsTest, InvalidBufferSizeZero) {
5664
ur_mem_handle_t buffer = nullptr;
57-
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_BUFFER_SIZE,
58-
urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 0,
59-
nullptr, &buffer));
65+
ASSERT_EQ_RESULT(
66+
UR_RESULT_ERROR_INVALID_BUFFER_SIZE,
67+
urMemBufferCreate(context, getParam(), 0, nullptr, &buffer));
6068
}

0 commit comments

Comments
 (0)