Skip to content

Commit 8fa2a12

Browse files
martygrantmartygrant
authored
[UR] Improvements to align CTS and Spec for Program (#17094)
Migrated from oneapi-src/unified-runtime#2697 - All error returns for urProgramCreateWithIL are now covered, and a Success case with different properties has been added - Passing properties to urProgramCreateWithBinary - Added tests for passing options to urProgramCompile - Not passing any options to urProgramLink as there are no common platform independent options that I'm aware of - Added extra validation for urProgramRetain/Release - Added unowned native handle test for urProgramCreateWithNativeHandle
1 parent 36f40ed commit 8fa2a12

File tree

9 files changed

+222
-61
lines changed

9 files changed

+222
-61
lines changed

‎unified-runtime/source/adapters/opencl/common.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@ ur_result_t mapCLErrorToUR(cl_int Result) {
8181
case CL_PROFILING_INFO_NOT_AVAILABLE:
8282
return UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE;
8383
case CL_LINK_PROGRAM_FAILURE:
84+
case CL_INVALID_LINKER_OPTIONS:
8485
return UR_RESULT_ERROR_PROGRAM_LINK_FAILURE;
8586
case CL_INVALID_ARG_INDEX:
8687
return UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX;

‎unified-runtime/test/conformance/program/urProgramCompile.cpp‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,20 @@
66

77
#include <uur/fixtures.h>
88

9+
using urProgramCompileWithParamTest = uur::urProgramTestWithParam<std::string>;
10+
11+
UUR_DEVICE_TEST_SUITE_WITH_PARAM(urProgramCompileWithParamTest,
12+
::testing::Values("-O0", "-O1", "-O2", "-O3"),
13+
uur::deviceTestWithParamPrinter<std::string>);
14+
15+
TEST_P(urProgramCompileWithParamTest, Success) {
16+
const char *platformOption = nullptr;
17+
ASSERT_SUCCESS(urPlatformGetBackendOption(platform, getParam().c_str(),
18+
&platformOption));
19+
20+
ASSERT_SUCCESS(urProgramCompile(context, program, platformOption));
21+
}
22+
923
using urProgramCompileTest = uur::urProgramTest;
1024
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramCompileTest);
1125

‎unified-runtime/test/conformance/program/urProgramCreateWithBinary.cpp‎

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,47 @@ TEST_P(urProgramCreateWithBinaryTest, Success) {
4444
nullptr, &binary_program));
4545
}
4646

47+
TEST_P(urProgramCreateWithBinaryTest, SuccessWithProperties) {
48+
auto size = binary.size();
49+
const uint8_t *data = binary.data();
50+
51+
std::string string = "test metadata";
52+
ur_program_metadata_value_t md_value_string;
53+
md_value_string.pString = string.data();
54+
ur_program_metadata_t meta_string = {string.data(),
55+
UR_PROGRAM_METADATA_TYPE_STRING,
56+
string.size(), md_value_string};
57+
58+
ur_program_metadata_value_t md_value_32;
59+
md_value_32.data32 = 32;
60+
ur_program_metadata_t meta_32 = {string.data(),
61+
UR_PROGRAM_METADATA_TYPE_UINT32,
62+
sizeof(uint32_t), md_value_32};
63+
64+
ur_program_metadata_value_t md_value_64;
65+
md_value_64.data64 = 64;
66+
ur_program_metadata_t meta_64 = {string.data(),
67+
UR_PROGRAM_METADATA_TYPE_UINT64,
68+
sizeof(uint64_t), md_value_64};
69+
70+
ur_program_metadata_value_t md_value_data;
71+
std::vector<uint8_t> metadataValue = {0xDE, 0xAD, 0xBE, 0xEF};
72+
md_value_data.pData = metadataValue.data();
73+
ur_program_metadata_t meta_data = {string.data(),
74+
UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY,
75+
metadataValue.size(), md_value_data};
76+
77+
std::vector<ur_program_metadata_t> metadatas = {meta_string, meta_32, meta_64,
78+
meta_data};
79+
80+
ur_program_properties_t properties{
81+
UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
82+
static_cast<uint32_t>(metadatas.size()), metadatas.data()};
83+
84+
ASSERT_SUCCESS(urProgramCreateWithBinary(context, 1, &device, &size, &data,
85+
&properties, &binary_program));
86+
}
87+
4788
TEST_P(urProgramCreateWithBinaryTest, InvalidNullHandleContext) {
4889
auto size = binary.size();
4990
const uint8_t *data = binary.data();

‎unified-runtime/test/conformance/program/urProgramCreateWithIL.cpp‎

Lines changed: 78 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -46,8 +46,39 @@ TEST_P(urProgramCreateWithILTest, Success) {
4646
TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
4747
UUR_KNOWN_FAILURE_ON(uur::CUDA{});
4848

49-
ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
50-
nullptr, 0, nullptr};
49+
std::string string = "test metadata";
50+
ur_program_metadata_value_t md_value_string;
51+
md_value_string.pString = string.data();
52+
ur_program_metadata_t meta_string = {string.data(),
53+
UR_PROGRAM_METADATA_TYPE_STRING,
54+
string.size(), md_value_string};
55+
56+
ur_program_metadata_value_t md_value_32;
57+
md_value_32.data32 = 32;
58+
ur_program_metadata_t meta_32 = {string.data(),
59+
UR_PROGRAM_METADATA_TYPE_UINT32,
60+
sizeof(uint32_t), md_value_32};
61+
62+
ur_program_metadata_value_t md_value_64;
63+
md_value_64.data64 = 64;
64+
ur_program_metadata_t meta_64 = {string.data(),
65+
UR_PROGRAM_METADATA_TYPE_UINT64,
66+
sizeof(uint64_t), md_value_64};
67+
68+
ur_program_metadata_value_t md_value_data;
69+
std::vector<uint8_t> metadataValue = {0xDE, 0xAD, 0xBE, 0xEF};
70+
md_value_data.pData = metadataValue.data();
71+
ur_program_metadata_t meta_data = {string.data(),
72+
UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY,
73+
metadataValue.size(), md_value_data};
74+
75+
std::vector<ur_program_metadata_t> metadatas = {meta_string, meta_32, meta_64,
76+
meta_data};
77+
78+
ur_program_properties_t properties{
79+
UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
80+
static_cast<uint32_t>(metadatas.size()), metadatas.data()};
81+
5182
ur_program_handle_t program = nullptr;
5283
ASSERT_SUCCESS(urProgramCreateWithIL(
5384
context, il_binary->data(), il_binary->size(), &properties, &program));
@@ -56,33 +87,51 @@ TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
5687
}
5788

5889
TEST_P(urProgramCreateWithILTest, InvalidNullHandle) {
59-
ur_program_handle_t program = nullptr;
6090
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
6191
urProgramCreateWithIL(nullptr, il_binary->data(),
62-
il_binary->size(), nullptr, &program));
92+
il_binary->size(), nullptr, nullptr));
6393
}
6494

65-
TEST_P(urProgramCreateWithILTest, InvalidNullPointerSource) {
66-
ur_program_handle_t program = nullptr;
95+
TEST_P(urProgramCreateWithILTest, InvalidNullPointer) {
96+
6797
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
6898
urProgramCreateWithIL(context, nullptr, il_binary->size(),
69-
nullptr, &program));
99+
nullptr, nullptr));
100+
101+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
102+
urProgramCreateWithIL(context, il_binary->data(),
103+
il_binary->size(), nullptr, nullptr));
104+
105+
ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
106+
nullptr, 1, nullptr};
107+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
108+
urProgramCreateWithIL(context, il_binary->data(),
109+
il_binary->size(), &properties,
110+
nullptr));
70111
}
71112

72-
TEST_P(urProgramCreateWithILTest, InvalidSizeLength) {
113+
TEST_P(urProgramCreateWithILTest, InvalidSize) {
73114
ur_program_handle_t program = nullptr;
74115
ASSERT_EQ_RESULT(
75116
UR_RESULT_ERROR_INVALID_SIZE,
76117
urProgramCreateWithIL(context, il_binary->data(), 0, nullptr, &program));
77-
}
78118

79-
TEST_P(urProgramCreateWithILTest, InvalidNullPointerProgram) {
80-
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
81-
urProgramCreateWithIL(context, il_binary->data(),
82-
il_binary->size(), nullptr, nullptr));
119+
std::string md_string = "test metadata";
120+
ur_program_metadata_value_t md_value = {};
121+
md_value.pString = md_string.data();
122+
ur_program_metadata_t metadata = {md_string.data(),
123+
UR_PROGRAM_METADATA_TYPE_STRING,
124+
md_string.size(), md_value};
125+
126+
ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
127+
nullptr, 0, &metadata};
128+
129+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
130+
urProgramCreateWithIL(context, il_binary->data(), 1,
131+
&properties, &program));
83132
}
84133

85-
TEST_P(urProgramCreateWithILTest, BuildInvalidProgram) {
134+
TEST_P(urProgramCreateWithILTest, InvalidBinary) {
86135
UUR_KNOWN_FAILURE_ON(uur::CUDA{});
87136

88137
ur_program_handle_t program = nullptr;
@@ -92,3 +141,18 @@ TEST_P(urProgramCreateWithILTest, BuildInvalidProgram) {
92141
ASSERT_TRUE(result == UR_RESULT_ERROR_INVALID_BINARY ||
93142
result == UR_RESULT_SUCCESS);
94143
}
144+
145+
TEST_P(urProgramCreateWithILTest, CompilerNotAvailable) {
146+
UUR_KNOWN_FAILURE_ON(uur::CUDA{});
147+
148+
ur_bool_t compiler_available = false;
149+
urDeviceGetInfo(device, UR_DEVICE_INFO_COMPILER_AVAILABLE, sizeof(ur_bool_t),
150+
&compiler_available, nullptr);
151+
152+
if (!compiler_available) {
153+
ur_program_handle_t program = nullptr;
154+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE,
155+
urProgramCreateWithIL(context, il_binary->data(), 1,
156+
nullptr, &program));
157+
}
158+
}

‎unified-runtime/test/conformance/program/urProgramCreateWithNativeHandle.cpp‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,28 @@ TEST_P(urProgramCreateWithNativeHandleTest, Success) {
4747
ASSERT_NE(ref_count, 0);
4848
}
4949

50+
TEST_P(urProgramCreateWithNativeHandleTest,
51+
SuccessWithExplicitUnOwnedNativeHandle) {
52+
ur_native_handle_t native_handle = 0;
53+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
54+
urProgramGetNativeHandle(program, &native_handle));
55+
56+
ur_program_native_properties_t props = {
57+
/*.stype =*/UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES,
58+
/*.pNext =*/nullptr,
59+
/*.isNativeHandleOwned =*/false,
60+
};
61+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urProgramCreateWithNativeHandle(
62+
native_handle, context, &props, &native_program));
63+
ASSERT_NE(nullptr, native_program);
64+
65+
ur_context_handle_t program_context = nullptr;
66+
ASSERT_SUCCESS(urProgramGetInfo(native_program, UR_PROGRAM_INFO_CONTEXT,
67+
sizeof(ur_context_handle_t), &program_context,
68+
nullptr));
69+
ASSERT_EQ(context, program_context);
70+
}
71+
5072
TEST_P(urProgramCreateWithNativeHandleTest, SuccessWithProperties) {
5173
// We can't pass isNativeHandleOwned = true in the generic tests since
5274
// we always get the native handle from a UR object, and transferring

‎unified-runtime/test/conformance/program/urProgramLink.cpp‎

Lines changed: 45 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,51 @@ struct urProgramLinkTest : uur::urProgramTest {
3333
};
3434
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkTest);
3535

36+
TEST_P(urProgramLinkTest, Success) {
37+
// This entry point isn't implemented for HIP.
38+
UUR_KNOWN_FAILURE_ON(uur::HIP{});
39+
40+
ASSERT_SUCCESS(urProgramLink(context, 1, &program, nullptr, &linked_program));
41+
ur_program_binary_type_t binary_type = UR_PROGRAM_BINARY_TYPE_NONE;
42+
ASSERT_SUCCESS(urProgramGetBuildInfo(
43+
linked_program, device, UR_PROGRAM_BUILD_INFO_BINARY_TYPE,
44+
sizeof(binary_type), &binary_type, nullptr));
45+
ASSERT_EQ(binary_type, UR_PROGRAM_BINARY_TYPE_EXECUTABLE);
46+
}
47+
48+
TEST_P(urProgramLinkTest, InvalidNullHandleContext) {
49+
ASSERT_EQ_RESULT(
50+
UR_RESULT_ERROR_INVALID_NULL_HANDLE,
51+
urProgramLink(nullptr, 1, &program, nullptr, &linked_program));
52+
}
53+
54+
TEST_P(urProgramLinkTest, InvalidNullPointerProgram) {
55+
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
56+
urProgramLink(context, 1, &program, nullptr, nullptr));
57+
}
58+
59+
TEST_P(urProgramLinkTest, InvalidNullPointerInputPrograms) {
60+
ASSERT_EQ_RESULT(
61+
UR_RESULT_ERROR_INVALID_NULL_POINTER,
62+
urProgramLink(context, 1, nullptr, nullptr, &linked_program));
63+
}
64+
65+
TEST_P(urProgramLinkTest, InvalidSizeCount) {
66+
ASSERT_EQ_RESULT(
67+
UR_RESULT_ERROR_INVALID_SIZE,
68+
urProgramLink(context, 0, &program, nullptr, &linked_program));
69+
}
70+
71+
TEST_P(urProgramLinkTest, SetOutputOnZeroCount) {
72+
uintptr_t invalid_pointer;
73+
linked_program = reinterpret_cast<ur_program_handle_t>(&invalid_pointer);
74+
ASSERT_EQ_RESULT(
75+
UR_RESULT_ERROR_INVALID_SIZE,
76+
urProgramLink(context, 0, &program, nullptr, &linked_program));
77+
ASSERT_NE(linked_program,
78+
reinterpret_cast<ur_program_handle_t>(&invalid_pointer));
79+
}
80+
3681
struct urProgramLinkErrorTest : uur::urQueueTest {
3782
const std::string linker_error_program_name = "linker_error";
3883

@@ -75,57 +120,12 @@ struct urProgramLinkErrorTest : uur::urQueueTest {
75120
};
76121
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkErrorTest);
77122

78-
TEST_P(urProgramLinkTest, Success) {
79-
// This entry point isn't implemented for HIP.
80-
UUR_KNOWN_FAILURE_ON(uur::HIP{});
81-
82-
ASSERT_SUCCESS(urProgramLink(context, 1, &program, nullptr, &linked_program));
83-
ur_program_binary_type_t binary_type = UR_PROGRAM_BINARY_TYPE_NONE;
84-
ASSERT_SUCCESS(urProgramGetBuildInfo(
85-
linked_program, device, UR_PROGRAM_BUILD_INFO_BINARY_TYPE,
86-
sizeof(binary_type), &binary_type, nullptr));
87-
ASSERT_EQ(binary_type, UR_PROGRAM_BINARY_TYPE_EXECUTABLE);
88-
}
89-
90-
TEST_P(urProgramLinkTest, InvalidNullHandleContext) {
91-
ASSERT_EQ_RESULT(
92-
UR_RESULT_ERROR_INVALID_NULL_HANDLE,
93-
urProgramLink(nullptr, 1, &program, nullptr, &linked_program));
94-
}
95-
96-
TEST_P(urProgramLinkTest, InvalidNullPointerProgram) {
97-
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
98-
urProgramLink(context, 1, &program, nullptr, nullptr));
99-
}
100-
101-
TEST_P(urProgramLinkTest, InvalidNullPointerInputPrograms) {
102-
ASSERT_EQ_RESULT(
103-
UR_RESULT_ERROR_INVALID_NULL_POINTER,
104-
urProgramLink(context, 1, nullptr, nullptr, &linked_program));
105-
}
106-
107-
TEST_P(urProgramLinkTest, InvalidSizeCount) {
108-
ASSERT_EQ_RESULT(
109-
UR_RESULT_ERROR_INVALID_SIZE,
110-
urProgramLink(context, 0, &program, nullptr, &linked_program));
111-
}
112-
113123
TEST_P(urProgramLinkErrorTest, LinkFailure) {
114124
ASSERT_EQ_RESULT(
115125
UR_RESULT_ERROR_PROGRAM_LINK_FAILURE,
116126
urProgramLink(context, 1, &program, nullptr, &linked_program));
117127
}
118128

119-
TEST_P(urProgramLinkTest, SetOutputOnZeroCount) {
120-
uintptr_t invalid_pointer;
121-
linked_program = reinterpret_cast<ur_program_handle_t>(&invalid_pointer);
122-
ASSERT_EQ_RESULT(
123-
UR_RESULT_ERROR_INVALID_SIZE,
124-
urProgramLink(context, 0, &program, nullptr, &linked_program));
125-
ASSERT_NE(linked_program,
126-
reinterpret_cast<ur_program_handle_t>(&invalid_pointer));
127-
}
128-
129129
TEST_P(urProgramLinkErrorTest, SetOutputOnLinkError) {
130130
uintptr_t invalid_pointer;
131131
linked_program = reinterpret_cast<ur_program_handle_t>(&invalid_pointer);

‎unified-runtime/test/conformance/program/urProgramRelease.cpp‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,16 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramReleaseTest);
1111

1212
TEST_P(urProgramReleaseTest, Success) {
1313
ASSERT_SUCCESS(urProgramRetain(program));
14+
15+
uint32_t prevRefCount = 0;
16+
ASSERT_SUCCESS(uur::GetObjectReferenceCount(program, prevRefCount));
17+
1418
ASSERT_SUCCESS(urProgramRelease(program));
19+
20+
uint32_t refCount = 0;
21+
ASSERT_SUCCESS(uur::GetObjectReferenceCount(program, refCount));
22+
23+
ASSERT_GT(prevRefCount, refCount);
1524
}
1625

1726
TEST_P(urProgramReleaseTest, InvalidNullHandleProgram) {

‎unified-runtime/test/conformance/program/urProgramRetain.cpp‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,17 @@ using urProgramRetainTest = uur::urProgramTest;
1010
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramRetainTest);
1111

1212
TEST_P(urProgramRetainTest, Success) {
13+
uint32_t prevRefCount = 0;
14+
ASSERT_SUCCESS(uur::GetObjectReferenceCount(program, prevRefCount));
15+
1316
ASSERT_SUCCESS(urProgramRetain(program));
14-
EXPECT_SUCCESS(urProgramRelease(program));
17+
18+
uint32_t refCount = 0;
19+
ASSERT_SUCCESS(uur::GetObjectReferenceCount(program, refCount));
20+
21+
ASSERT_LT(prevRefCount, refCount);
22+
23+
EXPECT_SUCCESS(urProgramRetain(program));
1524
}
1625

1726
TEST_P(urProgramRetainTest, InvalidNullHandleProgram) {

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

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1174,7 +1174,8 @@ std::string deviceTestWithParamPrinter(
11741174

11751175
std::stringstream ss;
11761176
ss << param;
1177-
return uur::GetPlatformAndDeviceName(device) + "__" + ss.str();
1177+
return uur::GetPlatformAndDeviceName(device) + "__" +
1178+
GTestSanitizeString(ss.str());
11781179
}
11791180

11801181
template <>

0 commit comments

Comments
 (0)