diff --git a/offload/unittests/CMakeLists.txt b/offload/unittests/CMakeLists.txt index b08f7213d5344..a7142ece82e66 100644 --- a/offload/unittests/CMakeLists.txt +++ b/offload/unittests/CMakeLists.txt @@ -141,6 +141,7 @@ function(add_offload_unittest test_dirname) add_unittest(OffloadUnitTests "${target_name}" ${CMAKE_CURRENT_SOURCE_DIR}/common/Environment.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/common/Properties.cpp ${files}) add_dependencies(${target_name} ${PLUGINS_TEST_COMMON} offload_device_binaries) target_compile_definitions(${target_name} PRIVATE DEVICE_CODE_PATH="${OFFLOAD_TEST_DEVICE_CODE_PATH}") diff --git a/offload/unittests/OffloadAPI/CMakeLists.txt b/offload/unittests/OffloadAPI/CMakeLists.txt index d960da4b98f82..4798dc02d0610 100644 --- a/offload/unittests/OffloadAPI/CMakeLists.txt +++ b/offload/unittests/OffloadAPI/CMakeLists.txt @@ -6,8 +6,7 @@ add_subdirectory(device_code) add_offload_unittest("device" device/olIterateDevices.cpp device/olGetDeviceInfo.cpp - device/olGetDeviceInfoSize.cpp - device/olGetHostInfo.cpp) + device/olGetDeviceInfoSize.cpp) add_offload_unittest("event" event/olCreateEvent.cpp diff --git a/offload/unittests/OffloadAPI/common/Fixtures.hpp b/offload/unittests/OffloadAPI/common/Fixtures.hpp index f6b7502c41882..6d940584faef8 100644 --- a/offload/unittests/OffloadAPI/common/Fixtures.hpp +++ b/offload/unittests/OffloadAPI/common/Fixtures.hpp @@ -180,13 +180,16 @@ struct OffloadTest : ::testing::Test { ol_device_handle_t Host = TestEnvironment::getHostDevice(); }; -struct OffloadDeviceTest +template using OffloadParam = std::tuple; + +template +struct OffloadDeviceTestWithParam : OffloadTest, - ::testing::WithParamInterface { + ::testing::WithParamInterface> { void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadTest::SetUp()); - auto DeviceParam = GetParam(); + auto &DeviceParam = std::get<0>(this->GetParam()); Device = DeviceParam.Handle; if (Device == nullptr) GTEST_SKIP() << "No available devices."; @@ -204,14 +207,31 @@ struct OffloadDeviceTest return Backend; } + const OffloadParam &getParamTuple() const { return this->GetParam(); } + + const T &getTestParam() { return std::get<1>(getParamTuple()); } + ol_device_handle_t Device = nullptr; }; -struct OffloadPlatformTest : OffloadDeviceTest { +// In order to avoid code duplication, the unparameterized versions of fixtures +// are aliases for parameterized fixtures, with `int` type chosen arbitrarily as +// an ignored parameter type. The single mock parameter of value `0` is combined +// with the devices in the provided macros, yielding tuples +// `std::tuple`. The hidden `int` parameter is not +// used, but it enables users to instantiate unparameterized tests without the +// knowledge about the details related to the implementation of fixtures. +// Moreover, it allows for modifying only one version of the fixture, without +// the need to also change the other version: either parameterized or +// unparameterized. +using OffloadDeviceTest = OffloadDeviceTestWithParam; + +template +struct OffloadPlatformTestWithParam : OffloadDeviceTestWithParam { void SetUp() override { - RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); + RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam::SetUp()); - ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM, + ASSERT_SUCCESS(olGetDeviceInfo(this->Device, OL_DEVICE_INFO_PLATFORM, sizeof(Platform), &Platform)); ASSERT_NE(Platform, nullptr); } @@ -219,17 +239,20 @@ struct OffloadPlatformTest : OffloadDeviceTest { ol_platform_handle_t Platform = nullptr; }; +using OffloadPlatformTest = OffloadPlatformTestWithParam; + // Fixture for a generic program test. If you want a different program, use // offloadQueueTest and create your own program handle with the binary you want. -struct OffloadProgramTest : OffloadDeviceTest { +template +struct OffloadProgramTestWithParam : OffloadDeviceTestWithParam { void SetUp() override { SetUpWith("foo"); } void SetUpWith(const char *ProgramName) { - RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); - ASSERT_TRUE( - TestEnvironment::loadDeviceBinary(ProgramName, Device, DeviceBin)); + RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam::SetUp()); + ASSERT_TRUE(TestEnvironment::loadDeviceBinary(ProgramName, this->Device, + DeviceBin)); ASSERT_GE(DeviceBin->getBufferSize(), 0lu); - ASSERT_SUCCESS(olCreateProgram(Device, DeviceBin->getBufferStart(), + ASSERT_SUCCESS(olCreateProgram(this->Device, DeviceBin->getBufferStart(), DeviceBin->getBufferSize(), &Program)); } @@ -237,13 +260,15 @@ struct OffloadProgramTest : OffloadDeviceTest { if (Program) { olDestroyProgram(Program); } - RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown()); + RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam::TearDown()); } ol_program_handle_t Program = nullptr; std::unique_ptr DeviceBin; }; +using OffloadProgramTest = OffloadProgramTestWithParam; + struct OffloadKernelTest : OffloadProgramTest { void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUp()); @@ -257,20 +282,24 @@ struct OffloadKernelTest : OffloadProgramTest { ol_symbol_handle_t Kernel = nullptr; }; -struct OffloadGlobalTest : OffloadProgramTest { +template +struct OffloadGlobalTestWithParam : OffloadProgramTestWithParam { void SetUp() override { - RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUpWith("global")); - ASSERT_SUCCESS(olGetSymbol(Program, "global", + RETURN_ON_FATAL_FAILURE( + OffloadProgramTestWithParam::SetUpWith("global")); + ASSERT_SUCCESS(olGetSymbol(this->Program, "global", OL_SYMBOL_KIND_GLOBAL_VARIABLE, &Global)); } void TearDown() override { - RETURN_ON_FATAL_FAILURE(OffloadProgramTest::TearDown()); + RETURN_ON_FATAL_FAILURE(OffloadProgramTestWithParam::TearDown()); } ol_symbol_handle_t Global = nullptr; }; +using OffloadGlobalTest = OffloadGlobalTestWithParam; + struct OffloadQueueTest : OffloadDeviceTest { void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); @@ -338,13 +367,69 @@ struct LaunchSingleKernelTestBase : LaunchKernelTestBase { ol_symbol_handle_t Kernel = nullptr; }; +using DevicesVec = std::vector; + +inline DevicesVec getDevicesAndHost() { + DevicesVec Res(TestEnvironment::getDevices()); + TestEnvironment::Device Host{TestEnvironment::getHostDevice(), "HOST"}; + + Res.push_back(Host); + + return Res; +} + +template +inline std::string +defaultPrinterWithParam(const ::testing::TestParamInfo> &info) { + auto device = std::get<0>(info.param); + auto param = std::get<1>(info.param); + + std::string placeholder; + llvm::raw_string_ostream ss(placeholder); + + ss << device.Name << "__" << param; + + return SanitizeString(ss.str()); +} + +inline std::string +defaultPrinter(const ::testing::TestParamInfo> &info) { + auto device = std::get<0>(info.param); + + return SanitizeString(device.Name); +} + // Devices might not be available for offload testing, so allow uninstantiated // tests (as the device list will be empty). This means that all tests requiring // a device will be silently skipped. +#define OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, DEVICES) \ + INSTANTIATE_TEST_SUITE_P( \ + , FIXTURE, \ + testing::Combine(::testing::ValuesIn(DEVICES), testing::ValuesIn({0})), \ + defaultPrinter); \ + GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FIXTURE) + #define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(FIXTURE) \ + OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, TestEnvironment::getDevices()) + +#define OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE(FIXTURE) \ + OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, getDevicesAndHost()) + +#define OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM(FIXTURE, VALUES, \ + DEVICES, PRINTER) \ INSTANTIATE_TEST_SUITE_P( \ - , FIXTURE, ::testing::ValuesIn(TestEnvironment::getDevices()), \ - [](const ::testing::TestParamInfo &info) { \ - return SanitizeString(info.param.Name); \ - }); \ + , FIXTURE, \ + testing::Combine(::testing::ValuesIn(TestEnvironment::getDevices()), \ + ::testing::ValuesIn(VALUES)), \ + PRINTER); \ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FIXTURE) + +#define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(FIXTURE, VALUES, \ + PRINTER) \ + OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM( \ + FIXTURE, VALUES, TestEnvironment::getDevices(), PRINTER) + +#define OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( \ + FIXTURE, VALUES, PRINTER) \ + OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM( \ + FIXTURE, VALUES, getDevicesAndHost(), PRINTER) diff --git a/offload/unittests/OffloadAPI/common/Properties.cpp b/offload/unittests/OffloadAPI/common/Properties.cpp new file mode 100644 index 0000000000000..4aa1e8e3d2ef8 --- /dev/null +++ b/offload/unittests/OffloadAPI/common/Properties.cpp @@ -0,0 +1,105 @@ +#include "Properties.hpp" + +// ol_device_info_t +DeviceInfoProp PropBool{OL_DEVICE_INFO_SINGLE_FP_SUPPORT, + OL_DEVICE_INFO_DOUBLE_FP_SUPPORT, + OL_DEVICE_INFO_HALF_FP_SUPPORT}; +DeviceInfoProperties BoolProperties = + createPropertiesWithSizeContainer(sizeof(bool), PropBool); + +DeviceInfoProp PropUint32{OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, + OL_DEVICE_INFO_MAX_WORK_SIZE, + OL_DEVICE_INFO_VENDOR_ID, + OL_DEVICE_INFO_NUM_COMPUTE_UNITS, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF, + OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, + OL_DEVICE_INFO_MEMORY_CLOCK_RATE, + OL_DEVICE_INFO_ADDRESS_BITS}; +DeviceInfoProperties Uint32Properties = + createPropertiesWithSizeContainer(sizeof(uint32_t), PropUint32); + +DeviceInfoProp PropUint64{OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, + OL_DEVICE_INFO_GLOBAL_MEM_SIZE, + OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE}; +DeviceInfoProperties Uint64Properties = + createPropertiesWithSizeContainer(sizeof(uint64_t), PropUint64); + +DeviceInfoProp PropCapabilitiesFlags{OL_DEVICE_INFO_SINGLE_FP_CONFIG, + OL_DEVICE_INFO_HALF_FP_CONFIG, + OL_DEVICE_INFO_DOUBLE_FP_CONFIG}; +// sizeof(ol_device_fp_capability_flags_t) == sizeof(uint32_t) +DeviceInfoProperties CapabilitesFlagsProperties = + createPropertiesWithSizeContainer(sizeof(ol_device_fp_capability_flags_t), + PropCapabilitiesFlags); + +DeviceInfoProp PropIrrelevantGTCapabilities = {OL_DEVICE_INFO_HALF_FP_CONFIG}; +DeviceInfoProp Prop_RelevantGTCapabilites = removeIrrelevantProperties( + PropCapabilitiesFlags, PropIrrelevantGTCapabilities); +DeviceInfoProperties RelevantGTCapabilitiesProperties = + createPropertiesWithSizeContainer(sizeof(ol_device_fp_capability_flags_t), + Prop_RelevantGTCapabilites); + +DeviceInfoProp PropIrrelevantGTUint32 = { + OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF}; +DeviceInfoProp Prop_RelevantGTUint32 = + removeIrrelevantProperties(PropUint32, PropIrrelevantGTUint32); +DeviceInfoProperties RelevantGTUint32Properties = + createPropertiesWithSizeContainer(sizeof(uint32_t), Prop_RelevantGTUint32); + +DeviceInfoProp PropDeviceType{OL_DEVICE_INFO_TYPE}; +DeviceInfoProperties DeviceTypeProperties = + createPropertiesWithSizeContainer(sizeof(ol_device_type_t), PropDeviceType); + +DeviceInfoProp PropPlatform{OL_DEVICE_INFO_PLATFORM}; +DeviceInfoProperties PlatformProperties = createPropertiesWithSizeContainer( + sizeof(ol_platform_handle_t), PropPlatform); + +DeviceInfoProp PropNames{OL_DEVICE_INFO_NAME, OL_DEVICE_INFO_PRODUCT_NAME, + OL_DEVICE_INFO_UID, OL_DEVICE_INFO_VENDOR, + OL_DEVICE_INFO_DRIVER_VERSION}; +DeviceInfoProperties NamesProperties = + createPropertiesWithSizeContainer(0, PropNames); + +DeviceInfoProp PropDimensions{OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION, + OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION}; +DeviceInfoProperties DimensionsProperties = + createPropertiesWithSizeContainer(sizeof(ol_dimensions_t), PropDimensions); + +DeviceInfoPropertiesTypes propertiesTypes = + createTypesMap({BoolProperties, Uint32Properties, Uint64Properties, + CapabilitesFlagsProperties}); + +// ol_symbol_info_t +SymbolInfoProp PropSymbolInfoGlobal{OL_SYMBOL_INFO_KIND, + OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS, + OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE}; +SymbolInfoProperties SymbolGlobalProperties{ + {sizeof(ol_symbol_kind_t), OL_SYMBOL_INFO_KIND}, + {sizeof(void *), OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS}, + {sizeof(size_t), OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE}}; + +// ol_platform_info_t +ol_platform_info_t PlatformInfoNames[3] = {OL_PLATFORM_INFO_NAME, + OL_PLATFORM_INFO_VENDOR_NAME, + OL_PLATFORM_INFO_VERSION}; + +// ol_alloc_type_t +ol_alloc_type_t AllocTypes[3] = {OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, + OL_ALLOC_TYPE_HOST}; + +// ol_mem_info_t +MemInfoProp PropMemInfo{OL_MEM_INFO_DEVICE, OL_MEM_INFO_BASE, OL_MEM_INFO_SIZE, + OL_MEM_INFO_TYPE}; +MemInfoProperties MemInfoSizeProperties{ + {sizeof(ol_device_handle_t), OL_MEM_INFO_DEVICE}, + {sizeof(void *), OL_MEM_INFO_BASE}, + {sizeof(size_t), OL_MEM_INFO_SIZE}, + {sizeof(ol_alloc_type_t), OL_MEM_INFO_TYPE}}; + +size_t TestAllocsNum = 1000; \ No newline at end of file diff --git a/offload/unittests/OffloadAPI/common/Properties.hpp b/offload/unittests/OffloadAPI/common/Properties.hpp new file mode 100644 index 0000000000000..c6981f475a58c --- /dev/null +++ b/offload/unittests/OffloadAPI/common/Properties.hpp @@ -0,0 +1,187 @@ +#pragma once + +#include "Fixtures.hpp" +#include "OffloadAPI.h" + +inline constexpr size_t MAX_DEVICE_INFO_BYTES = 8; + +inline constexpr char zeroArray[MAX_DEVICE_INFO_BYTES] = {}; + +template struct SizedProperty { + size_t size; + T property; +}; + +template +using PropertiesWithSizeContainer = std::vector>; +template using PropertiesContainer = std::set; +template +using PropertiesTypes = std::unordered_map>; + +template +auto createPropertiesWithSizeContainer( + size_t PropSize, PropertiesContainer SelectedProperties) + -> PropertiesWithSizeContainer { + PropertiesWithSizeContainer Res; + for (auto p : SelectedProperties) { + Res.push_back({PropSize, p}); + } + + return Res; +} + +template +auto mergeProperties(std::initializer_list> + properties) -> PropertiesWithSizeContainer { + PropertiesWithSizeContainer finalProperties; + + for (auto prop : properties) { + finalProperties.insert(finalProperties.end(), prop.begin(), prop.end()); + } + + return finalProperties; +} + +template +PropertiesContainer +removeIrrelevantProperties(PropertiesContainer base, + PropertiesContainer unwanted) { + PropertiesContainer res(base); + + for (auto prop : unwanted) { + res.erase(prop); + } + + return res; +} + +template +PropertiesTypes inline createTypesMap( + std::initializer_list> properties) { + PropertiesTypes Res; + + for (auto container : properties) { + for (auto prop : container) { + Res.insert({prop.property, prop}); + } + } + + return Res; +} + +// ol_device_info_t +using DeviceInfoProp = PropertiesContainer; +using DeviceInfoProperties = PropertiesWithSizeContainer; +using DeviceInfoPropertiesTypes = PropertiesTypes; + +extern DeviceInfoProp PropBool; +extern DeviceInfoProperties BoolProperties; + +extern DeviceInfoProp PropUint32; +extern DeviceInfoProperties Uint32Properties; + +extern DeviceInfoProp PropUint64; +extern DeviceInfoProperties Uint64Properties; + +extern DeviceInfoProp PropCapabilitiesFlags; +// sizeof(ol_device_fp_capability_flags_t) == sizeof(uint32_t) +extern DeviceInfoProperties CapabilitesFlagsProperties; + +extern DeviceInfoProp PropDeviceType; +extern DeviceInfoProperties DeviceTypeProperties; + +extern DeviceInfoProp PropPlatform; +extern DeviceInfoProperties PlatformProperties; + +extern DeviceInfoProp PropNames; +extern DeviceInfoProperties NamesProperties; + +extern DeviceInfoProp PropDimensions; +extern DeviceInfoProperties DimensionsProperties; + +extern DeviceInfoProperties RelevantGTCapabilitiesProperties; +extern DeviceInfoProperties RelevantGTUint32Properties; + +extern DeviceInfoPropertiesTypes propertiesTypes; + +inline bool defaultCheckIsNonZero(char *buffer) { + return memcmp(buffer, zeroArray, MAX_DEVICE_INFO_BYTES) != 0; +} + +template +inline std::string defaultPropertyTestPrinter( + const ::testing::TestParamInfo>> &info) { + auto device = std::get<0>(info.param); + auto paramData = std::get<1>(info.param); + + std::string ss; + llvm::raw_string_ostream finalName(ss); + + auto property = paramData.property; + finalName << device.Name << "__" << property; + + return SanitizeString(finalName.str()); +} + +template +struct olPropertyTest : OffloadDeviceTestWithParam> { + void SetUp() override { + RETURN_ON_FATAL_FAILURE( + OffloadDeviceTestWithParam>::SetUp()); + + auto paramData = this->getTestParam(); + PropertySize = paramData.size; + Property = paramData.property; + } + + size_t PropertySize = 0; + T Property; +}; + +struct olGetHostDeviceInfoPropertyTest : olPropertyTest { + bool isHost() { return Host == this->Device; } +}; + +struct olGetHostDeviceInfoTest : OffloadDeviceTest { + void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); } + + bool isHost() { return Host == this->Device; } +}; + +// ol_symbol_info +using SymbolInfoTuple = SizedProperty; +using SymbolInfoProp = PropertiesContainer; +using SymbolInfoProperties = PropertiesWithSizeContainer; + +extern SymbolInfoProp PropSymbolInfoGlobal; +extern SymbolInfoProperties SymbolGlobalProperties; + +struct olGetSymbolInfoSizeGlobalTest + : OffloadGlobalTestWithParam { + void SetUp() override { + RETURN_ON_FATAL_FAILURE( + OffloadGlobalTestWithParam::SetUp()); + + auto paramData = this->getTestParam(); + PropertySize = paramData.size; + Property = paramData.property; + } + + size_t PropertySize = 0; + ol_symbol_info_t Property; +}; + +// ol_platform_info_t +extern ol_platform_info_t PlatformInfoNames[3]; + +// ol_alloc_type_t +extern ol_alloc_type_t AllocTypes[3]; + +// ol_mem_info_t +using MemInfoProp = PropertiesContainer; +using MemInfoProperties = PropertiesWithSizeContainer; + +extern MemInfoProp PropMemInfo; +extern MemInfoProperties MemInfoSizeProperties; + +extern size_t TestAllocsNum; diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp index f2ea60cffdf12..9e810ececab53 100644 --- a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp +++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp @@ -6,257 +6,120 @@ // //===----------------------------------------------------------------------===// -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" #include #include -using olGetDeviceInfoTest = OffloadDeviceTest; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoTest); +DeviceInfoProperties JustSupportedProperties = mergeProperties( + {BoolProperties, + {propertiesTypes.at(OL_DEVICE_INFO_HALF_FP_CONFIG), + propertiesTypes.at(OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF)}}); -#define OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Dev, \ - Expr) \ - TEST_P(olGetDeviceInfoTest, Test##Dev##TestName) { \ - PropType Value; \ - ASSERT_SUCCESS(olGetDeviceInfo(Dev, PropName, sizeof(Value), &Value)); \ - Expr; \ - } - -#define OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, {}) - -#define OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, {}) - -#define OL_DEVICE_INFO_TEST_SUCCESS(TestName, PropType, PropName) \ - OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \ - OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) +DeviceInfoProperties NonZeroProperties = + mergeProperties({RelevantGTCapabilitiesProperties, + RelevantGTUint32Properties, Uint64Properties}); -#define OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, \ - LowBound) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, \ - ASSERT_GT(Value, LowBound)) +using olGetHostDeviceInfoPropertySupportTest = olGetHostDeviceInfoPropertyTest; +using olGetHostDeviceInfoPropertyNonZeroTest = olGetHostDeviceInfoPropertyTest; -#define OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, \ - LowBound) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, \ - ASSERT_GT(Value, LowBound)) +OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( + olGetHostDeviceInfoPropertySupportTest, JustSupportedProperties, + defaultPropertyTestPrinter); -#define OL_DEVICE_INFO_TEST_VALUE_GT(TestName, PropType, PropName, LowBound) \ - OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, LowBound) \ - OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, LowBound) +OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( + olGetHostDeviceInfoPropertyNonZeroTest, NonZeroProperties, + defaultPropertyTestPrinter); -TEST_P(olGetDeviceInfoTest, SuccessType) { - ol_device_type_t DeviceType; - ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, - sizeof(ol_device_type_t), &DeviceType)); +// Properties without gt test +TEST_P(olGetHostDeviceInfoPropertySupportTest, Success) { + char Value[MAX_DEVICE_INFO_BYTES]; + ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, PropertySize, &Value)); } -TEST_P(olGetDeviceInfoTest, HostSuccessType) { - ol_device_type_t DeviceType; - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, - sizeof(ol_device_type_t), &DeviceType)); - ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST); -} +TEST_P(olGetHostDeviceInfoPropertyNonZeroTest, Value) { + char Value[MAX_DEVICE_INFO_BYTES] = {}; + ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, PropertySize, &Value)); -TEST_P(olGetDeviceInfoTest, SuccessPlatform) { - ol_platform_handle_t Platform = nullptr; - ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM, - sizeof(ol_platform_handle_t), &Platform)); - ASSERT_NE(Platform, nullptr); + ASSERT_TRUE(defaultCheckIsNonZero(Value)); } -TEST_P(olGetDeviceInfoTest, SuccessName) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Name; - Name.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Device, OL_DEVICE_INFO_NAME, Size, Name.data())); - ASSERT_EQ(std::strlen(Name.data()), Size - 1); -} - -TEST_P(olGetDeviceInfoTest, HostName) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Name; - Name.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data())); - ASSERT_EQ(std::strlen(Name.data()), Size - 1); -} - -TEST_P(olGetDeviceInfoTest, SuccessProductName) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetDeviceInfoSize(Device, OL_DEVICE_INFO_PRODUCT_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Name; - Name.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Device, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data())); - ASSERT_EQ(std::strlen(Name.data()), Size - 1); -} +using olGetDeviceHostInfoNamesTest = olGetHostDeviceInfoPropertyTest; -TEST_P(olGetDeviceInfoTest, SuccessUID) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_UID, &Size)); - ASSERT_GT(Size, 0ul); - std::vector UID; - UID.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_UID, Size, UID.data())); - ASSERT_EQ(std::strlen(UID.data()), Size - 1); -} +OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( + olGetDeviceHostInfoNamesTest, NamesProperties, + defaultPropertyTestPrinter); -TEST_P(olGetDeviceInfoTest, HostProductName) { +TEST_P(olGetDeviceHostInfoNamesTest, SuccessNames) { size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_PRODUCT_NAME, &Size)); + ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size)); ASSERT_GT(Size, 0ul); std::vector Name; Name.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Host, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data())); + ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, Size, Name.data())); ASSERT_EQ(std::strlen(Name.data()), Size - 1); } -TEST_P(olGetDeviceInfoTest, HostUID) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_UID, &Size)); - ASSERT_GT(Size, 0ul); - std::vector UID; - UID.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_UID, Size, UID.data())); - ASSERT_EQ(std::strlen(UID.data()), Size - 1); -} - -TEST_P(olGetDeviceInfoTest, SuccessVendor) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Vendor; - Vendor.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Device, OL_DEVICE_INFO_VENDOR, Size, Vendor.data())); - ASSERT_EQ(std::strlen(Vendor.data()), Size - 1); -} +using olGetHostDeviceInfoDimensionsTest = olGetHostDeviceInfoPropertyTest; -TEST_P(olGetDeviceInfoTest, SuccessDriverVersion) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetDeviceInfoSize(Device, OL_DEVICE_INFO_DRIVER_VERSION, &Size)); - ASSERT_GT(Size, 0ul); - std::vector DriverVersion; - DriverVersion.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_DRIVER_VERSION, Size, - DriverVersion.data())); - ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1); -} +OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( + olGetHostDeviceInfoDimensionsTest, DimensionsProperties, + defaultPropertyTestPrinter); -OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkGroupSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, 0); - -TEST_P(olGetDeviceInfoTest, SuccessMaxWorkGroupSizePerDimension) { +TEST_P(olGetHostDeviceInfoDimensionsTest, Success) { ol_dimensions_t Value{0, 0, 0}; - ASSERT_SUCCESS( - olGetDeviceInfo(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION, - sizeof(Value), &Value)); + ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, sizeof(Value), &Value)); ASSERT_GT(Value.x, 0u); ASSERT_GT(Value.y, 0u); ASSERT_GT(Value.z, 0u); } -OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_SIZE, 0); +OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE(olGetHostDeviceInfoTest); -TEST_P(olGetDeviceInfoTest, SuccessMaxWorkSizePerDimension) { - ol_dimensions_t Value{0, 0, 0}; - ASSERT_SUCCESS(olGetDeviceInfo(Device, - OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION, - sizeof(Value), &Value)); - ASSERT_GT(Value.x, 0u); - ASSERT_GT(Value.y, 0u); - ASSERT_GT(Value.z, 0u); +TEST_P(olGetHostDeviceInfoTest, HostSuccessType) { + ol_device_type_t DeviceType; + ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, + sizeof(ol_device_type_t), &DeviceType)); + + if (isHost()) { + ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST); + } } -OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(VendorId, uint32_t, - OL_DEVICE_INFO_VENDOR_ID, 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID); -OL_DEVICE_INFO_TEST_VALUE_GT(NumComputeUnits, uint32_t, - OL_DEVICE_INFO_NUM_COMPUTE_UNITS, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(SingleFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_SINGLE_FP_CONFIG, 0); -OL_DEVICE_INFO_TEST_SUCCESS(HalfFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_HALF_FP_CONFIG); -OL_DEVICE_INFO_TEST_VALUE_GT(DoubleFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_DOUBLE_FP_CONFIG, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthChar, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthShort, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthInt, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthLong, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthFloat, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthDouble, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, 0); -OL_DEVICE_INFO_TEST_SUCCESS(SingleFPSupport, bool, - OL_DEVICE_INFO_SINGLE_FP_SUPPORT); -OL_DEVICE_INFO_TEST_SUCCESS(DoubleFPSupport, bool, - OL_DEVICE_INFO_DOUBLE_FP_SUPPORT); -OL_DEVICE_INFO_TEST_SUCCESS(HalfFPSupport, bool, - OL_DEVICE_INFO_HALF_FP_SUPPORT); -OL_DEVICE_INFO_TEST_SUCCESS(NativeVectorWidthHalf, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF); -OL_DEVICE_INFO_TEST_VALUE_GT(MaxClockFrequency, uint32_t, - OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(MemoryClockRate, uint32_t, - OL_DEVICE_INFO_MEMORY_CLOCK_RATE, 0); -OL_DEVICE_INFO_TEST_VALUE_GT(AddressBits, uint32_t, OL_DEVICE_INFO_ADDRESS_BITS, - 0); -OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(MaxMemAllocSize, uint64_t, - OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(MaxMemAllocSize, uint64_t, - OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE); -OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(GlobalMemSize, uint64_t, - OL_DEVICE_INFO_GLOBAL_MEM_SIZE, 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(GlobalMemSize, uint64_t, - OL_DEVICE_INFO_GLOBAL_MEM_SIZE); -OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(SharedMemSize, uint64_t, - OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE, - 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(SharedMemSize, uint64_t, - OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE); +TEST_P(olGetHostDeviceInfoTest, SuccessPlatform) { + ol_platform_handle_t Platform = nullptr; + ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM, + sizeof(ol_platform_handle_t), &Platform)); + ASSERT_NE(Platform, nullptr); +} -TEST_P(olGetDeviceInfoTest, InvalidNullHandleDevice) { +TEST_P(olGetHostDeviceInfoTest, InvalidNullHandleDevice) { ol_device_type_t DeviceType; ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE, sizeof(ol_device_type_t), &DeviceType)); } -TEST_P(olGetDeviceInfoTest, InvalidEnumerationInfoType) { +TEST_P(olGetHostDeviceInfoTest, InvalidEnumerationInfoType) { ol_device_type_t DeviceType; ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION, olGetDeviceInfo(Device, OL_DEVICE_INFO_FORCE_UINT32, sizeof(ol_device_type_t), &DeviceType)); } -TEST_P(olGetDeviceInfoTest, InvalidSizePropSize) { +TEST_P(olGetHostDeviceInfoTest, InvalidPropSize) { ol_device_type_t DeviceType; ASSERT_ERROR(OL_ERRC_INVALID_SIZE, olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, 0, &DeviceType)); } -TEST_P(olGetDeviceInfoTest, InvalidSizePropSizeSmall) { +TEST_P(olGetHostDeviceInfoTest, InvalidPropSizeSmall) { ol_device_type_t DeviceType; ASSERT_ERROR(OL_ERRC_INVALID_SIZE, olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, sizeof(DeviceType) - 1, &DeviceType)); } -TEST_P(olGetDeviceInfoTest, InvalidNullPointerPropValue) { +TEST_P(olGetHostDeviceInfoTest, InvalidNullPointerPropValue) { ol_device_type_t DeviceType; ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, sizeof(DeviceType), diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp index 2c375eb555a48..82e0d36f027d9 100644 --- a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp +++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp @@ -6,73 +6,38 @@ // //===----------------------------------------------------------------------===// +#include "../common/Properties.hpp" #include -#include "../common/Fixtures.hpp" - using olGetDeviceInfoSizeTest = OffloadDeviceTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoSizeTest); -#define OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, Expr) \ - TEST_P(olGetDeviceInfoSizeTest, Success##TestName) { \ - size_t Size = 0; \ - ASSERT_SUCCESS(olGetDeviceInfoSize(Device, PropName, &Size)); \ - Expr; \ - } +using olGetDeviceInfoSizeEqualTest = olGetHostDeviceInfoPropertyTest; +using olGetDeviceInfoSizeNonZeroTest = olGetHostDeviceInfoPropertyTest; + +DeviceInfoProperties answerSizeEqualToTypeSizeProperties = mergeProperties( + {Uint32Properties, Uint64Properties, CapabilitesFlagsProperties, + PlatformProperties, DeviceTypeProperties}); -#define OL_DEVICE_INFO_SIZE_TEST_EQ(TestName, PropType, PropName) \ - OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, \ - ASSERT_EQ(Size, sizeof(PropType))); +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetDeviceInfoSizeEqualTest, answerSizeEqualToTypeSizeProperties, + defaultPropertyTestPrinter); -#define OL_DEVICE_INFO_SIZE_TEST_NONZERO(TestName, PropName) \ - OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, ASSERT_NE(Size, 0ul)); +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetDeviceInfoSizeNonZeroTest, NamesProperties, + defaultPropertyTestPrinter); -OL_DEVICE_INFO_SIZE_TEST_EQ(Type, ol_device_type_t, OL_DEVICE_INFO_TYPE); -OL_DEVICE_INFO_SIZE_TEST_EQ(Platform, ol_platform_handle_t, - OL_DEVICE_INFO_PLATFORM); -OL_DEVICE_INFO_SIZE_TEST_NONZERO(Name, OL_DEVICE_INFO_NAME); -OL_DEVICE_INFO_SIZE_TEST_NONZERO(ProductName, OL_DEVICE_INFO_PRODUCT_NAME); -OL_DEVICE_INFO_SIZE_TEST_NONZERO(UID, OL_DEVICE_INFO_UID); -OL_DEVICE_INFO_SIZE_TEST_NONZERO(Vendor, OL_DEVICE_INFO_VENDOR); -OL_DEVICE_INFO_SIZE_TEST_NONZERO(DriverVersion, OL_DEVICE_INFO_DRIVER_VERSION); -OL_DEVICE_INFO_SIZE_TEST_EQ(MaxWorkGroupSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE); -OL_DEVICE_INFO_SIZE_TEST_EQ(MaxWorkSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_SIZE); -OL_DEVICE_INFO_SIZE_TEST_EQ(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID); -OL_DEVICE_INFO_SIZE_TEST_EQ(NumComputeUnits, uint32_t, - OL_DEVICE_INFO_NUM_COMPUTE_UNITS); -OL_DEVICE_INFO_SIZE_TEST_EQ(SingleFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_SINGLE_FP_CONFIG); -OL_DEVICE_INFO_SIZE_TEST_EQ(HalfFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_HALF_FP_CONFIG); -OL_DEVICE_INFO_SIZE_TEST_EQ(DoubleFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_DOUBLE_FP_CONFIG); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthChar, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthShort, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthInt, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthLong, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthFloat, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthDouble, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE); -OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthHalf, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF); -OL_DEVICE_INFO_SIZE_TEST_EQ(MaxClockFrequency, uint32_t, - OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY); -OL_DEVICE_INFO_SIZE_TEST_EQ(MemoryClockRate, uint32_t, - OL_DEVICE_INFO_MEMORY_CLOCK_RATE); -OL_DEVICE_INFO_SIZE_TEST_EQ(AddressBits, uint32_t, OL_DEVICE_INFO_ADDRESS_BITS); -OL_DEVICE_INFO_SIZE_TEST_EQ(MaxMemAllocSize, uint64_t, - OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE); -OL_DEVICE_INFO_SIZE_TEST_EQ(GlobalMemSize, uint64_t, - OL_DEVICE_INFO_GLOBAL_MEM_SIZE); -OL_DEVICE_INFO_SIZE_TEST_EQ(SharedMemSize, uint64_t, - OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE); +TEST_P(olGetDeviceInfoSizeEqualTest, Success) { + size_t Size = 0; + ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size)); + ASSERT_EQ(PropertySize, Size); +} + +TEST_P(olGetDeviceInfoSizeNonZeroTest, Success) { + size_t Size = 0; + ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size)); + ASSERT_NE(Size, 0ul); +} TEST_P(olGetDeviceInfoSizeTest, SuccessMaxWorkGroupSizePerDimension) { size_t Size = 0; diff --git a/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp b/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp deleted file mode 100644 index debd29e0bb190..0000000000000 --- a/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp +++ /dev/null @@ -1,195 +0,0 @@ -//===------- Offload API tests - olGetHostInfo ---------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#include "../common/Fixtures.hpp" -#include -#include - -using olGetHostInfoTest = OffloadTest; - -#define OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Dev, \ - Expr) \ - TEST_F(olGetHostInfoTest, Test##Dev##TestName) { \ - PropType Value; \ - ASSERT_SUCCESS(olGetDeviceInfo(Dev, PropName, sizeof(Value), &Value)); \ - Expr; \ - } - -#define OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, {}) - -#define OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, \ - LowBound) \ - OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, \ - ASSERT_GT(Value, LowBound)) - -TEST_F(olGetHostInfoTest, HostSuccessType) { - ol_device_type_t DeviceType; - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, - sizeof(ol_device_type_t), &DeviceType)); - ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST); -} - -TEST_F(olGetHostInfoTest, SuccessHostPlatform) { - ol_platform_handle_t Platform = nullptr; - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_PLATFORM, - sizeof(ol_platform_handle_t), &Platform)); - ASSERT_NE(Platform, nullptr); -} - -TEST_F(olGetHostInfoTest, HostName) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Name; - Name.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data())); - ASSERT_EQ(std::strlen(Name.data()), Size - 1); -} - -TEST_F(olGetHostInfoTest, HostProductName) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_PRODUCT_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Name; - Name.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Host, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data())); - ASSERT_EQ(std::strlen(Name.data()), Size - 1); -} - -TEST_F(olGetHostInfoTest, HostUID) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_UID, &Size)); - ASSERT_GT(Size, 0ul); - std::vector UID; - UID.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_UID, Size, UID.data())); - ASSERT_EQ(std::strlen(UID.data()), Size - 1); -} - -TEST_F(olGetHostInfoTest, SuccessHostVendor) { - size_t Size = 0; - ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_VENDOR, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Vendor; - Vendor.resize(Size); - ASSERT_SUCCESS( - olGetDeviceInfo(Host, OL_DEVICE_INFO_VENDOR, Size, Vendor.data())); - ASSERT_EQ(std::strlen(Vendor.data()), Size - 1); -} - -TEST_F(olGetHostInfoTest, SuccessHostDriverVersion) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetDeviceInfoSize(Host, OL_DEVICE_INFO_DRIVER_VERSION, &Size)); - ASSERT_GT(Size, 0ul); - std::vector DriverVersion; - DriverVersion.resize(Size); - ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_DRIVER_VERSION, Size, - DriverVersion.data())); - ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1); -} - -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxWorkGroupSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, 0); - -TEST_F(olGetHostInfoTest, SuccessHostMaxWorkGroupSizePerDimension) { - ol_dimensions_t Value{0, 0, 0}; - ASSERT_SUCCESS( - olGetDeviceInfo(Host, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION, - sizeof(Value), &Value)); - ASSERT_GT(Value.x, 0u); - ASSERT_GT(Value.y, 0u); - ASSERT_GT(Value.z, 0u); -} - -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxWorkSize, uint32_t, - OL_DEVICE_INFO_MAX_WORK_SIZE, 0); - -TEST_F(olGetHostInfoTest, SuccessHostMaxWorkSizePerDimension) { - ol_dimensions_t Value{0, 0, 0}; - ASSERT_SUCCESS(olGetDeviceInfo( - Host, OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION, sizeof(Value), &Value)); - ASSERT_GT(Value.x, 0u); - ASSERT_GT(Value.y, 0u); - ASSERT_GT(Value.z, 0u); -} - -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID, - 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NumComputeUnits, uint32_t, - OL_DEVICE_INFO_NUM_COMPUTE_UNITS, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(SingleFPConfig, - ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_SINGLE_FP_CONFIG, 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(HalfFPConfig, ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_HALF_FP_CONFIG); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(DoubleFPConfig, - ol_device_fp_capability_flags_t, - OL_DEVICE_INFO_DOUBLE_FP_CONFIG, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthChar, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthShort, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthInt, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthLong, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthFloat, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthDouble, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, 0); -OL_DEVICE_INFO_TEST_HOST_SUCCESS(NativeVectorWidthHalf, uint32_t, - OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxClockFrequency, uint32_t, - OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MemoryClockRate, uint32_t, - OL_DEVICE_INFO_MEMORY_CLOCK_RATE, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(AddressBits, uint32_t, - OL_DEVICE_INFO_ADDRESS_BITS, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxMemAllocSize, uint64_t, - OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(GlobalMemSize, uint64_t, - OL_DEVICE_INFO_GLOBAL_MEM_SIZE, 0); -OL_DEVICE_INFO_TEST_HOST_VALUE_GT(SharedMemSize, uint64_t, - OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE, 0); - -TEST_F(olGetHostInfoTest, InvalidNullHandleDevice) { - ol_device_type_t DeviceType; - ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, - olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE, - sizeof(ol_device_type_t), &DeviceType)); -} - -TEST_F(olGetHostInfoTest, InvalidEnumerationInfoType) { - ol_device_type_t DeviceType; - ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION, - olGetDeviceInfo(Host, OL_DEVICE_INFO_FORCE_UINT32, - sizeof(ol_device_type_t), &DeviceType)); -} - -TEST_F(olGetHostInfoTest, InvalidSizePropSize) { - ol_device_type_t DeviceType; - ASSERT_ERROR(OL_ERRC_INVALID_SIZE, - olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, 0, &DeviceType)); -} - -TEST_F(olGetHostInfoTest, InvalidSizePropSizeSmall) { - ol_device_type_t DeviceType; - ASSERT_ERROR(OL_ERRC_INVALID_SIZE, - olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, - sizeof(DeviceType) - 1, &DeviceType)); -} - -TEST_F(olGetHostInfoTest, InvalidNullPointerPropValue) { - ol_device_type_t DeviceType; - ASSERT_ERROR( - OL_ERRC_INVALID_NULL_POINTER, - olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, sizeof(DeviceType), nullptr)); -} diff --git a/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp b/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp index a4b382ff298ad..ba1d52cdc7edd 100644 --- a/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp +++ b/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp @@ -6,94 +6,76 @@ // //===----------------------------------------------------------------------===// -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" #include #include constexpr size_t SIZE = 1024; -struct olGetMemInfoBaseTest : OffloadDeviceTest { - void *OffsetPtr() { return &reinterpret_cast(Ptr)[123]; } +struct olGetMemInfoAllocTypeTest : OffloadDeviceTestWithParam { + void SetUp() override { + RETURN_ON_FATAL_FAILURE( + OffloadDeviceTestWithParam::SetUp()); + ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), SIZE, &Ptr)); + } + + void TearDown() override { + ASSERT_SUCCESS(olMemFree(Ptr)); + RETURN_ON_FATAL_FAILURE( + OffloadDeviceTestWithParam::TearDown()); + } void *Ptr; }; -template -struct olGetMemInfoTest : olGetMemInfoBaseTest { +struct olGetMemInfoTest : OffloadDeviceTest { void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); - ASSERT_SUCCESS(olMemAlloc(Device, AllocType, SIZE, &Ptr)); + ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, SIZE, &Ptr)); } void TearDown() override { ASSERT_SUCCESS(olMemFree(Ptr)); RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown()); } + + void *Ptr; }; -using olGetMemInfoDeviceTest = olGetMemInfoTest; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoDeviceTest); -using olGetMemInfoManagedTest = olGetMemInfoTest; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoManagedTest); -using olGetMemInfoHostTest = olGetMemInfoTest; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoHostTest); - -#define PER_ALLOC_TEST(FUNCTION) \ - TEST_P(olGetMemInfoDeviceTest, FUNCTION) { \ - FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \ - } \ - TEST_P(olGetMemInfoManagedTest, FUNCTION) { \ - FUNCTION(this, Ptr, OL_ALLOC_TYPE_MANAGED); \ - } \ - TEST_P(olGetMemInfoHostTest, FUNCTION) { \ - FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \ - } \ - TEST_P(olGetMemInfoDeviceTest, FUNCTION##Offset) { \ - FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \ - } \ - TEST_P(olGetMemInfoManagedTest, FUNCTION##Offset) { \ - FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_MANAGED); \ - } \ - TEST_P(olGetMemInfoHostTest, FUNCTION##Offset) { \ - FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \ - } -void SuccessDevice(olGetMemInfoBaseTest *Fixture, void *Ptr, - ol_alloc_type_t Type) { +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetMemInfoAllocTypeTest, AllocTypes, + defaultPrinterWithParam); +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoTest); + +TEST_P(olGetMemInfoAllocTypeTest, SuccessDevice) { ol_device_handle_t RetrievedDevice; - ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_DEVICE, - sizeof(RetrievedDevice), &RetrievedDevice)); - ASSERT_EQ(RetrievedDevice, Fixture->Device); + ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, sizeof(RetrievedDevice), + &RetrievedDevice)); + ASSERT_EQ(RetrievedDevice, Device); } -PER_ALLOC_TEST(SuccessDevice); -void SuccessBase(olGetMemInfoBaseTest *Fixture, void *Ptr, - ol_alloc_type_t Type) { +TEST_P(olGetMemInfoAllocTypeTest, SuccessBase) { void *RetrievedBase; - ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_BASE, - sizeof(RetrievedBase), &RetrievedBase)); - ASSERT_EQ(RetrievedBase, Fixture->Ptr); + ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_BASE, sizeof(RetrievedBase), + &RetrievedBase)); + ASSERT_EQ(RetrievedBase, Ptr); } -PER_ALLOC_TEST(SuccessBase); -void SuccessSize(olGetMemInfoBaseTest *Fixture, void *Ptr, - ol_alloc_type_t Type) { +TEST_P(olGetMemInfoAllocTypeTest, SuccessSize) { size_t RetrievedSize; - ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_SIZE, - sizeof(RetrievedSize), &RetrievedSize)); + ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_SIZE, sizeof(RetrievedSize), + &RetrievedSize)); ASSERT_EQ(RetrievedSize, SIZE); } -PER_ALLOC_TEST(SuccessSize); -void SuccessType(olGetMemInfoBaseTest *Fixture, void *Ptr, - ol_alloc_type_t Type) { +TEST_P(olGetMemInfoAllocTypeTest, SuccessType) { ol_alloc_type_t RetrievedType; - ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_TYPE, - sizeof(RetrievedType), &RetrievedType)); - ASSERT_EQ(RetrievedType, Type); + ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_TYPE, sizeof(RetrievedType), + &RetrievedType)); + ASSERT_EQ(RetrievedType, getTestParam()); } -PER_ALLOC_TEST(SuccessType); -TEST_P(olGetMemInfoDeviceTest, InvalidNotFound) { +TEST_P(olGetMemInfoTest, InvalidNotFound) { // Assuming that we aren't unlucky and happen to get 0x1234 as a random // pointer void *RetrievedBase; @@ -102,27 +84,27 @@ TEST_P(olGetMemInfoDeviceTest, InvalidNotFound) { sizeof(RetrievedBase), &RetrievedBase)); } -TEST_P(olGetMemInfoDeviceTest, InvalidNullPtr) { +TEST_P(olGetMemInfoTest, InvalidNullPtr) { ol_device_handle_t RetrievedDevice; ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olGetMemInfo(nullptr, OL_MEM_INFO_DEVICE, sizeof(RetrievedDevice), &RetrievedDevice)); } -TEST_P(olGetMemInfoDeviceTest, InvalidSizeZero) { +TEST_P(olGetMemInfoTest, InvalidSizeZero) { ol_device_handle_t RetrievedDevice; ASSERT_ERROR(OL_ERRC_INVALID_SIZE, olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, 0, &RetrievedDevice)); } -TEST_P(olGetMemInfoDeviceTest, InvalidSizeSmall) { +TEST_P(olGetMemInfoTest, InvalidSizeSmall) { ol_device_handle_t RetrievedDevice; ASSERT_ERROR(OL_ERRC_INVALID_SIZE, olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, sizeof(RetrievedDevice) - 1, &RetrievedDevice)); } -TEST_P(olGetMemInfoDeviceTest, InvalidNullPointerPropValue) { +TEST_P(olGetMemInfoTest, InvalidNullPointerPropValue) { ol_device_handle_t RetrievedDevice; ASSERT_ERROR( OL_ERRC_INVALID_NULL_POINTER, diff --git a/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp b/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp index f1a1e790fb22f..7e0ffaacea19d 100644 --- a/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp +++ b/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp @@ -8,7 +8,27 @@ #include -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" + +struct olGetMemInfoSizeTypesTest : olPropertyTest { + void *OffsetPtr() { return &reinterpret_cast(Ptr)[123]; } + + void SetUp() override { + RETURN_ON_FATAL_FAILURE(olPropertyTest::SetUp()); + ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 0x1024, &Ptr)); + } + + void TearDown() override { + ASSERT_SUCCESS(olMemFree(Ptr)); + RETURN_ON_FATAL_FAILURE(olPropertyTest::TearDown()); + } + + void *Ptr; +}; + +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetMemInfoSizeTypesTest, MemInfoSizeProperties, + defaultPropertyTestPrinter); struct olGetMemInfoSizeTest : OffloadDeviceTest { void *OffsetPtr() { return &reinterpret_cast(Ptr)[123]; } @@ -25,30 +45,13 @@ struct olGetMemInfoSizeTest : OffloadDeviceTest { void *Ptr; }; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoSizeTest); - -TEST_P(olGetMemInfoSizeTest, SuccessDevice) { - size_t Size = 0; - ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_DEVICE, &Size)); - ASSERT_EQ(Size, sizeof(ol_device_handle_t)); -} -TEST_P(olGetMemInfoSizeTest, SuccessBase) { - size_t Size = 0; - ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_BASE, &Size)); - ASSERT_EQ(Size, sizeof(void *)); -} - -TEST_P(olGetMemInfoSizeTest, SuccessSize) { - size_t Size = 0; - ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_SIZE, &Size)); - ASSERT_EQ(Size, sizeof(size_t)); -} +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoSizeTest); -TEST_P(olGetMemInfoSizeTest, SuccessType) { +TEST_P(olGetMemInfoSizeTypesTest, Success) { size_t Size = 0; - ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_TYPE, &Size)); - ASSERT_EQ(Size, sizeof(ol_alloc_type_t)); + ASSERT_SUCCESS(olGetMemInfoSize(Ptr, Property, &Size)); + ASSERT_EQ(Size, PropertySize); } TEST_P(olGetMemInfoSizeTest, InvalidSymbolInfoEnumeration) { diff --git a/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp b/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp index 445262aa0c583..08e95b6dfe7c8 100644 --- a/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp +++ b/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp @@ -6,44 +6,32 @@ // //===----------------------------------------------------------------------===// -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" #include #include using olMemAllocTest = OffloadDeviceTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemAllocTest); -TEST_P(olMemAllocTest, SuccessAllocManaged) { - void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED, 1024, &Alloc)); - ASSERT_NE(Alloc, nullptr); - olMemFree(Alloc); -} - -TEST_P(olMemAllocTest, SuccessAllocHost) { - void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_HOST, 1024, &Alloc)); - ASSERT_NE(Alloc, nullptr); - olMemFree(Alloc); -} +using olMemAllocAllocTypesTest = OffloadDeviceTestWithParam; +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olMemAllocAllocTypesTest, AllocTypes, + defaultPrinterWithParam); // printerMine); -TEST_P(olMemAllocTest, SuccessAllocDevice) { +TEST_P(olMemAllocAllocTypesTest, Success) { void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 1024, &Alloc)); + ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), 1024, &Alloc)); ASSERT_NE(Alloc, nullptr); olMemFree(Alloc); } TEST_P(olMemAllocTest, SuccessAllocMany) { std::vector Allocs; - Allocs.reserve(1000); - - constexpr ol_alloc_type_t TYPES[3] = { - OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, OL_ALLOC_TYPE_HOST}; + Allocs.reserve(TestAllocsNum); - for (size_t I = 1; I < 1000; I++) { + for (size_t I = 1; I < TestAllocsNum; I++) { void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, TYPES[I % 3], 1024 * I, &Alloc)); + ASSERT_SUCCESS(olMemAlloc(Device, AllocTypes[I % 3], 1024 * I, &Alloc)); ASSERT_NE(Alloc, nullptr); Allocs.push_back(Alloc); diff --git a/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp b/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp index 18feafbf2b325..6e26cc0d635ae 100644 --- a/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp +++ b/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp @@ -6,27 +6,27 @@ // //===----------------------------------------------------------------------===// -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" #include #include using olMemAllocAlignedTest = OffloadDeviceTest; - OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemAllocAlignedTest); +using olMemAllocAlignedTypesTest = OffloadDeviceTestWithParam; +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olMemAllocAlignedTypesTest, AllocTypes, + defaultPrinterWithParam); + constexpr size_t DefaultAlignment = 16; -constexpr size_t TestAllocsNum = 1000; TEST_P(olMemAllocAlignedTest, SuccessAllocMany) { std::vector Allocs; - Allocs.reserve(1000); - - constexpr ol_alloc_type_t TYPES[3] = { - OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, OL_ALLOC_TYPE_HOST}; + Allocs.reserve(TestAllocsNum); for (size_t I = 1; I < TestAllocsNum; I++) { void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAllocAligned(Device, TYPES[I % 3], 1024 * I, + ASSERT_SUCCESS(olMemAllocAligned(Device, AllocTypes[I % 3], 1024 * I, DefaultAlignment, &Alloc)); ASSERT_NE(Alloc, nullptr); @@ -80,110 +80,24 @@ TEST_P(olMemAllocAlignedTest, CudaExceedDefaultAlignment) { ASSERT_EQ(Alloc, nullptr); } -TEST_P(olMemAllocAlignedTest, SuccessAllocManagedDifferentAlignments) { +TEST_P(olMemAllocAlignedTypesTest, SuccessAllocDifferentAlignments) { void *Alloc = nullptr; - size_t NumAlignments = 6; size_t Alignments[] = {8, 16, 32, 64, 128, 256}; + size_t NumAlignments = sizeof(Alignments) / sizeof(Alignments[0]); size_t Alignment; - for (size_t i = 0; i < NumAlignments; i++) { - Alignment = Alignments[i]; - SCOPED_TRACE("alignment: " + std::to_string(Alignment)); - ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_MANAGED, 1024, - Alignment, &Alloc)); - ASSERT_NE(Alloc, nullptr); - olMemFree(Alloc); - } -} - -TEST_P(olMemAllocAlignedTest, SuccessAllocHostDifferentAlignments) { - void *Alloc = nullptr; - size_t NumAlignments = 6; - size_t Alignments[] = {8, 16, 32, 64, 128, 256}; - size_t Alignment; for (size_t i = 0; i < NumAlignments; i++) { Alignment = Alignments[i]; SCOPED_TRACE("alignment: " + std::to_string(Alignment)); ASSERT_SUCCESS( - olMemAllocAligned(Device, OL_ALLOC_TYPE_HOST, 1024, Alignment, &Alloc)); + olMemAllocAligned(Device, getTestParam(), 1024, Alignment, &Alloc)); ASSERT_NE(Alloc, nullptr); olMemFree(Alloc); } } -TEST_P(olMemAllocAlignedTest, SuccessAllocDeviceDifferentAlignments) { - void *Alloc = nullptr; - size_t NumAlignments = 6; - size_t Alignments[] = {8, 16, 32, 64, 128, 256}; - size_t Alignment; - - for (size_t i = 0; i < NumAlignments; i++) { - Alignment = Alignments[i]; - SCOPED_TRACE("alignment: " + std::to_string(Alignment)); - ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_DEVICE, 1024, - Alignment, &Alloc)); - ASSERT_NE(Alloc, nullptr); - - olMemFree(Alloc); - } -} - -TEST_P(olMemAllocAlignedTest, SuccessMemcpyManagedDiferentAlignments) { - constexpr size_t Size = 1024; - void *Alloc; - std::vector Input(Size, 42); - std::vector Output(Size, 0); - - size_t NumAlignments = 6; - size_t Alignments[] = {8, 16, 32, 64, 128, 256}; - size_t Alignment; - for (size_t i = 0; i < NumAlignments; i++) { - Alignment = Alignments[i]; - SCOPED_TRACE("alignment: " + std::to_string(Alignment)); - - ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_MANAGED, Size, - Alignment, &Alloc)); - // memcpy is synchronous when queue is unspecified. - ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size)); - ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size)); - - for (uint8_t Val : Output) { - ASSERT_EQ(Val, 42); - } - - ASSERT_SUCCESS(olMemFree(Alloc)); - } -} - -TEST_P(olMemAllocAlignedTest, SuccessMemcpyDeviceDiferentAlignments) { - constexpr size_t Size = 1024; - void *Alloc; - std::vector Input(Size, 42); - std::vector Output(Size, 0); - - size_t NumAlignments = 6; - size_t Alignments[] = {8, 16, 32, 64, 128, 256}; - size_t Alignment; - for (size_t i = 0; i < NumAlignments; i++) { - Alignment = Alignments[i]; - SCOPED_TRACE("alignment: " + std::to_string(Alignment)); - - ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_DEVICE, Size, - Alignment, &Alloc)); - // memcpy is synchronous when queue is unspecified. - ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size)); - ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size)); - - for (uint8_t Val : Output) { - ASSERT_EQ(Val, 42); - } - - ASSERT_SUCCESS(olMemFree(Alloc)); - } -} - -TEST_P(olMemAllocAlignedTest, SuccessMemcpyHostDiferentAlignments) { +TEST_P(olMemAllocAlignedTypesTest, SuccessMemcpyDiferentAlignments) { constexpr size_t Size = 1024; void *Alloc; std::vector Input(Size, 42); @@ -197,7 +111,7 @@ TEST_P(olMemAllocAlignedTest, SuccessMemcpyHostDiferentAlignments) { SCOPED_TRACE("alignment: " + std::to_string(Alignment)); ASSERT_SUCCESS( - olMemAllocAligned(Device, OL_ALLOC_TYPE_HOST, Size, Alignment, &Alloc)); + olMemAllocAligned(Device, getTestParam(), Size, Alignment, &Alloc)); // memcpy is synchronous when queue is unspecified. ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size)); ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size)); diff --git a/offload/unittests/OffloadAPI/memory/olMemFree.cpp b/offload/unittests/OffloadAPI/memory/olMemFree.cpp index dfaf9bdef3189..54782396008ed 100644 --- a/offload/unittests/OffloadAPI/memory/olMemFree.cpp +++ b/offload/unittests/OffloadAPI/memory/olMemFree.cpp @@ -6,28 +6,21 @@ // //===----------------------------------------------------------------------===// -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" #include #include using olMemFreeTest = OffloadDeviceTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemFreeTest); -TEST_P(olMemFreeTest, SuccessFreeManaged) { - void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED, 1024, &Alloc)); - ASSERT_SUCCESS(olMemFree(Alloc)); -} - -TEST_P(olMemFreeTest, SuccessFreeHost) { - void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_HOST, 1024, &Alloc)); - ASSERT_SUCCESS(olMemFree(Alloc)); -} +using olMemFreeAllocTypesTest = OffloadDeviceTestWithParam; +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olMemFreeAllocTypesTest, AllocTypes, + defaultPrinterWithParam); -TEST_P(olMemFreeTest, SuccessFreeDevice) { +TEST_P(olMemFreeAllocTypesTest, Success) { void *Alloc = nullptr; - ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 1024, &Alloc)); + ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), 1024, &Alloc)); ASSERT_SUCCESS(olMemFree(Alloc)); } diff --git a/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp b/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp index 862b008fb9e85..f95ecd21e1232 100644 --- a/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp +++ b/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp @@ -8,46 +8,28 @@ #include -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" using olGetPlatformInfoTest = OffloadPlatformTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetPlatformInfoTest); -TEST_P(olGetPlatformInfoTest, SuccessName) { +using olGetPlatformInfoNamesTest = + OffloadPlatformTestWithParam; +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetPlatformInfoNamesTest, PlatformInfoNames, + defaultPrinterWithParam); + +TEST_P(olGetPlatformInfoNamesTest, SuccessName) { size_t Size = 0; - ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_NAME, &Size)); + ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, getTestParam(), &Size)); ASSERT_GT(Size, 0ul); std::vector Name; Name.resize(Size); ASSERT_SUCCESS( - olGetPlatformInfo(Platform, OL_PLATFORM_INFO_NAME, Size, Name.data())); + olGetPlatformInfo(Platform, getTestParam(), Size, Name.data())); ASSERT_EQ(std::strlen(Name.data()), Size - 1); } -TEST_P(olGetPlatformInfoTest, SuccessVendorName) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VENDOR_NAME, &Size)); - ASSERT_GT(Size, 0ul); - std::vector VendorName; - VendorName.resize(Size); - ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_VENDOR_NAME, Size, - VendorName.data())); - ASSERT_EQ(std::strlen(VendorName.data()), Size - 1); -} - -TEST_P(olGetPlatformInfoTest, SuccessVersion) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VERSION, &Size)); - ASSERT_GT(Size, 0ul); - std::vector Version; - Version.resize(Size); - ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_VERSION, Size, - Version.data())); - ASSERT_EQ(std::strlen(Version.data()), Size - 1); -} - TEST_P(olGetPlatformInfoTest, SuccessBackend) { ol_platform_backend_t Backend; ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_BACKEND, diff --git a/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp b/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp index 9ed9835ff945e..b7478bc64d2cb 100644 --- a/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp +++ b/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp @@ -8,28 +8,20 @@ #include -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" using olGetPlatformInfoSizeTest = OffloadPlatformTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetPlatformInfoSizeTest); -TEST_P(olGetPlatformInfoSizeTest, SuccessName) { - size_t Size = 0; - ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_NAME, &Size)); - ASSERT_NE(Size, 0ul); -} +using olGetPlatformInfoSizeNameTest = + OffloadPlatformTestWithParam; +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetPlatformInfoSizeNameTest, PlatformInfoNames, + defaultPrinterWithParam); -TEST_P(olGetPlatformInfoSizeTest, SuccessVendorName) { +TEST_P(olGetPlatformInfoSizeNameTest, Success) { size_t Size = 0; - ASSERT_SUCCESS( - olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VENDOR_NAME, &Size)); - ASSERT_NE(Size, 0ul); -} - -TEST_P(olGetPlatformInfoSizeTest, SuccessVersion) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VERSION, &Size)); + ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, getTestParam(), &Size)); ASSERT_NE(Size, 0ul); } diff --git a/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp b/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp index ec011865cc6ad..60c1a6767b13b 100644 --- a/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp +++ b/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp @@ -8,38 +8,25 @@ #include -#include "../common/Fixtures.hpp" +#include "../common/Properties.hpp" using olGetSymbolInfoSizeKernelTest = OffloadKernelTest; OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetSymbolInfoSizeKernelTest); -using olGetSymbolInfoSizeGlobalTest = OffloadGlobalTest; -OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetSymbolInfoSizeGlobalTest); +OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM( + olGetSymbolInfoSizeGlobalTest, SymbolGlobalProperties, + defaultPropertyTestPrinter); -TEST_P(olGetSymbolInfoSizeKernelTest, SuccessKind) { +TEST_P(olGetSymbolInfoSizeKernelTest, SuccessPropertySize) { size_t Size = 0; ASSERT_SUCCESS(olGetSymbolInfoSize(Kernel, OL_SYMBOL_INFO_KIND, &Size)); ASSERT_EQ(Size, sizeof(ol_symbol_kind_t)); } -TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessKind) { +TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessPropertySize) { size_t Size = 0; - ASSERT_SUCCESS(olGetSymbolInfoSize(Global, OL_SYMBOL_INFO_KIND, &Size)); - ASSERT_EQ(Size, sizeof(ol_symbol_kind_t)); -} - -TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessAddress) { - size_t Size = 0; - ASSERT_SUCCESS(olGetSymbolInfoSize( - Global, OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS, &Size)); - ASSERT_EQ(Size, sizeof(void *)); -} - -TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessSize) { - size_t Size = 0; - ASSERT_SUCCESS( - olGetSymbolInfoSize(Global, OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE, &Size)); - ASSERT_EQ(Size, sizeof(size_t)); + ASSERT_SUCCESS(olGetSymbolInfoSize(Global, Property, &Size)); + ASSERT_EQ(Size, PropertySize); } TEST_P(olGetSymbolInfoSizeKernelTest, InvalidNullHandle) {