diff --git a/include/ur_api.h b/include/ur_api.h index 226b9f41f8..3abf8597b1 100644 --- a/include/ur_api.h +++ b/include/ur_api.h @@ -2595,13 +2595,16 @@ typedef enum ur_image_channel_type_t { /////////////////////////////////////////////////////////////////////////////// /// @brief Image information types typedef enum ur_image_info_t { - UR_IMAGE_INFO_FORMAT = 0, ///< [::ur_image_format_t] image format - UR_IMAGE_INFO_ELEMENT_SIZE = 1, ///< [size_t] element size - UR_IMAGE_INFO_ROW_PITCH = 2, ///< [size_t] row pitch - UR_IMAGE_INFO_SLICE_PITCH = 3, ///< [size_t] slice pitch - UR_IMAGE_INFO_WIDTH = 4, ///< [size_t] image width - UR_IMAGE_INFO_HEIGHT = 5, ///< [size_t] image height - UR_IMAGE_INFO_DEPTH = 6, ///< [size_t] image depth + UR_IMAGE_INFO_FORMAT = 0, ///< [::ur_image_format_t] image format + UR_IMAGE_INFO_ELEMENT_SIZE = 1, ///< [size_t] element size + UR_IMAGE_INFO_ROW_PITCH = 2, ///< [size_t] row pitch + UR_IMAGE_INFO_SLICE_PITCH = 3, ///< [size_t] slice pitch + UR_IMAGE_INFO_WIDTH = 4, ///< [size_t] image width + UR_IMAGE_INFO_HEIGHT = 5, ///< [size_t] image height + UR_IMAGE_INFO_DEPTH = 6, ///< [size_t] image depth + UR_IMAGE_INFO_ARRAY_SIZE = 7, ///< [size_t] array size + UR_IMAGE_INFO_NUM_MIP_LEVELS = 8, ///< [size_t] number of MIP levels + UR_IMAGE_INFO_NUM_SAMPLES = 9, ///< [size_t] number of samples /// @cond UR_IMAGE_INFO_FORCE_UINT32 = 0x7fffffff /// @endcond @@ -3055,7 +3058,7 @@ urMemGetInfo( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hMemory` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -7990,7 +7993,7 @@ urBindlessImagesImageCopyExp( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hContext` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE diff --git a/include/ur_print.hpp b/include/ur_print.hpp index c350f206c6..1b0f4bac2e 100644 --- a/include/ur_print.hpp +++ b/include/ur_print.hpp @@ -5954,6 +5954,15 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_image_info_t value) { case UR_IMAGE_INFO_DEPTH: os << "UR_IMAGE_INFO_DEPTH"; break; + case UR_IMAGE_INFO_ARRAY_SIZE: + os << "UR_IMAGE_INFO_ARRAY_SIZE"; + break; + case UR_IMAGE_INFO_NUM_MIP_LEVELS: + os << "UR_IMAGE_INFO_NUM_MIP_LEVELS"; + break; + case UR_IMAGE_INFO_NUM_SAMPLES: + os << "UR_IMAGE_INFO_NUM_SAMPLES"; + break; default: os << "unknown enumerator"; break; @@ -6054,6 +6063,42 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_image_info_ os << ")"; } break; + case UR_IMAGE_INFO_ARRAY_SIZE: { + const size_t *tptr = (const size_t *)ptr; + if (sizeof(size_t) > size) { + os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")"; + return UR_RESULT_ERROR_INVALID_SIZE; + } + os << (const void *)(tptr) << " ("; + + os << *tptr; + + os << ")"; + } break; + case UR_IMAGE_INFO_NUM_MIP_LEVELS: { + const size_t *tptr = (const size_t *)ptr; + if (sizeof(size_t) > size) { + os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")"; + return UR_RESULT_ERROR_INVALID_SIZE; + } + os << (const void *)(tptr) << " ("; + + os << *tptr; + + os << ")"; + } break; + case UR_IMAGE_INFO_NUM_SAMPLES: { + const size_t *tptr = (const size_t *)ptr; + if (sizeof(size_t) > size) { + os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")"; + return UR_RESULT_ERROR_INVALID_SIZE; + } + os << (const void *)(tptr) << " ("; + + os << *tptr; + + os << ")"; + } break; default: os << "unknown enumerator"; return UR_RESULT_ERROR_INVALID_ENUMERATION; diff --git a/scripts/core/memory.yml b/scripts/core/memory.yml index 467e10d749..de906fdb1b 100644 --- a/scripts/core/memory.yml +++ b/scripts/core/memory.yml @@ -160,6 +160,12 @@ etors: desc: "[size_t] image height" - name: DEPTH desc: "[size_t] image depth" + - name: ARRAY_SIZE + desc: "[size_t] array size" + - name: NUM_MIP_LEVELS + desc: "[size_t] number of MIP levels" + - name: NUM_SAMPLES + desc: "[size_t] number of samples" --- #-------------------------------------------------------------------------- type: struct desc: "Image format including channel layout and data type" diff --git a/source/adapters/opencl/memory.cpp b/source/adapters/opencl/memory.cpp index 201df1f678..09a33f4c16 100644 --- a/source/adapters/opencl/memory.cpp +++ b/source/adapters/opencl/memory.cpp @@ -10,6 +10,92 @@ #include "common.hpp" +#include + +const std::unordered_map + ChannelOrderMap = { + {UR_IMAGE_CHANNEL_ORDER_A, CL_A}, + {UR_IMAGE_CHANNEL_ORDER_R, CL_R}, + {UR_IMAGE_CHANNEL_ORDER_RG, CL_RG}, + {UR_IMAGE_CHANNEL_ORDER_RA, CL_RA}, + {UR_IMAGE_CHANNEL_ORDER_RGB, CL_RGB}, + {UR_IMAGE_CHANNEL_ORDER_RGBA, CL_RGBA}, + {UR_IMAGE_CHANNEL_ORDER_BGRA, CL_BGRA}, + {UR_IMAGE_CHANNEL_ORDER_ARGB, CL_ARGB}, + {UR_IMAGE_CHANNEL_ORDER_ABGR, CL_ABGR}, + {UR_IMAGE_CHANNEL_ORDER_INTENSITY, CL_INTENSITY}, + {UR_IMAGE_CHANNEL_ORDER_LUMINANCE, CL_LUMINANCE}, + {UR_IMAGE_CHANNEL_ORDER_RX, CL_Rx}, + {UR_IMAGE_CHANNEL_ORDER_RGX, CL_RGx}, + {UR_IMAGE_CHANNEL_ORDER_RGBX, CL_RGBx}, + {UR_IMAGE_CHANNEL_ORDER_SRGBA, CL_sRGBA}, +}; + +const std::unordered_map + ChannelTypeMap = { + {UR_IMAGE_CHANNEL_TYPE_SNORM_INT8, CL_SNORM_INT8}, + {UR_IMAGE_CHANNEL_TYPE_SNORM_INT16, CL_SNORM_INT16}, + {UR_IMAGE_CHANNEL_TYPE_UNORM_INT8, CL_UNORM_INT8}, + {UR_IMAGE_CHANNEL_TYPE_UNORM_INT16, CL_UNORM_INT16}, + {UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565, CL_UNORM_SHORT_565}, + {UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555, CL_UNORM_SHORT_555}, + {UR_IMAGE_CHANNEL_TYPE_INT_101010, CL_UNORM_INT_101010}, + {UR_IMAGE_CHANNEL_TYPE_SIGNED_INT8, CL_SIGNED_INT8}, + {UR_IMAGE_CHANNEL_TYPE_SIGNED_INT16, CL_SIGNED_INT16}, + {UR_IMAGE_CHANNEL_TYPE_SIGNED_INT32, CL_SIGNED_INT32}, + {UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8, CL_UNSIGNED_INT8}, + {UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16, CL_UNSIGNED_INT16}, + {UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32, CL_UNSIGNED_INT32}, + {UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT, CL_HALF_FLOAT}, + {UR_IMAGE_CHANNEL_TYPE_FLOAT, CL_FLOAT}, +}; + +cl_image_format mapURImageFormatToCL(const ur_image_format_t &PImageFormat) { + cl_image_format CLImageFormat = {UR_IMAGE_CHANNEL_ORDER_FORCE_UINT32, + UR_IMAGE_CHANNEL_TYPE_FORCE_UINT32}; + + auto channelOrderIt = ChannelOrderMap.find(PImageFormat.channelOrder); + if (channelOrderIt != ChannelOrderMap.end()) { + CLImageFormat.image_channel_order = channelOrderIt->second; + } + + auto channelTypeIt = ChannelTypeMap.find(PImageFormat.channelType); + if (channelTypeIt != ChannelTypeMap.end()) { + CLImageFormat.image_channel_data_type = channelTypeIt->second; + } + + return CLImageFormat; +} + +ur_image_format_t mapCLImageFormatToUR(const cl_image_format *PImageFormat) { + ur_image_format_t URImageFormat = {UR_IMAGE_CHANNEL_ORDER_FORCE_UINT32, + UR_IMAGE_CHANNEL_TYPE_FORCE_UINT32}; + + auto reverseChannelOrderIt = + std::find_if(ChannelOrderMap.begin(), ChannelOrderMap.end(), + [PImageFormat](const auto &pair) { + return pair.second == PImageFormat->image_channel_order; + }); + if (reverseChannelOrderIt != ChannelOrderMap.end()) { + URImageFormat.channelOrder = reverseChannelOrderIt->first; + } + + URImageFormat.channelOrder = (reverseChannelOrderIt != ChannelOrderMap.end()) + ? reverseChannelOrderIt->first + : UR_IMAGE_CHANNEL_ORDER_FORCE_UINT32; + + auto reverseChannelTypeIt = std::find_if( + ChannelTypeMap.begin(), ChannelTypeMap.end(), + [PImageFormat](const auto &pair) { + return pair.second == PImageFormat->image_channel_data_type; + }); + if (reverseChannelTypeIt != ChannelTypeMap.end()) { + URImageFormat.channelType = reverseChannelTypeIt->first; + } + + return URImageFormat; +} + cl_image_format mapURImageFormatToCL(const ur_image_format_t *PImageFormat) { cl_image_format CLImageFormat; switch (PImageFormat->channelOrder) { @@ -174,6 +260,12 @@ cl_int mapURMemImageInfoToCL(ur_image_info_t URPropName) { return CL_IMAGE_HEIGHT; case UR_IMAGE_INFO_DEPTH: return CL_IMAGE_DEPTH; + case UR_IMAGE_INFO_ARRAY_SIZE: + return CL_IMAGE_DEPTH; + case UR_IMAGE_INFO_NUM_MIP_LEVELS: + return CL_IMAGE_DEPTH; + case UR_IMAGE_INFO_NUM_SAMPLES: + return CL_IMAGE_DEPTH; default: return -1; } @@ -397,7 +489,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory, CL_RETURN_ON_FAILURE(ClResult); if (pPropSizeRet) { *pPropSizeRet = CheckPropSize; + } else { + if (propName == UR_IMAGE_INFO_FORMAT) { + ur_image_format_t format = mapCLImageFormatToUR( + reinterpret_cast(pPropValue)); + return ReturnValue(format); + } } + return UR_RESULT_SUCCESS; } diff --git a/source/loader/layers/validation/ur_valddi.cpp b/source/loader/layers/validation/ur_valddi.cpp index f64f61e11d..b3fb6db623 100644 --- a/source/loader/layers/validation/ur_valddi.cpp +++ b/source/loader/layers/validation/ur_valddi.cpp @@ -1566,7 +1566,7 @@ __urdlllocal ur_result_t UR_APICALL urMemImageGetInfo( return UR_RESULT_ERROR_INVALID_NULL_POINTER; } - if (UR_IMAGE_INFO_DEPTH < propName) { + if (UR_IMAGE_INFO_NUM_SAMPLES < propName) { return UR_RESULT_ERROR_INVALID_ENUMERATION; } @@ -7456,7 +7456,7 @@ __urdlllocal ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp( return UR_RESULT_ERROR_INVALID_NULL_POINTER; } - if (UR_IMAGE_INFO_DEPTH < propName) { + if (UR_IMAGE_INFO_NUM_SAMPLES < propName) { return UR_RESULT_ERROR_INVALID_ENUMERATION; } } diff --git a/source/loader/ur_libapi.cpp b/source/loader/ur_libapi.cpp index c434f750b6..d58d0c42e4 100644 --- a/source/loader/ur_libapi.cpp +++ b/source/loader/ur_libapi.cpp @@ -1946,7 +1946,7 @@ ur_result_t UR_APICALL urMemGetInfo( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hMemory` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -7007,7 +7007,7 @@ ur_result_t UR_APICALL urBindlessImagesImageCopyExp( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hContext` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE diff --git a/source/ur_api.cpp b/source/ur_api.cpp index 7aa9cfcdd4..5096c56c47 100644 --- a/source/ur_api.cpp +++ b/source/ur_api.cpp @@ -1686,7 +1686,7 @@ ur_result_t UR_APICALL urMemGetInfo( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hMemory` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE @@ -5981,7 +5981,7 @@ ur_result_t UR_APICALL urBindlessImagesImageCopyExp( /// - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE /// + `NULL == hContext` /// - ::UR_RESULT_ERROR_INVALID_ENUMERATION -/// + `::UR_IMAGE_INFO_DEPTH < propName` +/// + `::UR_IMAGE_INFO_NUM_SAMPLES < propName` /// - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION /// + If `propName` is not supported by the adapter. /// - ::UR_RESULT_ERROR_INVALID_SIZE diff --git a/test/conformance/memory/memory_adapter_level_zero.match b/test/conformance/memory/memory_adapter_level_zero.match new file mode 100644 index 0000000000..7dda97e119 --- /dev/null +++ b/test/conformance/memory/memory_adapter_level_zero.match @@ -0,0 +1,14 @@ +{{OPT}}urMemBufferMultiQueueMemBufferTest.WriteBack +urMemBufferPartitionWithFlagsTest.Success/*__UR_MEM_FLAG_WRITE_ONLY +urMemBufferPartitionWithFlagsTest.Success/*__UR_MEM_FLAG_READ_ONLY +urMemBufferPartitionTest.InvalidValueCreateType/* +urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/* +{{OPT}}urMemImageCreateWithNativeHandleTest.Success/* +{{OPT}}urMemGetInfoImageTest.SuccessSize/* +{{OPT}}urMemImageCreateTestWithImageFormatParam.Success/*__UR_IMAGE_CHANNEL_ORDER_RGBA__* + +# These tests fail in the "Multi device testing" job, but pass in the hardware specific test +{{OPT}}urMemImageCreateTest.InvalidImageDescStype/* +{{OPT}}urMemImageCreateTest.InvalidSize/* +{{OPT}}urMemImageCreateWithHostPtrFlagsTest.Success/* +{{OPT}}urMemImageGetInfoTest.InvalidSizeSmall/* diff --git a/test/conformance/memory/urMemImageGetInfo.cpp b/test/conformance/memory/urMemImageGetInfo.cpp index 78bc3b7513..550ad95063 100644 --- a/test/conformance/memory/urMemImageGetInfo.cpp +++ b/test/conformance/memory/urMemImageGetInfo.cpp @@ -4,93 +4,236 @@ // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception #include -#include - -struct urMemImageGetInfoTest : uur::urMemImageTestWithParam { - void SetUp() override { - UUR_KNOWN_FAILURE_ON(uur::LevelZeroV2{}); - UUR_RETURN_ON_FATAL_FAILURE( - uur::urMemImageTestWithParam::SetUp()); - } -}; - -static std::unordered_map image_info_size_map = { - {UR_IMAGE_INFO_FORMAT, sizeof(ur_image_format_t)}, - {UR_IMAGE_INFO_ELEMENT_SIZE, sizeof(size_t)}, - {UR_IMAGE_INFO_ROW_PITCH, sizeof(size_t)}, - {UR_IMAGE_INFO_SLICE_PITCH, sizeof(size_t)}, - {UR_IMAGE_INFO_WIDTH, sizeof(size_t)}, - {UR_IMAGE_INFO_HEIGHT, sizeof(size_t)}, - {UR_IMAGE_INFO_DEPTH, sizeof(size_t)}, -}; - -UUR_DEVICE_TEST_SUITE_P( - urMemImageGetInfoTest, - ::testing::Values(UR_IMAGE_INFO_FORMAT, UR_IMAGE_INFO_ELEMENT_SIZE, - UR_IMAGE_INFO_ROW_PITCH, UR_IMAGE_INFO_SLICE_PITCH, - UR_IMAGE_INFO_WIDTH, UR_IMAGE_INFO_HEIGHT, - UR_IMAGE_INFO_DEPTH), - uur::deviceTestWithParamPrinter); - -TEST_P(urMemImageGetInfoTest, Success) { - UUR_KNOWN_FAILURE_ON(uur::HIP{}); - // This fail is specific to the "Multi device testing" ci job. +#include + +using urMemImageGetInfoTest = uur::urMemImageTest; +UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemImageGetInfoTest); + +bool operator==(ur_image_format_t lhs, ur_image_format_t rhs) { + return lhs.channelOrder == rhs.channelOrder && + lhs.channelType == rhs.channelType; +} + +TEST_P(urMemImageGetInfoTest, SuccessFormat) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_image_info_t info = getParam(); size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_FORMAT; + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urMemImageGetInfo(image, info, 0, nullptr, &size), info); - ASSERT_NE(size, 0); + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(ur_image_format_t), size); - if (const auto expected_size = image_info_size_map.find(info); - expected_size != image_info_size_map.end()) { - ASSERT_EQ(expected_size->second, size); - } else { - FAIL() << "Missing info value in image info size map"; - } + ur_image_format_t returned_format = {UR_IMAGE_CHANNEL_ORDER_FORCE_UINT32, + UR_IMAGE_CHANNEL_TYPE_FORCE_UINT32}; - std::vector info_data(size); + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_format, nullptr)); + + ASSERT_TRUE(returned_format == image_format); +} + +TEST_P(urMemImageGetInfoTest, SuccessElementSize) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_ELEMENT_SIZE; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_size = 999; ASSERT_SUCCESS( - urMemImageGetInfo(image, info, size, info_data.data(), nullptr)); + urMemImageGetInfo(image, property_name, size, &returned_size, nullptr)); + + ASSERT_NE(returned_size, 999); +} + +TEST_P(urMemImageGetInfoTest, SuccessRowPitch) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_ROW_PITCH; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_row_pitch = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_row_pitch, nullptr)); + + ASSERT_NE(returned_row_pitch, 999); +} + +TEST_P(urMemImageGetInfoTest, SuccessSlicePitch) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_SLICE_PITCH; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_slice_pitch = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_slice_pitch, nullptr)); + + ASSERT_EQ(returned_slice_pitch, image_desc.slicePitch); +} + +TEST_P(urMemImageGetInfoTest, SuccessWidth) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_WIDTH; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_width = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_width, nullptr)); + + ASSERT_EQ(returned_width, image_desc.width); +} + +TEST_P(urMemImageGetInfoTest, SuccessHeight) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_HEIGHT; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_height = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_height, nullptr)); + + ASSERT_EQ(returned_height, image_desc.height); +} + +TEST_P(urMemImageGetInfoTest, SuccessDepth) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_DEPTH; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_depth = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_depth, nullptr)); + + ASSERT_NE(returned_depth, 999); +} + +TEST_P(urMemImageGetInfoTest, SuccessArraySize) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_ARRAY_SIZE; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_depth = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_depth, nullptr)); + + ASSERT_NE(returned_depth, 999); +} + +TEST_P(urMemImageGetInfoTest, SuccessNumMipMaps) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_NUM_MIP_LEVELS; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_depth = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_depth, nullptr)); + + ASSERT_NE(returned_depth, 999); +} + +TEST_P(urMemImageGetInfoTest, SuccessNumSamples) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); + + size_t size = 0; + ur_image_info_t property_name = UR_IMAGE_INFO_NUM_SAMPLES; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urMemImageGetInfo(image, property_name, 0, nullptr, &size), + property_name); + ASSERT_EQ(sizeof(size_t), size); + + size_t returned_depth = 999; + ASSERT_SUCCESS(urMemImageGetInfo(image, property_name, size, + &returned_depth, nullptr)); + + ASSERT_NE(returned_depth, 999); } TEST_P(urMemImageGetInfoTest, InvalidNullHandleImage) { - size_t info_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urMemImageGetInfo(nullptr, UR_IMAGE_INFO_FORMAT, - sizeof(size_t), &info_size, nullptr)); + sizeof(size_t), &property_size, + nullptr)); } TEST_P(urMemImageGetInfoTest, InvalidEnumerationImageInfoType) { - size_t info_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urMemImageGetInfo(image, UR_IMAGE_INFO_FORCE_UINT32, - sizeof(size_t), &info_size, nullptr)); + sizeof(size_t), &property_size, + nullptr)); } TEST_P(urMemImageGetInfoTest, InvalidSizeZero) { - size_t info_size = 0; - ASSERT_EQ_RESULT( - urMemImageGetInfo(image, UR_IMAGE_INFO_FORMAT, 0, &info_size, nullptr), - UR_RESULT_ERROR_INVALID_SIZE); + size_t property_size = 0; + ASSERT_EQ_RESULT(urMemImageGetInfo(image, UR_IMAGE_INFO_FORMAT, 0, + &property_size, nullptr), + UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urMemImageGetInfoTest, InvalidSizeSmall) { // This fail is specific to the "Multi device testing" ci job. UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - int info_size = 0; + int property_size = 0; ASSERT_EQ_RESULT(urMemImageGetInfo(image, UR_IMAGE_INFO_FORMAT, - sizeof(info_size) - 1, &info_size, - nullptr), + sizeof(property_size) - 1, + &property_size, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urMemImageGetInfoTest, InvalidNullPointerParamValue) { - size_t info_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(urMemImageGetInfo(image, UR_IMAGE_INFO_FORMAT, - sizeof(info_size), nullptr, nullptr), + sizeof(property_size), nullptr, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); } diff --git a/test/conformance/queue/urQueueGetInfo.cpp b/test/conformance/queue/urQueueGetInfo.cpp index b3066c427d..a4238df12d 100644 --- a/test/conformance/queue/urQueueGetInfo.cpp +++ b/test/conformance/queue/urQueueGetInfo.cpp @@ -12,14 +12,13 @@ TEST_P(urQueueGetInfoTest, Context) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t size = 0; - auto infoType = UR_QUEUE_INFO_CONTEXT; - ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + auto info_type = UR_QUEUE_INFO_CONTEXT; + ASSERT_SUCCESS(urQueueGetInfo(queue, info_type, 0, nullptr, &size)); ASSERT_EQ(sizeof(ur_context_handle_t), size); ur_context_handle_t returned_context = nullptr; ASSERT_SUCCESS( - urQueueGetInfo(queue, infoType, size, &returned_context, nullptr)); + urQueueGetInfo(queue, info_type, size, &returned_context, nullptr)); ASSERT_EQ(context, returned_context); } @@ -28,14 +27,13 @@ TEST_P(urQueueGetInfoTest, Device) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t size = 0; - auto infoType = UR_QUEUE_INFO_DEVICE; - ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + auto info_type = UR_QUEUE_INFO_DEVICE; + ASSERT_SUCCESS(urQueueGetInfo(queue, info_type, 0, nullptr, &size)); ASSERT_EQ(sizeof(ur_device_handle_t), size); ur_device_handle_t returned_device = nullptr; ASSERT_SUCCESS( - urQueueGetInfo(queue, infoType, size, &returned_device, nullptr)); + urQueueGetInfo(queue, info_type, size, &returned_device, nullptr)); ASSERT_EQ(device, returned_device); } @@ -44,14 +42,13 @@ TEST_P(urQueueGetInfoTest, Flags) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t size = 0; - auto infoType = UR_QUEUE_INFO_FLAGS; - ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + auto info_type = UR_QUEUE_INFO_FLAGS; + ASSERT_SUCCESS(urQueueGetInfo(queue, info_type, 0, nullptr, &size)); ASSERT_EQ(sizeof(ur_queue_flags_t), size); ur_queue_flags_t returned_flags = 0; ASSERT_SUCCESS( - urQueueGetInfo(queue, infoType, size, &returned_flags, nullptr)); + urQueueGetInfo(queue, info_type, size, &returned_flags, nullptr)); EXPECT_EQ(returned_flags, queue_properties.flags); } @@ -60,13 +57,12 @@ TEST_P(urQueueGetInfoTest, ReferenceCount) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t size = 0; - auto infoType = UR_QUEUE_INFO_REFERENCE_COUNT; - ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + auto info_type = UR_QUEUE_INFO_REFERENCE_COUNT; + ASSERT_SUCCESS(urQueueGetInfo(queue, info_type, 0, nullptr, &size)); ASSERT_EQ(sizeof(uint32_t), size); uint32_t returned_reference_count = 0; - ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, + ASSERT_SUCCESS(urQueueGetInfo(queue, info_type, size, &returned_reference_count, nullptr)); ASSERT_GT(returned_reference_count, 0U); @@ -76,9 +72,9 @@ TEST_P(urQueueGetInfoTest, EmptyQueue) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t size = 0; - auto infoType = UR_QUEUE_INFO_EMPTY; + auto info_type = UR_QUEUE_INFO_EMPTY; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + urQueueGetInfo(queue, info_type, 0, nullptr, &size), info_type); ASSERT_EQ(sizeof(ur_bool_t), size); } @@ -162,28 +158,28 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoDeviceQueueTestWithInfoParam); TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, DeviceDefault) { size_t size = 0; - auto infoType = UR_QUEUE_INFO_DEVICE_DEFAULT; + auto info_type = UR_QUEUE_INFO_DEVICE_DEFAULT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + urQueueGetInfo(queue, info_type, 0, nullptr, &size), info_type); ASSERT_EQ(sizeof(ur_queue_handle_t), size); ur_queue_handle_t returned_queue = nullptr; ASSERT_SUCCESS( - urQueueGetInfo(queue, infoType, size, &returned_queue, nullptr)); + urQueueGetInfo(queue, info_type, size, &returned_queue, nullptr)); ASSERT_EQ(queue, returned_queue); } TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, Size) { size_t size = 0; - auto infoType = UR_QUEUE_INFO_SIZE; + auto info_type = UR_QUEUE_INFO_SIZE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urQueueGetInfo(queue, infoType, 0, nullptr, &size), infoType); + urQueueGetInfo(queue, info_type, 0, nullptr, &size), info_type); ASSERT_EQ(sizeof(uint32_t), size); uint32_t returned_size = 0; ASSERT_SUCCESS( - urQueueGetInfo(queue, infoType, size, &returned_size, nullptr)); + urQueueGetInfo(queue, info_type, size, &returned_size, nullptr)); ASSERT_GT(returned_size, 0); } diff --git a/test/conformance/testing/include/uur/fixtures.h b/test/conformance/testing/include/uur/fixtures.h index 80bbff6d49..8f5cc2f746 100644 --- a/test/conformance/testing/include/uur/fixtures.h +++ b/test/conformance/testing/include/uur/fixtures.h @@ -357,44 +357,6 @@ template struct urSamplerTestWithParam : urContextTestWithParam { ur_sampler_desc_t sampler_desc; }; -template struct urMemImageTestWithParam : urContextTestWithParam { - void SetUp() override { - UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam::SetUp()); - ur_bool_t imageSupported = false; - ASSERT_SUCCESS( - urDeviceGetInfo(this->device, UR_DEVICE_INFO_IMAGE_SUPPORTED, - sizeof(ur_bool_t), &imageSupported, nullptr)); - if (!imageSupported) { - GTEST_SKIP(); - } - UUR_ASSERT_SUCCESS_OR_UNSUPPORTED( - urMemImageCreate(this->context, UR_MEM_FLAG_READ_WRITE, &format, - &desc, nullptr, &image)); - ASSERT_NE(nullptr, image); - } - - void TearDown() override { - if (image) { - EXPECT_SUCCESS(urMemRelease(image)); - } - UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam::TearDown()); - } - ur_mem_handle_t image = nullptr; - ur_image_format_t format = {UR_IMAGE_CHANNEL_ORDER_RGBA, - UR_IMAGE_CHANNEL_TYPE_FLOAT}; - ur_image_desc_t desc = {UR_STRUCTURE_TYPE_IMAGE_DESC, // stype - nullptr, // pNext - UR_MEM_TYPE_IMAGE1D, // mem object type - 1024, // image width - 1, // image height - 1, // image depth - 1, // array size - 0, // row pitch - 0, // slice pitch - 0, // mip levels - 0}; // num samples -}; - struct urQueueTest : urContextTest { void SetUp() override { UUR_RETURN_ON_FATAL_FAILURE(urContextTest::SetUp());