Skip to content

Commit

Permalink
Merge pull request #481 from aarongreig/aaron/parameterizeProgramKern…
Browse files Browse the repository at this point in the history 
…elInfo

Parameterize program and kernel info tests.
  • Loading branch information
@aarongreig
aarongreig authored Apr 28, 2023
2 parents d2d7f8e + 720de64 commit 803871f
Show file tree
Hide file tree
Showing 7 changed files with 252 additions and 69 deletions.
28 changes: 21 additions & 7 deletions test/conformance/kernel/urKernelGetGroupInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,15 +3,29 @@

#include <uur/fixtures.h>

using urKernelGetGroupInfoTest = uur::urKernelTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetGroupInfoTest);
using urKernelGetGroupInfoTest =
uur::urKernelTestWithParam<ur_kernel_group_info_t>;

UUR_TEST_SUITE_P(
urKernelGetGroupInfoTest,
::testing::Values(UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE,
UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE,
UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE,
UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE,
UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE),
uur::deviceTestWithParamPrinter<ur_kernel_group_info_t>);

TEST_P(urKernelGetGroupInfoTest, Success) {
size_t work_group_size = 0;
ASSERT_SUCCESS(urKernelGetGroupInfo(
kernel, device, UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE,
sizeof(work_group_size), &work_group_size, nullptr));
ASSERT_NE(work_group_size, 0);
auto property_name = getParam();
size_t property_size = 0;
std::vector<char> property_value;
ASSERT_SUCCESS(urKernelGetGroupInfo(kernel, device, property_name, 0,
nullptr, &property_size));
property_value.resize(property_size);
ASSERT_SUCCESS(urKernelGetGroupInfo(kernel, device, property_name,
property_size, property_value.data(),
nullptr));
}

TEST_P(urKernelGetGroupInfoTest, InvalidNullHandleKernel) {
Expand Down
28 changes: 17 additions & 11 deletions test/conformance/kernel/urKernelGetInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,19 +3,25 @@

#include <uur/fixtures.h>

using urKernelGetInfoTest = uur::urKernelTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetInfoTest);
using urKernelGetInfoTest = uur::urKernelTestWithParam<ur_kernel_info_t>;

UUR_TEST_SUITE_P(
urKernelGetInfoTest,
::testing::Values(UR_KERNEL_INFO_FUNCTION_NAME, UR_KERNEL_INFO_NUM_ARGS,
UR_KERNEL_INFO_REFERENCE_COUNT, UR_KERNEL_INFO_CONTEXT,
UR_KERNEL_INFO_PROGRAM, UR_KERNEL_INFO_ATTRIBUTES,
UR_KERNEL_INFO_NUM_REGS),
uur::deviceTestWithParamPrinter<ur_kernel_info_t>);

TEST_P(urKernelGetInfoTest, Success) {
size_t kernel_name_length = 0;
ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_FUNCTION_NAME, 0,
nullptr, &kernel_name_length));
std::string queried_kernel_name;
queried_kernel_name.resize(kernel_name_length);
ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_FUNCTION_NAME,
queried_kernel_name.size(),
queried_kernel_name.data(), nullptr));
ASSERT_EQ(queried_kernel_name, kernel_name);
auto property_name = getParam();
size_t property_size = 0;
std::vector<char> property_value;
ASSERT_SUCCESS(
urKernelGetInfo(kernel, property_name, 0, nullptr, &property_size));
property_value.resize(property_size);
ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size,
property_value.data(), nullptr));
}

TEST_P(urKernelGetInfoTest, InvalidNullHandleKernel) {
Expand Down
32 changes: 19 additions & 13 deletions test/conformance/kernel/urKernelGetSubGroupInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,21 +3,27 @@

#include <uur/fixtures.h>

using urKernelGetSubGroupInfoTest = uur::urKernelTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetSubGroupInfoTest);
using urKernelGetSubGroupInfoTest =
uur::urKernelTestWithParam<ur_kernel_sub_group_info_t>;

TEST_P(urKernelGetSubGroupInfoTest, Success) {
uint32_t max_num_sub_groups = 0;
ASSERT_SUCCESS(urKernelGetSubGroupInfo(
kernel, device, UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS,
sizeof(max_num_sub_groups), &max_num_sub_groups, nullptr));
UUR_TEST_SUITE_P(
urKernelGetSubGroupInfoTest,
::testing::Values(UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE,
UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS,
UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS,
UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL),
uur::deviceTestWithParamPrinter<ur_kernel_sub_group_info_t>);

uint32_t device_max_num_sub_groups = 0;
ASSERT_SUCCESS(urDeviceGetInfo(device, UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS,
sizeof(device_max_num_sub_groups),
&device_max_num_sub_groups, nullptr));

ASSERT_TRUE(max_num_sub_groups <= device_max_num_sub_groups);
TEST_P(urKernelGetSubGroupInfoTest, Success) {
auto property_name = getParam();
size_t property_size = 0;
std::vector<char> property_value;
ASSERT_SUCCESS(urKernelGetSubGroupInfo(kernel, device, property_name, 0,
nullptr, &property_size));
property_value.resize(property_size);
ASSERT_SUCCESS(urKernelGetSubGroupInfo(kernel, device, property_name,
property_size, property_value.data(),
nullptr));
}

TEST_P(urKernelGetSubGroupInfoTest, InvalidNullHandleKernel) {
Expand Down
85 changes: 84 additions & 1 deletion test/conformance/kernel/urKernelSetExecInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@
using urKernelSetExecInfoTest = uur::urKernelTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelSetExecInfoTest);

TEST_P(urKernelSetExecInfoTest, Success) {
TEST_P(urKernelSetExecInfoTest, SuccessIndirectAccess) {
bool property_value = false;
ASSERT_SUCCESS(
urKernelSetExecInfo(kernel, UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS,
Expand Down Expand Up @@ -36,3 +36,86 @@ TEST_P(urKernelSetExecInfoTest, InvalidNullPointerPropValue) {
urKernelSetExecInfo(nullptr, UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS,
sizeof(property_value), nullptr));
}

struct urKernelSetExecInfoUSMPointersTest : uur::urKernelTest {
void SetUp() {
kernel_name = "fill";
UUR_RETURN_ON_FATAL_FAILURE(urKernelTest::SetUp());
}

void TearDown() {
if (allocation) {
ASSERT_SUCCESS(urUSMFree(context, allocation));
}
UUR_RETURN_ON_FATAL_FAILURE(urKernelTest::TearDown());
}

size_t allocation_size = 16;
void *allocation = nullptr;
};
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelSetExecInfoUSMPointersTest);

TEST_P(urKernelSetExecInfoUSMPointersTest, SuccessHost) {
bool host_supported = false;
ASSERT_SUCCESS(uur::GetDeviceUSMHostSupport(device, host_supported));
if (!host_supported) {
GTEST_SKIP() << "Host USM is not supported.";
}

ASSERT_SUCCESS(urUSMHostAlloc(context, nullptr, nullptr, allocation_size,
&allocation));
ASSERT_NE(allocation, nullptr);
void *pointers[] = {allocation};

ASSERT_SUCCESS(urKernelSetExecInfo(kernel, UR_KERNEL_EXEC_INFO_USM_PTRS,
sizeof(pointers), pointers));
}

TEST_P(urKernelSetExecInfoUSMPointersTest, SuccessDevice) {
bool device_supported = false;
ASSERT_SUCCESS(uur::GetDeviceUSMDeviceSupport(device, device_supported));
if (!device_supported) {
GTEST_SKIP() << "Device USM is not supported.";
}

ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr,
allocation_size, &allocation));
ASSERT_NE(allocation, nullptr);
void *pointers[] = {allocation};

ASSERT_SUCCESS(urKernelSetExecInfo(kernel, UR_KERNEL_EXEC_INFO_USM_PTRS,
sizeof(pointers), pointers));
}

TEST_P(urKernelSetExecInfoUSMPointersTest, SuccessShared) {
bool shared_supported = false;
ASSERT_SUCCESS(
uur::GetDeviceUSMSingleSharedSupport(device, shared_supported));
if (!shared_supported) {
GTEST_SKIP() << "Shared USM is not supported.";
}

ASSERT_SUCCESS(urUSMSharedAlloc(context, device, nullptr, nullptr,
allocation_size, &allocation));
ASSERT_NE(allocation, nullptr);
void *pointers[] = {allocation};

ASSERT_SUCCESS(urKernelSetExecInfo(kernel, UR_KERNEL_EXEC_INFO_USM_PTRS,
sizeof(pointers), pointers));
}

using urKernelSetExecInfoCacheConfigTest =
uur::urKernelTestWithParam<ur_kernel_cache_config_t>;

UUR_TEST_SUITE_P(urKernelSetExecInfoCacheConfigTest,
::testing::Values(UR_KERNEL_CACHE_CONFIG_DEFAULT,
UR_KERNEL_CACHE_CONFIG_LARGE_SLM,
UR_KERNEL_CACHE_CONFIG_LARGE_DATA),
uur::deviceTestWithParamPrinter<ur_kernel_cache_config_t>);

TEST_P(urKernelSetExecInfoCacheConfigTest, Success) {
auto property_value = getParam();
ASSERT_SUCCESS(urKernelSetExecInfo(kernel, UR_KERNEL_EXEC_INFO_CACHE_CONFIG,
sizeof(property_value),
&property_value));
}
31 changes: 21 additions & 10 deletions test/conformance/program/urProgramGetBuildInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,21 +3,32 @@

#include <uur/fixtures.h>

struct urProgramGetBuildInfoTest : uur::urProgramTest {
struct urProgramGetBuildInfoTest
: uur::urProgramTestWithParam<ur_program_build_info_t> {
void SetUp() override {
UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::SetUp());
ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
UUR_RETURN_ON_FATAL_FAILURE(
urProgramTestWithParam<ur_program_build_info_t>::SetUp());
ASSERT_SUCCESS(urProgramBuild(this->context, program, nullptr));
}
};
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urProgramGetBuildInfoTest);

UUR_TEST_SUITE_P(urProgramGetBuildInfoTest,
::testing::Values(UR_PROGRAM_BUILD_INFO_STATUS,
UR_PROGRAM_BUILD_INFO_OPTIONS,
UR_PROGRAM_BUILD_INFO_LOG,
UR_PROGRAM_BUILD_INFO_BINARY_TYPE),
uur::deviceTestWithParamPrinter<ur_program_build_info_t>);

TEST_P(urProgramGetBuildInfoTest, Success) {
ur_program_build_status_t programBuildStatus =
UR_PROGRAM_BUILD_STATUS_ERROR;
ASSERT_SUCCESS(urProgramGetBuildInfo(
program, device, UR_PROGRAM_BUILD_INFO_STATUS,
sizeof(programBuildStatus), &programBuildStatus, nullptr));
ASSERT_NE(UR_PROGRAM_BUILD_STATUS_ERROR, programBuildStatus);
auto property_name = getParam();
size_t property_size = 0;
std::vector<char> property_value;
ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, 0,
nullptr, &property_size));
property_value.resize(property_size);
ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name,
property_size, property_value.data(),
nullptr));
}

TEST_P(urProgramGetBuildInfoTest, InvalidNullHandleProgram) {
Expand Down
24 changes: 18 additions & 6 deletions test/conformance/program/urProgramGetInfo.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,14 +3,26 @@

#include <uur/fixtures.h>

using urProgramGetInfoTest = uur::urProgramTest;
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urProgramGetInfoTest);
using urProgramGetInfoTest = uur::urProgramTestWithParam<ur_program_info_t>;

UUR_TEST_SUITE_P(
urProgramGetInfoTest,
::testing::Values(UR_PROGRAM_INFO_REFERENCE_COUNT, UR_PROGRAM_INFO_CONTEXT,
UR_PROGRAM_INFO_NUM_DEVICES, UR_PROGRAM_INFO_DEVICES,
UR_PROGRAM_INFO_SOURCE, UR_PROGRAM_INFO_BINARY_SIZES,
UR_PROGRAM_INFO_BINARIES, UR_PROGRAM_INFO_NUM_KERNELS,
UR_PROGRAM_INFO_KERNEL_NAMES),
uur::deviceTestWithParamPrinter<ur_program_info_t>);

TEST_P(urProgramGetInfoTest, Success) {
uint32_t ref_count = 0;
ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_REFERENCE_COUNT,
sizeof(ref_count), &ref_count, nullptr));
ASSERT_NE(0, ref_count);
auto property_name = getParam();
size_t property_size = 0;
std::vector<char> property_value;
ASSERT_SUCCESS(
urProgramGetInfo(program, property_name, 0, nullptr, &property_size));
property_value.resize(property_size);
ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size,
property_value.data(), nullptr));
}

TEST_P(urProgramGetInfoTest, InvalidNullHandleProgram) {
Expand Down
93 changes: 72 additions & 21 deletions test/conformance/testing/include/uur/fixtures.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -455,31 +455,63 @@ struct urProgramTest : urContextTest {
ur_program_handle_t program = nullptr;
};

template <class T> struct urProgramTestWithParam : urContextTestWithParam<T> {
void SetUp() override {
UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam<T>::SetUp());
uur::KernelsEnvironment::instance->LoadSource("foo", 0, il_binary);
ASSERT_SUCCESS(urProgramCreateWithIL(this->context, il_binary->data(),
il_binary->size(), nullptr,
&program));
}

void TearDown() override {
if (program) {
EXPECT_SUCCESS(urProgramRelease(program));
}
UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam<T>::TearDown());
}

std::shared_ptr<std::vector<char>> il_binary;
std::string program_name = "foo";
ur_program_handle_t program = nullptr;
};

inline std::string getKernelName(ur_program_handle_t program) {
size_t kernel_string_size = 0;
if (UR_RESULT_SUCCESS != urProgramGetInfo(program,
UR_PROGRAM_INFO_KERNEL_NAMES, 0,
nullptr, &kernel_string_size)) {
return "";
}
std::string kernel_string;
kernel_string.resize(kernel_string_size);
if (UR_RESULT_SUCCESS !=
urProgramGetInfo(program, UR_PROGRAM_INFO_KERNEL_NAMES,
kernel_string.size(), kernel_string.data(), nullptr)) {
return "";
}
std::stringstream kernel_stream(kernel_string);
std::string kernel_name;
bool found_kernel = false;
// Go through the semi-colon separated list of kernel names looking for
// one that isn't a wrapper or an offset handler.
while (kernel_stream.good()) {
getline(kernel_stream, kernel_name, ';');
if (kernel_name.find("wrapper") == std::string::npos &&
kernel_name.find("offset") == std::string::npos) {
found_kernel = true;
break;
}
}
return found_kernel ? kernel_name : "";
}

struct urKernelTest : urProgramTest {
void SetUp() override {
UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::SetUp());
ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
size_t kernel_string_size = 0;
ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_KERNEL_NAMES,
0, nullptr, &kernel_string_size));
std::string kernel_string;
kernel_string.resize(kernel_string_size);
ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_KERNEL_NAMES,
kernel_string.size(),
kernel_string.data(), nullptr));
std::stringstream kernel_stream(kernel_string);
bool found_kernel = false;
// Go through the semi-colon separated list of kernel names looking for
// one that isn't a wrapper or an offset handler.
while (kernel_stream.good()) {
getline(kernel_stream, kernel_name, ';');
if (kernel_name.find("wrapper") == std::string::npos &&
kernel_name.find("offset") == std::string::npos) {
found_kernel = true;
break;
}
}
ASSERT_TRUE(found_kernel);
kernel_name = getKernelName(program);
ASSERT_FALSE(kernel_name.empty());
}

void TearDown() override {
Expand All @@ -492,6 +524,25 @@ struct urKernelTest : urProgramTest {
std::string kernel_name;
ur_kernel_handle_t kernel = nullptr;
};

template <class T> struct urKernelTestWithParam : urProgramTestWithParam<T> {
void SetUp() override {
UUR_RETURN_ON_FATAL_FAILURE(urProgramTestWithParam<T>::SetUp());
ASSERT_SUCCESS(urProgramBuild(this->context, this->program, nullptr));
kernel_name = getKernelName(this->program);
ASSERT_FALSE(kernel_name.empty());
}

void TearDown() override {
if (kernel) {
EXPECT_SUCCESS(urKernelRelease(kernel));
}
UUR_RETURN_ON_FATAL_FAILURE(urProgramTestWithParam<T>::TearDown());
}

std::string kernel_name;
ur_kernel_handle_t kernel = nullptr;
};
} // namespace uur

#endif // UR_CONFORMANCE_INCLUDE_FIXTURES_H_INCLUDED

0 comments on commit 803871f

Please sign in to comment.