Skip to content

Commit 5b57041

Browse files
martygrantmartygrant
authored
Merge pull request #2282 from martygrant/martin/queue-cts-spec-gap
Improvements to align CTS and Spec for Queue
2 parents 83c02a3 + 30d91b4 commit 5b57041

File tree

3 files changed

+146
-115
lines changed

3 files changed

+146
-115
lines changed

‎test/conformance/queue/queue_adapter_native_cpu.match

+6-6
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,12 @@ urQueueCreateTest.CheckContext/*
33
urQueueCreateWithParamTest.SuccessWithProperties/*
44
urQueueCreateWithParamTest.MatchingDeviceHandles/*
55
urQueueFlushTest.Success/*
6-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_CONTEXT
7-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_DEVICE
8-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_FLAGS
9-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_REFERENCE_COUNT
10-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_EMPTY
11-
urQueueGetInfoDeviceQueueTestWithInfoParam.Success/*
6+
urQueueGetInfoTest.Context/*
7+
urQueueGetInfoTest.Device/*
8+
urQueueGetInfoTest.Flags/*
9+
urQueueGetInfoTest.ReferenceCount/*
1210
urQueueGetInfoTest.InvalidSizeSmall/*
11+
urQueueGetInfoDeviceQueueTestWithInfoParam.DeviceDefault/*
12+
urQueueGetInfoDeviceQueueTestWithInfoParam.Size/*
1313
urQueueRetainTest.Success/*
1414
urQueueReleaseTest.Success/*

‎test/conformance/queue/urQueueCreateWithNativeHandle.cpp

+21
Original file line numberDiff line numberDiff line change
@@ -29,3 +29,24 @@ TEST_P(urQueueCreateWithNativeHandleTest, Success) {
2929
ASSERT_EQ(q_context, context);
3030
ASSERT_SUCCESS(urQueueRelease(q));
3131
}
32+
33+
TEST_P(urQueueCreateWithNativeHandleTest, InvalidNullHandle) {
34+
ur_native_handle_t native_handle = 0;
35+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
36+
urQueueGetNativeHandle(queue, nullptr, &native_handle));
37+
38+
ur_queue_handle_t q = nullptr;
39+
ASSERT_EQ(urQueueCreateWithNativeHandle(native_handle, nullptr, device,
40+
nullptr, &q),
41+
UR_RESULT_ERROR_INVALID_NULL_HANDLE);
42+
}
43+
44+
TEST_P(urQueueCreateWithNativeHandleTest, InvalidNullPointer) {
45+
ur_native_handle_t native_handle = 0;
46+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
47+
urQueueGetNativeHandle(queue, nullptr, &native_handle));
48+
49+
ASSERT_EQ(urQueueCreateWithNativeHandle(native_handle, context, device,
50+
nullptr, nullptr),
51+
UR_RESULT_ERROR_INVALID_NULL_POINTER);
52+
}

‎test/conformance/queue/urQueueGetInfo.cpp

+119-109
Original file line numberDiff line numberDiff line change
@@ -5,131 +5,80 @@
55
#include <map>
66
#include <uur/fixtures.h>
77

8-
std::unordered_map<ur_queue_info_t, size_t> queue_info_size_map = {
9-
{UR_QUEUE_INFO_CONTEXT, sizeof(ur_context_handle_t)},
10-
{UR_QUEUE_INFO_DEVICE, sizeof(ur_device_handle_t)},
11-
{UR_QUEUE_INFO_DEVICE_DEFAULT, sizeof(ur_queue_handle_t)},
12-
{UR_QUEUE_INFO_FLAGS, sizeof(ur_queue_flags_t)},
13-
{UR_QUEUE_INFO_REFERENCE_COUNT, sizeof(uint32_t)},
14-
{UR_QUEUE_INFO_SIZE, sizeof(uint32_t)},
15-
{UR_QUEUE_INFO_EMPTY, sizeof(ur_bool_t)},
16-
};
8+
using urQueueGetInfoTest = uur::urQueueTest;
9+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
1710

18-
using urQueueGetInfoTestWithInfoParam =
19-
uur::urQueueTestWithParam<ur_queue_info_t>;
11+
TEST_P(urQueueGetInfoTest, Context) {
12+
size_t size = 0;
13+
auto infoType = UR_QUEUE_INFO_CONTEXT;
14+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
15+
ASSERT_NE(size, 0);
16+
ASSERT_EQ(sizeof(ur_context_handle_t), size);
2017

21-
UUR_TEST_SUITE_P(urQueueGetInfoTestWithInfoParam,
22-
::testing::Values(UR_QUEUE_INFO_CONTEXT, UR_QUEUE_INFO_DEVICE,
23-
UR_QUEUE_INFO_FLAGS,
24-
UR_QUEUE_INFO_REFERENCE_COUNT,
25-
UR_QUEUE_INFO_EMPTY),
26-
uur::deviceTestWithParamPrinter<ur_queue_info_t>);
18+
std::vector<uint8_t> data(size);
19+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
2720

28-
TEST_P(urQueueGetInfoTestWithInfoParam, Success) {
29-
ur_queue_info_t info_type = getParam();
30-
size_t size = 0;
31-
auto result = urQueueGetInfo(queue, info_type, 0, nullptr, &size);
21+
auto returned_context =
22+
reinterpret_cast<ur_context_handle_t *>(data.data());
23+
ASSERT_EQ(context, *returned_context);
24+
}
3225

33-
if (result == UR_RESULT_SUCCESS) {
34-
ASSERT_NE(size, 0);
26+
TEST_P(urQueueGetInfoTest, Device) {
27+
size_t size = 0;
28+
auto infoType = UR_QUEUE_INFO_DEVICE;
29+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
30+
ASSERT_NE(size, 0);
31+
ASSERT_EQ(sizeof(ur_device_handle_t), size);
3532

36-
if (const auto expected_size = queue_info_size_map.find(info_type);
37-
expected_size != queue_info_size_map.end()) {
38-
ASSERT_EQ(expected_size->second, size);
39-
}
33+
std::vector<uint8_t> data(size);
34+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
4035

41-
std::vector<uint8_t> data(size);
42-
ASSERT_SUCCESS(
43-
urQueueGetInfo(queue, info_type, size, data.data(), nullptr));
44-
45-
switch (info_type) {
46-
case UR_QUEUE_INFO_CONTEXT: {
47-
auto returned_context =
48-
reinterpret_cast<ur_context_handle_t *>(data.data());
49-
ASSERT_EQ(context, *returned_context);
50-
break;
51-
}
52-
case UR_QUEUE_INFO_DEVICE: {
53-
auto returned_device =
54-
reinterpret_cast<ur_device_handle_t *>(data.data());
55-
ASSERT_EQ(*returned_device, device);
56-
break;
57-
}
58-
case UR_QUEUE_INFO_REFERENCE_COUNT: {
59-
auto returned_reference_count =
60-
reinterpret_cast<uint32_t *>(data.data());
61-
ASSERT_GT(*returned_reference_count, 0U);
62-
break;
63-
}
64-
default:
65-
break;
66-
}
67-
} else {
68-
ASSERT_EQ_RESULT(result, UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION);
69-
}
36+
auto returned_device = reinterpret_cast<ur_device_handle_t *>(data.data());
37+
ASSERT_EQ(device, *returned_device);
7038
}
7139

72-
struct urQueueGetInfoDeviceQueueTestWithInfoParam
73-
: public uur::urContextTestWithParam<ur_queue_info_t> {
74-
void SetUp() {
75-
urContextTestWithParam<ur_queue_info_t>::SetUp();
76-
ur_queue_flags_t deviceQueueCapabilities;
77-
ASSERT_SUCCESS(
78-
urDeviceGetInfo(device, UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES,
79-
sizeof(deviceQueueCapabilities),
80-
&deviceQueueCapabilities, nullptr));
81-
if (!deviceQueueCapabilities) {
82-
GTEST_SKIP() << "Queue on device is not supported.";
83-
}
84-
ASSERT_SUCCESS(
85-
urQueueCreate(context, device, &queueProperties, &queue));
86-
}
87-
88-
void TearDown() {
89-
if (queue) {
90-
ASSERT_SUCCESS(urQueueRelease(queue));
91-
}
92-
urContextTestWithParam<ur_queue_info_t>::TearDown();
93-
}
40+
TEST_P(urQueueGetInfoTest, Flags) {
41+
size_t size = 0;
42+
auto infoType = UR_QUEUE_INFO_FLAGS;
43+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
44+
ASSERT_NE(size, 0);
45+
ASSERT_EQ(sizeof(ur_queue_flags_t), size);
9446

95-
ur_queue_handle_t queue = nullptr;
96-
ur_queue_properties_t queueProperties = {
97-
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
98-
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
99-
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
100-
};
47+
std::vector<uint8_t> data(size);
48+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
10149

102-
UUR_TEST_SUITE_P(urQueueGetInfoDeviceQueueTestWithInfoParam,
103-
::testing::Values(UR_QUEUE_INFO_CONTEXT, UR_QUEUE_INFO_DEVICE,
104-
UR_QUEUE_INFO_DEVICE_DEFAULT,
105-
UR_QUEUE_INFO_FLAGS,
106-
UR_QUEUE_INFO_REFERENCE_COUNT,
107-
UR_QUEUE_INFO_SIZE, UR_QUEUE_INFO_EMPTY),
108-
uur::deviceTestWithParamPrinter<ur_queue_info_t>);
50+
auto returned_flags = reinterpret_cast<ur_queue_flags_t *>(data.data());
51+
EXPECT_EQ(*returned_flags, queue_properties.flags);
52+
}
10953

110-
TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, Success) {
111-
ur_queue_info_t info_type = getParam();
54+
TEST_P(urQueueGetInfoTest, ReferenceCount) {
11255
size_t size = 0;
113-
auto result = urQueueGetInfo(queue, info_type, 0, nullptr, &size);
56+
auto infoType = UR_QUEUE_INFO_REFERENCE_COUNT;
57+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
58+
ASSERT_NE(size, 0);
59+
ASSERT_EQ(sizeof(uint32_t), size);
11460

115-
if (result == UR_RESULT_SUCCESS) {
116-
ASSERT_NE(size, 0);
61+
std::vector<uint8_t> data(size);
62+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
11763

118-
if (const auto expected_size = queue_info_size_map.find(info_type);
119-
expected_size != queue_info_size_map.end()) {
120-
ASSERT_EQ(expected_size->second, size);
121-
}
122-
123-
std::vector<uint8_t> data(size);
124-
ASSERT_SUCCESS(
125-
urQueueGetInfo(queue, info_type, size, data.data(), nullptr));
126-
} else {
127-
ASSERT_EQ_RESULT(result, UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION);
128-
}
64+
auto returned_reference_count = reinterpret_cast<uint32_t *>(data.data());
65+
ASSERT_GT(*returned_reference_count, 0U);
12966
}
13067

131-
using urQueueGetInfoTest = uur::urQueueTest;
132-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
68+
TEST_P(urQueueGetInfoTest, EmptyQueue) {
69+
size_t size = 0;
70+
auto infoType = UR_QUEUE_INFO_EMPTY;
71+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
72+
urQueueGetInfo(queue, infoType, 0, nullptr, &size));
73+
ASSERT_NE(size, 0);
74+
ASSERT_EQ(sizeof(ur_bool_t), size);
75+
76+
std::vector<uint8_t> data(size);
77+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
78+
79+
auto returned_empty_queue = reinterpret_cast<ur_bool_t *>(data.data());
80+
ASSERT_TRUE(returned_empty_queue);
81+
}
13382

13483
TEST_P(urQueueGetInfoTest, InvalidNullHandleQueue) {
13584
ur_context_handle_t context = nullptr;
@@ -174,3 +123,64 @@ TEST_P(urQueueGetInfoTest, InvalidNullPointerPropSizeRet) {
174123
UR_RESULT_ERROR_INVALID_NULL_POINTER,
175124
urQueueGetInfo(queue, UR_QUEUE_INFO_CONTEXT, 0, nullptr, nullptr));
176125
}
126+
127+
struct urQueueGetInfoDeviceQueueTestWithInfoParam : public uur::urQueueTest {
128+
void SetUp() {
129+
urQueueGetInfoTest::SetUp();
130+
ur_queue_flags_t deviceQueueCapabilities;
131+
ASSERT_SUCCESS(
132+
urDeviceGetInfo(device, UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES,
133+
sizeof(deviceQueueCapabilities),
134+
&deviceQueueCapabilities, nullptr));
135+
if (!deviceQueueCapabilities) {
136+
GTEST_SKIP() << "Queue on device is not supported.";
137+
}
138+
ASSERT_SUCCESS(
139+
urQueueCreate(context, device, &queueProperties, &queue));
140+
}
141+
142+
void TearDown() {
143+
if (queue) {
144+
ASSERT_SUCCESS(urQueueRelease(queue));
145+
}
146+
urQueueGetInfoTest::TearDown();
147+
}
148+
149+
ur_queue_handle_t queue = nullptr;
150+
ur_queue_properties_t queueProperties = {
151+
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
152+
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
153+
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
154+
};
155+
156+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoDeviceQueueTestWithInfoParam);
157+
158+
TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, DeviceDefault) {
159+
160+
size_t size = 0;
161+
auto infoType = UR_QUEUE_INFO_DEVICE_DEFAULT;
162+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
163+
ASSERT_NE(size, 0);
164+
ASSERT_EQ(sizeof(ur_queue_handle_t), size);
165+
166+
std::vector<uint8_t> data(size);
167+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
168+
169+
auto returned_queue = reinterpret_cast<ur_queue_handle_t *>(data.data());
170+
ASSERT_EQ(queue, *returned_queue);
171+
}
172+
173+
TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, Size) {
174+
175+
size_t size = 0;
176+
auto infoType = UR_QUEUE_INFO_SIZE;
177+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
178+
ASSERT_NE(size, 0);
179+
ASSERT_EQ(sizeof(uint32_t), size);
180+
181+
std::vector<uint8_t> data(size);
182+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
183+
184+
auto returned_size = reinterpret_cast<uint32_t *>(data.data());
185+
ASSERT_GT(*returned_size, 0);
186+
}

0 commit comments

Comments
 (0)