Skip to content

Commit fbe7927

Browse files
martygrantmartygrant
committed
Move GetInfo queries into separate tests rather than being done in a switch statement in one test.
Remove tests for owned/unowned native queue, as it is being handled in oneapi-src#2193.
1 parent 8e8adb5 commit fbe7927

File tree

7 files changed

+111
-147
lines changed

7 files changed

+111
-147
lines changed

‎bisect.sh

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
#!/bin/bash
2+
echo "###################### NEW RUN #################"
3+
cd build-cl
4+
ninja
5+
6+
if ./bin/test-context; then
7+
# If the command succeeds, there's no regression
8+
echo "###################### END OF RUN #################"
9+
exit 0
10+
else
11+
# If the command fails, the regression is present
12+
echo "###################### END OF RUN #################"
13+
exit 1
14+
fi

‎test/conformance/queue/queue_adapter_cuda.match

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
urQueueGetInfoTest.EmptyQueue/*

‎test/conformance/queue/queue_adapter_hip.match

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
urQueueGetInfoTest.DefaultDevice/*
2+
urQueueGetInfoTest.Size/*

‎test/conformance/queue/queue_adapter_native_cpu.match

Lines changed: 6 additions & 6 deletions
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.DeviceDefault/*
9+
urQueueGetInfoTest.Flags/*
10+
urQueueGetInfoTest.ReferenceCount/*
11+
urQueueGetInfoTest.QueueEmpty/*
1212
urQueueGetInfoTest.InvalidSizeSmall/*
1313
urQueueRetainTest.Success/*
1414
urQueueReleaseTest.Success/*

‎test/conformance/queue/urQueueCreateWithNativeHandle.cpp

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -54,33 +54,3 @@ TEST_P(urQueueCreateWithNativeHandleTest, InvalidNullPointer) {
5454
nullptr, nullptr),
5555
UR_RESULT_ERROR_INVALID_NULL_POINTER);
5656
}
57-
58-
TEST_P(urQueueCreateWithNativeHandleTest, SuccessWithOwnedNativeHandle) {
59-
ur_native_handle_t native_handle = 0;
60-
{
61-
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
62-
urQueueGetNativeHandle(queue, nullptr, &native_handle));
63-
}
64-
65-
ur_queue_handle_t q = nullptr;
66-
ur_queue_native_properties_t properties{
67-
UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES, nullptr, true};
68-
ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
69-
&properties, &q));
70-
ASSERT_NE(q, nullptr);
71-
}
72-
73-
TEST_P(urQueueCreateWithNativeHandleTest, SuccessWithUnOwnedNativeHandle) {
74-
ur_native_handle_t native_handle = 0;
75-
{
76-
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
77-
urQueueGetNativeHandle(queue, nullptr, &native_handle));
78-
}
79-
80-
ur_queue_handle_t q = nullptr;
81-
ur_queue_native_properties_t properties{
82-
UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES, nullptr, false};
83-
ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
84-
&properties, &q));
85-
ASSERT_NE(q, nullptr);
86-
}

‎test/conformance/queue/urQueueGetInfo.cpp

Lines changed: 85 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -5,120 +5,95 @@
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-
};
17-
18-
using urQueueGetInfoTestWithInfoParam =
19-
uur::urQueueTestWithParam<ur_queue_info_t>;
20-
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>);
27-
28-
TEST_P(urQueueGetInfoTestWithInfoParam, Success) {
29-
ur_queue_info_t info_type = getParam();
8+
using urQueueGetInfoTest = uur::urQueueTest;
9+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
10+
11+
TEST_P(urQueueGetInfoTest, Context) {
3012
size_t size = 0;
31-
auto result = urQueueGetInfo(queue, info_type, 0, nullptr, &size);
32-
33-
if (result == UR_RESULT_SUCCESS) {
34-
ASSERT_NE(size, 0);
35-
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-
}
40-
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_DEVICE_DEFAULT: {
59-
auto returned_default_queue =
60-
reinterpret_cast<ur_queue_handle_t *>(data.data());
61-
ASSERT_EQ(*returned_default_queue, queue);
62-
break;
63-
}
64-
case UR_QUEUE_INFO_FLAGS: {
65-
auto returned_flags =
66-
reinterpret_cast<ur_queue_flags_t *>(data.data());
67-
EXPECT_EQ(*returned_flags, *returned_flags & UR_QUEUE_FLAGS_MASK);
68-
break;
69-
}
70-
case UR_QUEUE_INFO_REFERENCE_COUNT: {
71-
auto returned_reference_count =
72-
reinterpret_cast<uint32_t *>(data.data());
73-
ASSERT_GT(*returned_reference_count, 0U);
74-
break;
75-
}
76-
case UR_QUEUE_INFO_EMPTY: {
77-
auto returned_empty_queue =
78-
reinterpret_cast<ur_bool_t *>(data.data());
79-
ASSERT_TRUE(returned_empty_queue);
80-
break;
81-
}
82-
default:
83-
break;
84-
}
85-
} else {
86-
ASSERT_EQ_RESULT(result, UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION);
87-
}
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);
17+
18+
std::vector<uint8_t> data(size);
19+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
20+
21+
auto returned_context =
22+
reinterpret_cast<ur_context_handle_t *>(data.data());
23+
ASSERT_EQ(context, *returned_context);
8824
}
8925

90-
struct urQueueGetInfoDeviceQueueTestWithInfoParam
91-
: public uur::urContextTestWithParam<ur_queue_info_t> {
92-
void SetUp() {
93-
urContextTestWithParam<ur_queue_info_t>::SetUp();
94-
ur_queue_flags_t deviceQueueCapabilities;
95-
ASSERT_SUCCESS(
96-
urDeviceGetInfo(device, UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES,
97-
sizeof(deviceQueueCapabilities),
98-
&deviceQueueCapabilities, nullptr));
99-
if (!deviceQueueCapabilities) {
100-
GTEST_SKIP() << "Queue on device is not supported.";
101-
}
102-
ASSERT_SUCCESS(
103-
urQueueCreate(context, device, &queueProperties, &queue));
104-
}
105-
106-
void TearDown() {
107-
if (queue) {
108-
ASSERT_SUCCESS(urQueueRelease(queue));
109-
}
110-
urContextTestWithParam<ur_queue_info_t>::TearDown();
111-
}
112-
113-
ur_queue_handle_t queue = nullptr;
114-
ur_queue_properties_t queueProperties = {
115-
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
116-
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
117-
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
118-
};
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);
11932

120-
using urQueueGetInfoTest = uur::urQueueTest;
121-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
33+
std::vector<uint8_t> data(size);
34+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
35+
36+
auto returned_device = reinterpret_cast<ur_device_handle_t *>(data.data());
37+
ASSERT_EQ(device, *returned_device);
38+
}
39+
40+
TEST_P(urQueueGetInfoTest, DeviceDefault) {
41+
size_t size = 0;
42+
auto infoType = UR_QUEUE_INFO_DEVICE_DEFAULT;
43+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
44+
ASSERT_NE(size, 0);
45+
ASSERT_EQ(sizeof(ur_queue_handle_t), size);
46+
47+
std::vector<uint8_t> data(size);
48+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
49+
50+
auto returned_default_queue =
51+
reinterpret_cast<ur_queue_handle_t *>(data.data());
52+
ASSERT_EQ(queue, *returned_default_queue);
53+
}
54+
55+
TEST_P(urQueueGetInfoTest, Flags) {
56+
size_t size = 0;
57+
auto infoType = UR_QUEUE_INFO_FLAGS;
58+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
59+
ASSERT_NE(size, 0);
60+
ASSERT_EQ(sizeof(ur_queue_flags_t), size);
61+
62+
std::vector<uint8_t> data(size);
63+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
64+
65+
auto returned_flags = reinterpret_cast<ur_queue_flags_t *>(data.data());
66+
EXPECT_EQ(*returned_flags, queue_properties.flags);
67+
}
68+
69+
TEST_P(urQueueGetInfoTest, ReferenceCount) {
70+
size_t size = 0;
71+
auto infoType = UR_QUEUE_INFO_REFERENCE_COUNT;
72+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
73+
ASSERT_NE(size, 0);
74+
ASSERT_EQ(sizeof(uint32_t), size);
75+
76+
std::vector<uint8_t> data(size);
77+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
78+
79+
auto returned_reference_count = reinterpret_cast<uint32_t *>(data.data());
80+
ASSERT_GT(*returned_reference_count, 0U);
81+
}
82+
83+
TEST_P(urQueueGetInfoTest, EmptyQueue) {
84+
size_t size = 0;
85+
auto infoType = UR_QUEUE_INFO_EMPTY;
86+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
87+
urQueueGetInfo(queue, infoType, 0, nullptr, &size));
88+
ASSERT_NE(size, 0);
89+
ASSERT_EQ(sizeof(ur_bool_t), size);
90+
91+
std::vector<uint8_t> data(size);
92+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
93+
94+
auto returned_empty_queue = reinterpret_cast<ur_bool_t *>(data.data());
95+
ASSERT_TRUE(returned_empty_queue);
96+
}
12297

12398
TEST_P(urQueueGetInfoTest, InvalidNullHandleQueue) {
12499
ur_context_handle_t context = nullptr;

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

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -365,7 +365,9 @@ struct urQueueTest : urContextTest {
365365
}
366366

367367
ur_queue_properties_t queue_properties = {
368-
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr, 0};
368+
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
369+
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
370+
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
369371
ur_queue_handle_t queue = nullptr;
370372
};
371373

0 commit comments

Comments
 (0)