Skip to content

Commit

Permalink
Improvements to align CTS and Spec for Program:
Browse files Browse the repository at this point in the history 
- 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/Link
- Added extra validation for urProgramRetain/Release
- Added unowned native handle test for urProgramCreateWithNativeHandle
  • Loading branch information
@martygrant
martygrant committed Feb 13, 2025
1 parent 3ce6fcc commit f7bfaea
Show file tree
Hide file tree
Showing 8 changed files with 276 additions and 81 deletions.
14 changes: 14 additions & 0 deletions test/conformance/program/urProgramCompile.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,20 @@

#include <uur/fixtures.h>

using urProgramCompileWithParamTest = uur::urProgramTestWithParam<std::string>;

UUR_DEVICE_TEST_SUITE_WITH_PARAM(urProgramCompileWithParamTest,
::testing::Values("-O0", "-O1", "-O2", "-O3"),
uur::deviceTestWithParamPrinter<std::string>);

TEST_P(urProgramCompileWithParamTest, Success) {
const char *platformOption = nullptr;
ASSERT_SUCCESS(urPlatformGetBackendOption(platform, getParam().c_str(),
&platformOption));

ASSERT_SUCCESS(urProgramCompile(context, program, platformOption));
}

using urProgramCompileTest = uur::urProgramTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramCompileTest);

Expand Down
41 changes: 41 additions & 0 deletions test/conformance/program/urProgramCreateWithBinary.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,6 +44,47 @@ TEST_P(urProgramCreateWithBinaryTest, Success) {
nullptr, &binary_program));
}

TEST_P(urProgramCreateWithBinaryTest, SuccessWithProperties) {
auto size = binary.size();
const uint8_t *data = binary.data();

std::string string = "test metadata";
ur_program_metadata_value_t md_value_string;
md_value_string.pString = string.data();
ur_program_metadata_t meta_string = {string.data(),
UR_PROGRAM_METADATA_TYPE_STRING,
string.size(), md_value_string};

ur_program_metadata_value_t md_value_32;
md_value_32.data32 = 32;
ur_program_metadata_t meta_32 = {string.data(),
UR_PROGRAM_METADATA_TYPE_UINT32,
sizeof(uint32_t), md_value_32};

ur_program_metadata_value_t md_value_64;
md_value_64.data64 = 64;
ur_program_metadata_t meta_64 = {string.data(),
UR_PROGRAM_METADATA_TYPE_UINT64,
sizeof(uint64_t), md_value_64};

ur_program_metadata_value_t md_value_data;
std::vector<uint8_t> metadataValue = {0xDE, 0xAD, 0xBE, 0xEF};
md_value_data.pData = metadataValue.data();
ur_program_metadata_t meta_data = {string.data(),
UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY,
metadataValue.size(), md_value_data};

std::vector<ur_program_metadata_t> metadatas = {meta_string, meta_32, meta_64,
meta_data};

ur_program_properties_t properties{
UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
static_cast<uint32_t>(metadatas.size()), metadatas.data()};

ASSERT_SUCCESS(urProgramCreateWithBinary(context, 1, &device, &size, &data,
&properties, &binary_program));
}

TEST_P(urProgramCreateWithBinaryTest, InvalidNullHandleContext) {
auto size = binary.size();
const uint8_t *data = binary.data();
Expand Down
92 changes: 78 additions & 14 deletions test/conformance/program/urProgramCreateWithIL.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,8 +46,39 @@ TEST_P(urProgramCreateWithILTest, Success) {
TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
UUR_KNOWN_FAILURE_ON(uur::CUDA{});

ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
nullptr, 0, nullptr};
std::string string = "test metadata";
ur_program_metadata_value_t md_value_string;
md_value_string.pString = string.data();
ur_program_metadata_t meta_string = {string.data(),
UR_PROGRAM_METADATA_TYPE_STRING,
string.size(), md_value_string};

ur_program_metadata_value_t md_value_32;
md_value_32.data32 = 32;
ur_program_metadata_t meta_32 = {string.data(),
UR_PROGRAM_METADATA_TYPE_UINT32,
sizeof(uint32_t), md_value_32};

ur_program_metadata_value_t md_value_64;
md_value_64.data64 = 64;
ur_program_metadata_t meta_64 = {string.data(),
UR_PROGRAM_METADATA_TYPE_UINT64,
sizeof(uint64_t), md_value_64};

ur_program_metadata_value_t md_value_data;
std::vector<uint8_t> metadataValue = {0xDE, 0xAD, 0xBE, 0xEF};
md_value_data.pData = metadataValue.data();
ur_program_metadata_t meta_data = {string.data(),
UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY,
metadataValue.size(), md_value_data};

std::vector<ur_program_metadata_t> metadatas = {meta_string, meta_32, meta_64,
meta_data};

ur_program_properties_t properties{
UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
static_cast<uint32_t>(metadatas.size()), metadatas.data()};

ur_program_handle_t program = nullptr;
ASSERT_SUCCESS(urProgramCreateWithIL(
context, il_binary->data(), il_binary->size(), &properties, &program));
Expand All @@ -56,33 +87,51 @@ TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
}

TEST_P(urProgramCreateWithILTest, InvalidNullHandle) {
ur_program_handle_t program = nullptr;
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
urProgramCreateWithIL(nullptr, il_binary->data(),
il_binary->size(), nullptr, &program));
il_binary->size(), nullptr, nullptr));
}

TEST_P(urProgramCreateWithILTest, InvalidNullPointerSource) {
ur_program_handle_t program = nullptr;
TEST_P(urProgramCreateWithILTest, InvalidNullPointer) {

ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
urProgramCreateWithIL(context, nullptr, il_binary->size(),
nullptr, &program));
nullptr, nullptr));

ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
urProgramCreateWithIL(context, il_binary->data(),
il_binary->size(), nullptr, nullptr));

ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
nullptr, 1, nullptr};
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
urProgramCreateWithIL(context, il_binary->data(),
il_binary->size(), &properties,
nullptr));
}

TEST_P(urProgramCreateWithILTest, InvalidSizeLength) {
TEST_P(urProgramCreateWithILTest, InvalidSize) {
ur_program_handle_t program = nullptr;
ASSERT_EQ_RESULT(
UR_RESULT_ERROR_INVALID_SIZE,
urProgramCreateWithIL(context, il_binary->data(), 0, nullptr, &program));
}

TEST_P(urProgramCreateWithILTest, InvalidNullPointerProgram) {
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
urProgramCreateWithIL(context, il_binary->data(),
il_binary->size(), nullptr, nullptr));
std::string md_string = "test metadata";
ur_program_metadata_value_t md_value = {};
md_value.pString = md_string.data();
ur_program_metadata_t metadata = {md_string.data(),
UR_PROGRAM_METADATA_TYPE_STRING,
md_string.size(), md_value};

ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES,
nullptr, 0, &metadata};

ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
urProgramCreateWithIL(context, il_binary->data(), 1,
&properties, &program));
}

TEST_P(urProgramCreateWithILTest, BuildInvalidProgram) {
TEST_P(urProgramCreateWithILTest, InvalidBinary) {
UUR_KNOWN_FAILURE_ON(uur::CUDA{});

ur_program_handle_t program = nullptr;
Expand All @@ -92,3 +141,18 @@ TEST_P(urProgramCreateWithILTest, BuildInvalidProgram) {
ASSERT_TRUE(result == UR_RESULT_ERROR_INVALID_BINARY ||
result == UR_RESULT_SUCCESS);
}

TEST_P(urProgramCreateWithILTest, CompilerNotAvailable) {
UUR_KNOWN_FAILURE_ON(uur::CUDA{});

ur_bool_t compiler_available = false;
urDeviceGetInfo(device, UR_DEVICE_INFO_COMPILER_AVAILABLE, sizeof(ur_bool_t),
&compiler_available, nullptr);

if (!compiler_available) {
ur_program_handle_t program = nullptr;
ASSERT_EQ_RESULT(UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE,
urProgramCreateWithIL(context, il_binary->data(), 1,
nullptr, &program));
}
}
22 changes: 22 additions & 0 deletions test/conformance/program/urProgramCreateWithNativeHandle.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,28 @@ TEST_P(urProgramCreateWithNativeHandleTest, Success) {
ASSERT_NE(ref_count, 0);
}

TEST_P(urProgramCreateWithNativeHandleTest,
SuccessWithExplicitUnOwnedNativeHandle) {
ur_native_handle_t native_handle = 0;
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
urProgramGetNativeHandle(program, &native_handle));

ur_program_native_properties_t props = {
/*.stype =*/UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES,
/*.pNext =*/nullptr,
/*.isNativeHandleOwned =*/false,
};
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urProgramCreateWithNativeHandle(
native_handle, context, &props, &native_program));
ASSERT_NE(nullptr, native_program);

ur_context_handle_t program_context = nullptr;
ASSERT_SUCCESS(urProgramGetInfo(native_program, UR_PROGRAM_INFO_CONTEXT,
sizeof(ur_context_handle_t), &program_context,
nullptr));
ASSERT_EQ(context, program_context);
}

TEST_P(urProgramCreateWithNativeHandleTest, SuccessWithProperties) {
// We can't pass isNativeHandleOwned = true in the generic tests since
// we always get the native handle from a UR object, and transferring
Expand Down
136 changes: 71 additions & 65 deletions test/conformance/program/urProgramLink.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,73 +7,37 @@
#include <uur/fixtures.h>
#include <uur/known_failure.h>

struct urProgramLinkTest : uur::urProgramTest {
void SetUp() override {
UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::SetUp());
// TODO: This should use a query for urProgramCreateWithIL support or
// rely on UR_RESULT_ERROR_UNSUPPORTED_FEATURE being returned.
ur_platform_backend_t backend;
ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
sizeof(ur_platform_backend_t), &backend,
nullptr));
if (backend == UR_PLATFORM_BACKEND_HIP) {
GTEST_SKIP();
}
ASSERT_SUCCESS(urProgramCompile(context, program, nullptr));
}
using urProgramLinkWithParam = uur::urProgramLinkWithParamBaseTest<std::string>;

void TearDown() override {
if (linked_program) {
EXPECT_SUCCESS(urProgramRelease(linked_program));
}
UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::TearDown());
}
UUR_DEVICE_TEST_SUITE_WITH_PARAM(urProgramLinkWithParam,
::testing::Values("-O0", "-O1", "-O2", "-O3"),
uur::deviceTestWithParamPrinter<std::string>);

ur_program_handle_t linked_program = nullptr;
};
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkTest);
TEST_P(urProgramLinkWithParam, Success) {
UUR_KNOWN_FAILURE_ON(uur::OpenCL{"Intel(R) Core(TM) i9-12900K"});

struct urProgramLinkErrorTest : uur::urQueueTest {
const std::string linker_error_program_name = "linker_error";
size_t property_size = 0;
const ur_platform_info_t property_name = UR_PLATFORM_INFO_BACKEND;

void SetUp() override {
// We haven't got device code tests working on native cpu yet.
UUR_KNOWN_FAILURE_ON(uur::NativeCPU{});
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
urPlatformGetInfo(platform, property_name, 0, nullptr, &property_size),
property_name);
ASSERT_EQ(property_size, sizeof(ur_platform_backend_t));

UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
// TODO: This should use a query for urProgramCreateWithIL support or
// rely on UR_RESULT_ERROR_UNSUPPORTED_FEATURE being returned.
ur_platform_backend_t backend;
ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
sizeof(ur_platform_backend_t), &backend,
nullptr));
if (backend == UR_PLATFORM_BACKEND_HIP) {
GTEST_SKIP();
}
// Don't know how to produce alinker error on CUDA
if (backend == UR_PLATFORM_BACKEND_CUDA) {
GTEST_SKIP();
}
ur_platform_backend_t backend = UR_PLATFORM_BACKEND_UNKNOWN;
ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size,
&backend, nullptr));

std::shared_ptr<std::vector<char>> il_binary{};
UUR_RETURN_ON_FATAL_FAILURE(uur::KernelsEnvironment::instance->LoadSource(
linker_error_program_name, platform, il_binary));
ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
platform, context, device, *il_binary, nullptr, &program));
ASSERT_SUCCESS(urProgramCompile(context, program, nullptr));
}
const char *platformOption = nullptr;
ASSERT_SUCCESS(urPlatformGetBackendOption(platform, getParam().c_str(),
&platformOption));

void TearDown() override {
if (linked_program) {
EXPECT_SUCCESS(urProgramRelease(linked_program));
}
UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::TearDown());
}
ASSERT_SUCCESS(
urProgramLink(context, 1, &program, platformOption, &linked_program));
}

ur_program_handle_t program = nullptr;
ur_program_handle_t linked_program = nullptr;
};
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkErrorTest);
using urProgramLinkTest = uur::urProgramLinkBaseTest<uur::urProgramTest>;
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkTest);

TEST_P(urProgramLinkTest, Success) {
// This entry point isn't implemented for HIP.
Expand Down Expand Up @@ -110,12 +74,6 @@ TEST_P(urProgramLinkTest, InvalidSizeCount) {
urProgramLink(context, 0, &program, nullptr, &linked_program));
}

TEST_P(urProgramLinkErrorTest, LinkFailure) {
ASSERT_EQ_RESULT(
UR_RESULT_ERROR_PROGRAM_LINK_FAILURE,
urProgramLink(context, 1, &program, nullptr, &linked_program));
}

TEST_P(urProgramLinkTest, SetOutputOnZeroCount) {
uintptr_t invalid_pointer;
linked_program = reinterpret_cast<ur_program_handle_t>(&invalid_pointer);
Expand All @@ -126,6 +84,54 @@ TEST_P(urProgramLinkTest, SetOutputOnZeroCount) {
reinterpret_cast<ur_program_handle_t>(&invalid_pointer));
}

struct urProgramLinkErrorTest : uur::urQueueTest {
const std::string linker_error_program_name = "linker_error";

void SetUp() override {
// We haven't got device code tests working on native cpu yet.
UUR_KNOWN_FAILURE_ON(uur::NativeCPU{});

UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
// TODO: This should use a query for urProgramCreateWithIL support or
// rely on UR_RESULT_ERROR_UNSUPPORTED_FEATURE being returned.
ur_platform_backend_t backend;
ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
sizeof(ur_platform_backend_t), &backend,
nullptr));
if (backend == UR_PLATFORM_BACKEND_HIP) {
GTEST_SKIP();
}
// Don't know how to produce alinker error on CUDA
if (backend == UR_PLATFORM_BACKEND_CUDA) {
GTEST_SKIP();
}

std::shared_ptr<std::vector<char>> il_binary{};
UUR_RETURN_ON_FATAL_FAILURE(uur::KernelsEnvironment::instance->LoadSource(
linker_error_program_name, platform, il_binary));
ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
platform, context, device, *il_binary, nullptr, &program));
ASSERT_SUCCESS(urProgramCompile(context, program, nullptr));
}

void TearDown() override {
if (linked_program) {
EXPECT_SUCCESS(urProgramRelease(linked_program));
}
UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::TearDown());
}

ur_program_handle_t program = nullptr;
ur_program_handle_t linked_program = nullptr;
};
UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramLinkErrorTest);

TEST_P(urProgramLinkErrorTest, LinkFailure) {
ASSERT_EQ_RESULT(
UR_RESULT_ERROR_PROGRAM_LINK_FAILURE,
urProgramLink(context, 1, &program, nullptr, &linked_program));
}

TEST_P(urProgramLinkErrorTest, SetOutputOnLinkError) {
uintptr_t invalid_pointer;
linked_program = reinterpret_cast<ur_program_handle_t>(&invalid_pointer);
Expand Down
Loading

0 comments on commit f7bfaea

Please sign in to comment.