From 1b072cf170281d6d316b33e7f5144f14ce314132 Mon Sep 17 00:00:00 2001 From: Katarzyna Cencelewska Date: Tue, 14 Jan 2020 16:36:53 +0100 Subject: [PATCH] Add error code for get device info relative to images if image are not supported Related-To: NEO-3931 Change-Id: I527da2dc857cd15dae6535dd389378511eb71b6d Signed-off-by: Katarzyna Cencelewska --- runtime/api/api.cpp | 12 +- runtime/device/device.h | 5 + runtime/device/device_info.cpp | 82 ++-- .../cl_get_supported_image_formats_tests.inl | 57 ++- .../device/get_device_info_size_tests.cpp | 103 ++++- unit_tests/device/get_device_info_tests.cpp | 358 +++++++++++++++++- 6 files changed, 558 insertions(+), 59 deletions(-) diff --git a/runtime/api/api.cpp b/runtime/api/api.cpp index b34cae65c6..c6526aedc7 100644 --- a/runtime/api/api.cpp +++ b/runtime/api/api.cpp @@ -998,12 +998,14 @@ cl_int CL_API_CALL clGetSupportedImageFormats(cl_context context, "imageFormats", imageFormats, "numImageFormats", numImageFormats); auto pContext = castToObject(context); - auto pPlatform = platform(); - auto pDevice = pPlatform->getDevice(0); - if (pContext) { - retVal = pContext->getSupportedImageFormats(pDevice, flags, imageType, numEntries, - imageFormats, numImageFormats); + auto pDevice = pContext->getDevice(0); + if (pDevice->getHardwareInfo().capabilityTable.supportsImages) { + retVal = pContext->getSupportedImageFormats(pDevice, flags, imageType, numEntries, + imageFormats, numImageFormats); + } else { + retVal = CL_INVALID_VALUE; + } } else { retVal = CL_INVALID_CONTEXT; } diff --git a/runtime/device/device.h b/runtime/device/device.h index a0ba446e11..25e14de9dc 100644 --- a/runtime/device/device.h +++ b/runtime/device/device.h @@ -41,6 +41,11 @@ class Device : public BaseObject<_cl_device_id> { void *paramValue, size_t *paramValueSizeRet); + bool getDeviceInfoForImage(cl_device_info paramName, + const void *&src, + size_t &srcSize, + size_t &retSize); + // This helper template is meant to simplify getDeviceInfo template void getCap(const void *&src, diff --git a/runtime/device/device_info.cpp b/runtime/device/device_info.cpp index b10811b953..7a41e210db 100644 --- a/runtime/device/device_info.cpp +++ b/runtime/device/device_info.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -67,7 +67,7 @@ cl_int Device::getDeviceInfo(cl_device_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { - cl_int retVal; + cl_int retVal = CL_INVALID_VALUE; size_t srcSize = 0; size_t retSize = 0; cl_uint param; @@ -100,15 +100,6 @@ cl_int Device::getDeviceInfo(cl_device_info paramName, case CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL: getCap(src, srcSize, retSize); break; case CL_DEVICE_HOST_UNIFIED_MEMORY: getCap(src, srcSize, retSize); break; case CL_DEVICE_IL_VERSION: getStr(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE2D_MAX_HEIGHT: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE2D_MAX_WIDTH: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE3D_MAX_DEPTH: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE3D_MAX_HEIGHT: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE3D_MAX_WIDTH: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE: getCap(src, srcSize, retSize); break; - case CL_DEVICE_IMAGE_PITCH_ALIGNMENT: getCap(src, srcSize, retSize); break; case CL_DEVICE_IMAGE_SUPPORT: getCap(src, srcSize, retSize); break; case CL_DEVICE_LINKER_AVAILABLE: getCap(src, srcSize, retSize); break; case CL_DEVICE_LOCAL_MEM_SIZE: getCap(src, srcSize, retSize); break; @@ -124,13 +115,10 @@ cl_int Device::getDeviceInfo(cl_device_info paramName, case CL_DEVICE_MAX_ON_DEVICE_QUEUES: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_PARAMETER_SIZE: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_PIPE_ARGS: getCap(src, srcSize, retSize); break; - case CL_DEVICE_MAX_READ_IMAGE_ARGS: getCap(src, srcSize, retSize); break; - case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_SAMPLERS: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_WORK_GROUP_SIZE: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: getCap(src, srcSize, retSize); break; case CL_DEVICE_MAX_WORK_ITEM_SIZES: getCap(src, srcSize, retSize); break; - case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: getCap(src, srcSize, retSize); break; case CL_DEVICE_MEM_BASE_ADDR_ALIGN: getCap(src, srcSize, retSize); break; case CL_DEVICE_ME_VERSION_INTEL: getCap(src, srcSize, retSize); break; case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: getCap(src, srcSize, retSize); break; @@ -203,15 +191,10 @@ cl_int Device::getDeviceInfo(cl_device_info paramName, retSize = srcSize = sizeof(param); break; } - case CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL: - if (deviceInfo.nv12Extension) - getCap(src, srcSize, retSize); - break; - case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL: - if (deviceInfo.nv12Extension) - getCap(src, srcSize, retSize); - break; default: + if (deviceInfo.imageSupport && getDeviceInfoForImage(paramName, src, srcSize, retSize)) { + break; + } DeviceHelper::getExtraDeviceInfo(getHardwareInfo(), paramName, param, src, srcSize, retSize); } @@ -224,6 +207,61 @@ cl_int Device::getDeviceInfo(cl_device_info paramName, return retVal; } +bool Device::getDeviceInfoForImage(cl_device_info paramName, + const void *&src, + size_t &srcSize, + size_t &retSize) { + switch (paramName) { + case CL_DEVICE_MAX_READ_IMAGE_ARGS: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE2D_MAX_HEIGHT: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE2D_MAX_WIDTH: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE3D_MAX_DEPTH: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE3D_MAX_HEIGHT: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE3D_MAX_WIDTH: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_IMAGE_PITCH_ALIGNMENT: + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL: + if (deviceInfo.nv12Extension) + getCap(src, srcSize, retSize); + break; + case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL: + if (deviceInfo.nv12Extension) + getCap(src, srcSize, retSize); + break; + default: + return false; + } + return true; +} + bool Device::getDeviceAndHostTimer(uint64_t *deviceTimestamp, uint64_t *hostTimestamp) const { TimeStampData queueTimeStamp; bool retVal = getOSTime()->getCpuGpuTime(&queueTimeStamp); diff --git a/unit_tests/api/cl_get_supported_image_formats_tests.inl b/unit_tests/api/cl_get_supported_image_formats_tests.inl index 5bf705aa86..1fd84fac92 100644 --- a/unit_tests/api/cl_get_supported_image_formats_tests.inl +++ b/unit_tests/api/cl_get_supported_image_formats_tests.inl @@ -1,11 +1,14 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * */ +#include "core/unit_tests/utilities/base_object_utils.h" #include "runtime/context/context.h" +#include "runtime/device/device.h" +#include "unit_tests/mocks/mock_device.h" #include "cl_api_tests.h" @@ -14,6 +17,9 @@ using namespace NEO; typedef api_tests clGetSupportedImageFormatsTests; TEST_F(clGetSupportedImageFormatsTests, GivenValidParamsWhenGettingSupportImageFormatsThenNumImageFormatsIsGreaterThanZero) { + if (!pContext->getDevice(0)->getDeviceInfo().imageSupport) { + GTEST_SKIP(); + } cl_uint numImageFormats = 0; retVal = clGetSupportedImageFormats( pContext, @@ -42,3 +48,52 @@ TEST_F(clGetSupportedImageFormatsTests, givenInvalidContextWhenGettingSupportIma EXPECT_EQ(CL_INVALID_CONTEXT, retVal); } + +TEST(clGetSupportedImageFormatsTest, givenPlatforNotSupportingImageWhenGettingSupportImageFormatsThenClInvalidValueIsReturned) { + HardwareInfo hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.supportsImages = false; + std::unique_ptr device(MockDevice::createWithNewExecutionEnvironment(&hwInfo)); + cl_device_id clDevice = device.get(); + cl_int retVal; + auto context = ReleaseableObjectPtr(Context::create(nullptr, DeviceVector(&clDevice, 1), nullptr, nullptr, retVal)); + EXPECT_EQ(CL_SUCCESS, retVal); + + cl_uint numImageFormats = 0; + retVal = clGetSupportedImageFormats( + context.get(), + CL_MEM_READ_WRITE, + CL_MEM_OBJECT_IMAGE2D, + 0, + nullptr, + &numImageFormats); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(clGetSupportedImageFormatsTest, givenPlatformWithoutDevicesWhenClGetSupportedImageFormatIsCalledThenDeviceIsTakenFromContext) { + auto executionEnvironment = platform()->peekExecutionEnvironment(); + executionEnvironment->initializeMemoryManager(); + executionEnvironment->prepareRootDeviceEnvironments(1); + auto device = std::unique_ptr(Device::create(executionEnvironment, 0u)); + const DeviceInfo &devInfo = device->getDeviceInfo(); + if (!devInfo.imageSupport) { + GTEST_SKIP(); + } + cl_device_id clDevice = device.get(); + cl_int retVal; + auto context = ReleaseableObjectPtr(Context::create(nullptr, DeviceVector(&clDevice, 1), nullptr, nullptr, retVal)); + EXPECT_EQ(CL_SUCCESS, retVal); + + EXPECT_EQ(0u, platform()->getNumDevices()); + cl_uint numImageFormats = 0; + retVal = clGetSupportedImageFormats( + context.get(), + CL_MEM_READ_WRITE, + CL_MEM_OBJECT_IMAGE2D, + 0, + nullptr, + &numImageFormats); + + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_GT(numImageFormats, 0u); +} diff --git a/unit_tests/device/get_device_info_size_tests.cpp b/unit_tests/device/get_device_info_size_tests.cpp index cb9690aec3..a61545e77a 100644 --- a/unit_tests/device/get_device_info_size_tests.cpp +++ b/unit_tests/device/get_device_info_size_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -53,15 +53,6 @@ std::pair deviceInfoParams2[] = { {CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong)}, {CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, sizeof(size_t)}, // {CL_DEVICE_IL_VERSION, sizeof(char[])}, - {CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t)}, - {CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t)}, - {CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t)}, - {CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t)}, - {CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t)}, - {CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, sizeof(cl_uint)}, - {CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof(size_t)}, - {CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, sizeof(size_t)}, - {CL_DEVICE_IMAGE_PITCH_ALIGNMENT, sizeof(cl_uint)}, {CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool)}, {CL_DEVICE_LINKER_AVAILABLE, sizeof(cl_bool)}, {CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong)}, @@ -77,13 +68,10 @@ std::pair deviceInfoParams2[] = { {CL_DEVICE_MAX_ON_DEVICE_QUEUES, sizeof(cl_uint)}, {CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(size_t)}, {CL_DEVICE_MAX_PIPE_ARGS, sizeof(cl_uint)}, - {CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint)}, - {CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, sizeof(cl_uint)}, {CL_DEVICE_MAX_SAMPLERS, sizeof(cl_uint)}, {CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t)}, {CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(cl_uint)}, {CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t[3])}, - {CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint)}, {CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof(cl_uint)}, // {CL_DEVICE_NAME, sizeof(char[])}, {CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, sizeof(cl_uint)}, @@ -138,6 +126,93 @@ INSTANTIATE_TEST_CASE_P( GetDeviceInfoSize, testing::ValuesIn(deviceInfoParams2)); +struct GetDeviceInfoForImage : public GetDeviceInfoSize {}; + +TEST_P(GetDeviceInfoForImage, imageInfoSizeIsValid) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + if (!device->getDeviceInfo().imageSupport) { + GTEST_SKIP(); + } + size_t sizeReturned = 0; + auto retVal = device->getDeviceInfo( + param.first, + 0, + nullptr, + &sizeReturned); + if (CL_SUCCESS != retVal) { + ASSERT_EQ(CL_SUCCESS, retVal) << " param = " << param.first; + } + ASSERT_NE(0u, sizeReturned); + EXPECT_EQ(param.second, sizeReturned); +} + +TEST_P(GetDeviceInfoForImage, whenImageAreNotSupportedThenClInvalidValueIsReturned) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + if (device->getDeviceInfo().imageSupport) { + GTEST_SKIP(); + } + size_t sizeReturned = 0; + auto retVal = device->getDeviceInfo( + param.first, + 0, + nullptr, + &sizeReturned); + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST_P(GetDeviceInfoForImage, givenInfoImageParamsWhenCallGetDeviceInfoForImageThenSizeIsValidAndTrueReturned) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + size_t srcSize = 0; + size_t retSize = 0; + const void *src = nullptr; + auto retVal = device->getDeviceInfoForImage( + param.first, + src, + srcSize, + retSize); + EXPECT_TRUE(retVal); + ASSERT_NE(0u, srcSize); + EXPECT_EQ(param.second, srcSize); + EXPECT_EQ(param.second, retSize); +} + +TEST(GetDeviceInfoForImage, givenNotImageParamWhenCallGetDeviceInfoForImageThenSizeIsNotValidAndFalseReturned) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + size_t srcSize = 0; + size_t retSize = 0; + const void *src = nullptr; + cl_device_info notImageParam = CL_DEVICE_ADDRESS_BITS; + size_t paramSize = sizeof(cl_uint); + auto retVal = device->getDeviceInfoForImage( + notImageParam, + src, + srcSize, + retSize); + EXPECT_FALSE(retVal); + EXPECT_EQ(0u, srcSize); + EXPECT_NE(paramSize, srcSize); + EXPECT_NE(paramSize, retSize); +} +std::pair deviceInfoImageParams[] = { + {CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t)}, + {CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t)}, + {CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t)}, + {CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t)}, + {CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t)}, + {CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, sizeof(cl_uint)}, + {CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof(size_t)}, + {CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, sizeof(size_t)}, + {CL_DEVICE_IMAGE_PITCH_ALIGNMENT, sizeof(cl_uint)}, + {CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint)}, + {CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, sizeof(cl_uint)}, + {CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint)}, +}; + +INSTANTIATE_TEST_CASE_P( + Device_, + GetDeviceInfoForImage, + testing::ValuesIn(deviceInfoImageParams)); + TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForDeviceVersionThenProperSizeIsReturned) { auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); size_t sizeReturned = 0; @@ -158,4 +233,4 @@ TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForDeviceVersionThenProperSiz nullptr); EXPECT_EQ(CL_SUCCESS, retVal); -} \ No newline at end of file +} diff --git a/unit_tests/device/get_device_info_tests.cpp b/unit_tests/device/get_device_info_tests.cpp index aeb94481ee..880c42ccf7 100644 --- a/unit_tests/device/get_device_info_tests.cpp +++ b/unit_tests/device/get_device_info_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -42,9 +42,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GetDeviceInfoMemCapabilitiesTest, GivenValidParamete check(params); } -TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabled) { +TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabledAndSupportImageEnabled) { auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); - + device->deviceInfo.imageSupport = true; device->deviceInfo.nv12Extension = false; uint32_t value; @@ -65,9 +65,9 @@ TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtens EXPECT_EQ(CL_INVALID_VALUE, retVal); } -TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarYuvExtensionEnabled) { +TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarYuvExtensionEnabledAndSupportImageEnabled) { auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); - + device->deviceInfo.imageSupport = true; device->deviceInfo.nv12Extension = true; size_t value = 0; @@ -90,6 +90,342 @@ TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarY EXPECT_EQ(16352u, value); } +TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabledAndSupportImageDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + device->deviceInfo.imageSupport = false; + device->deviceInfo.nv12Extension = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL, + 4, + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL, + 4, + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionEnabledAndSupportImageDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + device->deviceInfo.imageSupport = false; + device->deviceInfo.nv12Extension = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL, + 4, + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL, + 4, + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImage2dMaxWidthHeightReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE2D_MAX_WIDTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE2D_MAX_HEIGHT, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImage2dMaxWidthHeightReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE2D_MAX_WIDTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE2D_MAX_HEIGHT, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImage3dMaxWidthHeightDepthReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_WIDTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_HEIGHT, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_DEPTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImage3dMaxWidthHeightDepthReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_WIDTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_HEIGHT, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE3D_MAX_DEPTH, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxArgsReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_MAX_READ_IMAGE_ARGS, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_MAX_WRITE_IMAGE_ARGS, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxArgsReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_MAX_READ_IMAGE_ARGS, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + retVal = device->getDeviceInfo( + CL_DEVICE_MAX_WRITE_IMAGE_ARGS, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageBaseAddressAlignmentReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageBaseAddressAlignmentReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxArraySizeReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxArraySizeReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxBufferSizeReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImageMaxBufferSizeReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, + sizeof(size_t), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST(GetDeviceInfo, clDeviceImagePtichAlignmentReturnsErrorWhenImageSupportDisabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = false; + uint32_t value; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_PITCH_ALIGNMENT, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +TEST(GetDeviceInfo, clDeviceImagePtichAlignmentReturnsCorrectValuesWhenImageSupportEnabled) { + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); + + device->deviceInfo.imageSupport = true; + size_t value = 0; + + auto retVal = device->getDeviceInfo( + CL_DEVICE_IMAGE_PITCH_ALIGNMENT, + sizeof(cl_uint), + &value, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + TEST(GetDeviceInfo, numSimultaneousInterops) { auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); device->simultaneousInterops = {0}; @@ -195,15 +531,6 @@ cl_device_info deviceInfoParams[] = { CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, CL_DEVICE_HALF_FP_CONFIG, CL_DEVICE_HOST_UNIFIED_MEMORY, - CL_DEVICE_IMAGE2D_MAX_HEIGHT, - CL_DEVICE_IMAGE2D_MAX_WIDTH, - CL_DEVICE_IMAGE3D_MAX_DEPTH, - CL_DEVICE_IMAGE3D_MAX_HEIGHT, - CL_DEVICE_IMAGE3D_MAX_WIDTH, - CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, - CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, - CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, - CL_DEVICE_IMAGE_PITCH_ALIGNMENT, CL_DEVICE_IMAGE_SUPPORT, CL_DEVICE_LINKER_AVAILABLE, CL_DEVICE_LOCAL_MEM_SIZE, @@ -219,13 +546,10 @@ cl_device_info deviceInfoParams[] = { CL_DEVICE_MAX_ON_DEVICE_QUEUES, CL_DEVICE_MAX_PARAMETER_SIZE, CL_DEVICE_MAX_PIPE_ARGS, - CL_DEVICE_MAX_READ_IMAGE_ARGS, - CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, CL_DEVICE_MAX_SAMPLERS, CL_DEVICE_MAX_WORK_GROUP_SIZE, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, CL_DEVICE_MAX_WORK_ITEM_SIZES, - CL_DEVICE_MAX_WRITE_IMAGE_ARGS, CL_DEVICE_MEM_BASE_ADDR_ALIGN, CL_DEVICE_ME_VERSION_INTEL, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE,