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 <katarzyna.cencelewska@intel.com>
2025-12-24 12:23:05 +08:00 · 2020-01-14 16:36:53 +01:00
parent 318d9620ae
commit 1b072cf170
6 changed files with 558 additions and 59 deletions
--- 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>(context);
-    auto pPlatform = platform();
-    auto pDevice = pPlatform->getDevice(0);
-
    if (pContext) {
+        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;
    }
--- 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 <cl_device_info Param>
    void getCap(const void *&src,
--- 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<CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL                 >(src, srcSize, retSize); break;
    case CL_DEVICE_HOST_UNIFIED_MEMORY:                         getCap<CL_DEVICE_HOST_UNIFIED_MEMORY                         >(src, srcSize, retSize); break;
    case CL_DEVICE_IL_VERSION:                                  getStr<CL_DEVICE_IL_VERSION                                  >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE2D_MAX_HEIGHT:                          getCap<CL_DEVICE_IMAGE2D_MAX_HEIGHT                          >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE2D_MAX_WIDTH:                           getCap<CL_DEVICE_IMAGE2D_MAX_WIDTH                           >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE3D_MAX_DEPTH:                           getCap<CL_DEVICE_IMAGE3D_MAX_DEPTH                           >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE3D_MAX_HEIGHT:                          getCap<CL_DEVICE_IMAGE3D_MAX_HEIGHT                          >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE3D_MAX_WIDTH:                           getCap<CL_DEVICE_IMAGE3D_MAX_WIDTH                           >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT:                getCap<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT                >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE:                        getCap<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE                        >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE:                       getCap<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE                       >(src, srcSize, retSize); break;
-    case CL_DEVICE_IMAGE_PITCH_ALIGNMENT:                       getCap<CL_DEVICE_IMAGE_PITCH_ALIGNMENT                       >(src, srcSize, retSize); break;
    case CL_DEVICE_IMAGE_SUPPORT:                               getCap<CL_DEVICE_IMAGE_SUPPORT                               >(src, srcSize, retSize); break;
    case CL_DEVICE_LINKER_AVAILABLE:                            getCap<CL_DEVICE_LINKER_AVAILABLE                            >(src, srcSize, retSize); break;
    case CL_DEVICE_LOCAL_MEM_SIZE:                              getCap<CL_DEVICE_LOCAL_MEM_SIZE                              >(src, srcSize, retSize); break;
@@ -124,13 +115,10 @@ cl_int Device::getDeviceInfo(cl_device_info paramName,
    case CL_DEVICE_MAX_ON_DEVICE_QUEUES:                        getCap<CL_DEVICE_MAX_ON_DEVICE_QUEUES                        >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_PARAMETER_SIZE:                          getCap<CL_DEVICE_MAX_PARAMETER_SIZE                          >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_PIPE_ARGS:                               getCap<CL_DEVICE_MAX_PIPE_ARGS                               >(src, srcSize, retSize); break;
-    case CL_DEVICE_MAX_READ_IMAGE_ARGS:                         getCap<CL_DEVICE_MAX_READ_IMAGE_ARGS                         >(src, srcSize, retSize); break;
-    case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS:                   getCap<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS                   >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_SAMPLERS:                                getCap<CL_DEVICE_MAX_SAMPLERS                                >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_WORK_GROUP_SIZE:                         getCap<CL_DEVICE_MAX_WORK_GROUP_SIZE                         >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:                    getCap<CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS                    >(src, srcSize, retSize); break;
    case CL_DEVICE_MAX_WORK_ITEM_SIZES:                         getCap<CL_DEVICE_MAX_WORK_ITEM_SIZES                         >(src, srcSize, retSize); break;
-    case CL_DEVICE_MAX_WRITE_IMAGE_ARGS:                        getCap<CL_DEVICE_MAX_WRITE_IMAGE_ARGS                        >(src, srcSize, retSize); break;
    case CL_DEVICE_MEM_BASE_ADDR_ALIGN:                         getCap<CL_DEVICE_MEM_BASE_ADDR_ALIGN                         >(src, srcSize, retSize); break;
    case CL_DEVICE_ME_VERSION_INTEL:                            getCap<CL_DEVICE_ME_VERSION_INTEL                            >(src, srcSize, retSize); break;
    case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:                    getCap<CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE                    >(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<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL>(src, srcSize, retSize);
-        break;
-    case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL:
-        if (deviceInfo.nv12Extension)
-            getCap<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL>(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<CL_DEVICE_MAX_READ_IMAGE_ARGS>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS:
+        getCap<CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_MAX_WRITE_IMAGE_ARGS:
+        getCap<CL_DEVICE_MAX_WRITE_IMAGE_ARGS>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE2D_MAX_HEIGHT:
+        getCap<CL_DEVICE_IMAGE2D_MAX_HEIGHT>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE2D_MAX_WIDTH:
+        getCap<CL_DEVICE_IMAGE2D_MAX_WIDTH>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE3D_MAX_DEPTH:
+        getCap<CL_DEVICE_IMAGE3D_MAX_DEPTH>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE3D_MAX_HEIGHT:
+        getCap<CL_DEVICE_IMAGE3D_MAX_HEIGHT>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE3D_MAX_WIDTH:
+        getCap<CL_DEVICE_IMAGE3D_MAX_WIDTH>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT:
+        getCap<CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE:
+        getCap<CL_DEVICE_IMAGE_MAX_ARRAY_SIZE>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE:
+        getCap<CL_DEVICE_IMAGE_MAX_BUFFER_SIZE>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_IMAGE_PITCH_ALIGNMENT:
+        getCap<CL_DEVICE_IMAGE_PITCH_ALIGNMENT>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL:
+        if (deviceInfo.nv12Extension)
+            getCap<CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL>(src, srcSize, retSize);
+        break;
+    case CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL:
+        if (deviceInfo.nv12Extension)
+            getCap<CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL>(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);
--- 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<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
+    cl_device_id clDevice = device.get();
+    cl_int retVal;
+    auto context = ReleaseableObjectPtr<Context>(Context::create<Context>(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>(Device::create<RootDevice>(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>(Context::create<Context>(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);
+}
--- 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<uint32_t, size_t> 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<uint32_t, size_t> 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<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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<uint32_t, size_t> 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<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    size_t sizeReturned = 0;
--- 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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(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,