diff --git a/runtime/context/context.cpp b/runtime/context/context.cpp index a1eeb7d632..101b9475ac 100644 --- a/runtime/context/context.cpp +++ b/runtime/context/context.cpp @@ -253,85 +253,51 @@ cl_int Context::getSupportedImageFormats( cl_uint numEntries, cl_image_format *imageFormats, cl_uint *numImageFormatsReturned) { - size_t numImageFormats = 0; - size_t numDepthFormats = 0; - const SurfaceFormatInfo *baseSurfaceFormats = nullptr; - const SurfaceFormatInfo *depthFormats = nullptr; - const bool nv12ExtensionEnabled = device->getDeviceInfo().nv12Extension; const bool packedYuvExtensionEnabled = device->getDeviceInfo().packedYuvExtension; - bool appendPlanarYUVSurfaces = false; - bool appendPackedYUVSurfaces = false; - bool appendDepthSurfaces = true; + + auto appendImageFormats = [&](ArrayRef formats) { + if (imageFormats) { + size_t offset = numImageFormats; + for (size_t i = 0; i < formats.size() && offset < numEntries; ++i) { + imageFormats[offset++] = formats[i].OCLImageFormat; + } + } + numImageFormats += formats.size(); + }; if (flags & CL_MEM_READ_ONLY) { - numImageFormats = numReadOnlySurfaceFormats; - baseSurfaceFormats = readOnlySurfaceFormats; - depthFormats = readOnlyDepthSurfaceFormats; - numDepthFormats = numReadOnlyDepthSurfaceFormats; - appendPlanarYUVSurfaces = true; - appendPackedYUVSurfaces = true; + appendImageFormats(SurfaceFormats::readOnly()); + if (Image::isImage2d(imageType) && nv12ExtensionEnabled) { + appendImageFormats(SurfaceFormats::planarYuv()); + } + if (Image::isImage2dOr2dArray(imageType)) { + appendImageFormats(SurfaceFormats::readOnlyDepth()); + } + if (Image::isImage2d(imageType) && packedYuvExtensionEnabled) { + appendImageFormats(SurfaceFormats::packedYuv()); + } } else if (flags & CL_MEM_WRITE_ONLY) { - numImageFormats = numWriteOnlySurfaceFormats; - baseSurfaceFormats = writeOnlySurfaceFormats; - depthFormats = readWriteDepthSurfaceFormats; - numDepthFormats = numReadWriteDepthSurfaceFormats; + appendImageFormats(SurfaceFormats::writeOnly()); + if (Image::isImage2dOr2dArray(imageType)) { + appendImageFormats(SurfaceFormats::readWriteDepth()); + } } else if (nv12ExtensionEnabled && (flags & CL_MEM_NO_ACCESS_INTEL)) { - numImageFormats = numReadOnlySurfaceFormats; - baseSurfaceFormats = readOnlySurfaceFormats; - appendPlanarYUVSurfaces = true; + appendImageFormats(SurfaceFormats::readOnly()); + if (Image::isImage2d(imageType)) { + appendImageFormats(SurfaceFormats::planarYuv()); + } } else { - numImageFormats = numReadWriteSurfaceFormats; - baseSurfaceFormats = readWriteSurfaceFormats; - depthFormats = readWriteDepthSurfaceFormats; - numDepthFormats = numReadWriteDepthSurfaceFormats; - } - - if (!Image::isImage2d(imageType)) { - appendPlanarYUVSurfaces = false; - appendPackedYUVSurfaces = false; - } - if (!Image::isImage2dOr2dArray(imageType)) { - appendDepthSurfaces = false; - } - - if (imageFormats) { - cl_uint entry = 0; - auto appendFormats = [&](const SurfaceFormatInfo *srcSurfaceFormats, size_t srcFormatsCount) { - for (size_t srcFormatPos = 0; srcFormatPos < srcFormatsCount && entry < numEntries; ++srcFormatPos, ++entry) { - imageFormats[entry] = srcSurfaceFormats[srcFormatPos].OCLImageFormat; - } - }; - - appendFormats(baseSurfaceFormats, numImageFormats); - - if (nv12ExtensionEnabled && appendPlanarYUVSurfaces) { - appendFormats(planarYuvSurfaceFormats, numPlanarYuvSurfaceFormats); - } - - if (appendDepthSurfaces) { - appendFormats(depthFormats, numDepthFormats); - } - - if (packedYuvExtensionEnabled && appendPackedYUVSurfaces) { - appendFormats(packedYuvSurfaceFormats, numPackedYuvSurfaceFormats); + appendImageFormats(SurfaceFormats::readWrite()); + if (Image::isImage2dOr2dArray(imageType)) { + appendImageFormats(SurfaceFormats::readWriteDepth()); } } - if (numImageFormatsReturned) { - if (nv12ExtensionEnabled && appendPlanarYUVSurfaces) { - numImageFormats += numPlanarYuvSurfaceFormats; - } - if (packedYuvExtensionEnabled && appendPackedYUVSurfaces) { - numImageFormats += numPackedYuvSurfaceFormats; - } - if (appendDepthSurfaces) { - numImageFormats += numDepthFormats; - } - *numImageFormatsReturned = static_cast(numImageFormats); } return CL_SUCCESS; } + } // namespace OCLRT diff --git a/runtime/helpers/surface_formats.cpp b/runtime/helpers/surface_formats.cpp index 3d31b63b80..0900e38c58 100644 --- a/runtime/helpers/surface_formats.cpp +++ b/runtime/helpers/surface_formats.cpp @@ -9,6 +9,8 @@ #include "runtime/helpers/array_count.h" #include "runtime/gmm_helper/gmm_lib.h" #include "runtime/api/cl_types.h" +#include "validators.h" +#include "runtime/mem_obj/image.h" namespace OCLRT { @@ -16,7 +18,7 @@ namespace OCLRT { //Initialize this with the required formats first. //Append the optional one later -const SurfaceFormatInfo readOnlySurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::readOnlySurfaceFormats[] = { {{CL_RGBA, CL_UNORM_INT8}, GMM_FORMAT_R8G8B8A8_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM , 0, 4, 1, 4}, {{CL_RGBA, CL_UNORM_INT16}, GMM_FORMAT_R16G16B16A16_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM , 0, 4, 2, 8}, {{CL_RGBA, CL_SIGNED_INT8}, GMM_FORMAT_R8G8B8A8_SINT_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT , 0, 4, 1, 4}, @@ -72,7 +74,7 @@ const SurfaceFormatInfo readOnlySurfaceFormats[] = { {{CL_RGBA, CL_SNORM_INT16}, GMM_FORMAT_R16G16B16A16_SNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SNORM , 0, 4, 2, 8}, }; -const SurfaceFormatInfo writeOnlySurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::writeOnlySurfaceFormats[] = { {{CL_RGBA, CL_UNORM_INT8}, GMM_FORMAT_R8G8B8A8_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM , 0, 4, 1, 4}, {{CL_RGBA, CL_UNORM_INT16}, GMM_FORMAT_R16G16B16A16_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM , 0, 4, 2, 8}, {{CL_RGBA, CL_SIGNED_INT8}, GMM_FORMAT_R8G8B8A8_SINT_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT , 0, 4, 1, 4}, @@ -119,7 +121,7 @@ const SurfaceFormatInfo writeOnlySurfaceFormats[] = { {{CL_RGBA, CL_SNORM_INT16}, GMM_FORMAT_R16G16B16A16_SNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SNORM , 0, 4, 2, 8}, }; -const SurfaceFormatInfo readWriteSurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::readWriteSurfaceFormats[] = { {{CL_RGBA, CL_UNORM_INT8}, GMM_FORMAT_R8G8B8A8_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM , 0, 4, 1, 4}, {{CL_RGBA, CL_UNORM_INT16}, GMM_FORMAT_R16G16B16A16_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM , 0, 4, 2, 8}, {{CL_RGBA, CL_SIGNED_INT8}, GMM_FORMAT_R8G8B8A8_SINT_TYPE, GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT , 0, 4, 1, 4}, @@ -167,40 +169,105 @@ const SurfaceFormatInfo readWriteSurfaceFormats[] = { }; #if SUPPORT_YUV -const SurfaceFormatInfo packedYuvSurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::packedYuvSurfaceFormats[] = { {{CL_YUYV_INTEL, CL_UNORM_INT8}, GMM_FORMAT_YUY2, GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL , 0, 2, 1, 2}, {{CL_UYVY_INTEL, CL_UNORM_INT8}, GMM_FORMAT_UYVY, GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY , 0, 2, 1, 2}, {{CL_YVYU_INTEL, CL_UNORM_INT8}, GMM_FORMAT_YVYU, GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV , 0, 2, 1, 2}, {{CL_VYUY_INTEL, CL_UNORM_INT8}, GMM_FORMAT_VYUY, GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY , 0, 2, 1, 2} }; -const SurfaceFormatInfo planarYuvSurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::planarYuvSurfaceFormats[] = { {{CL_NV12_INTEL, CL_UNORM_INT8}, GMM_FORMAT_NV12, GFX3DSTATE_SURFACEFORMAT_NV12 , 0, 1, 1, 1} }; -const size_t numPackedYuvSurfaceFormats = arrayCount(packedYuvSurfaceFormats); -const size_t numPlanarYuvSurfaceFormats = arrayCount(planarYuvSurfaceFormats); + #endif -const SurfaceFormatInfo readOnlyDepthSurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::readOnlyDepthSurfaceFormats[] = { {{ CL_DEPTH, CL_FLOAT}, GMM_FORMAT_R32_FLOAT_TYPE, GFX3DSTATE_SURFACEFORMAT_R32_FLOAT , 0, 1, 4, 4}, {{ CL_DEPTH, CL_UNORM_INT16}, GMM_FORMAT_R16_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16_UNORM , 0, 1, 2, 2}, {{ CL_DEPTH_STENCIL, CL_UNORM_INT24}, GMM_FORMAT_GENERIC_32BIT, GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS , 0, 1, 4, 4}, {{ CL_DEPTH_STENCIL, CL_FLOAT}, GMM_FORMAT_R32G32_FLOAT_TYPE, GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS, 0, 2, 4, 8} }; -const SurfaceFormatInfo readWriteDepthSurfaceFormats[] = { +const SurfaceFormatInfo SurfaceFormats::readWriteDepthSurfaceFormats[] = { {{ CL_DEPTH, CL_FLOAT}, GMM_FORMAT_R32_FLOAT_TYPE, GFX3DSTATE_SURFACEFORMAT_R32_FLOAT , 0, 1, 4, 4}, {{ CL_DEPTH, CL_UNORM_INT16}, GMM_FORMAT_R16_UNORM_TYPE, GFX3DSTATE_SURFACEFORMAT_R16_UNORM , 0, 1, 2, 2} }; -const size_t numReadOnlyDepthSurfaceFormats = arrayCount(readOnlyDepthSurfaceFormats); -const size_t numReadWriteDepthSurfaceFormats = arrayCount(readWriteDepthSurfaceFormats); +ArrayRef SurfaceFormats::readOnly() noexcept { + return ArrayRef(readOnlySurfaceFormats); +} +ArrayRef SurfaceFormats::writeOnly() noexcept { + return ArrayRef(writeOnlySurfaceFormats); +} -const size_t numReadOnlySurfaceFormats = arrayCount(readOnlySurfaceFormats); -const size_t numWriteOnlySurfaceFormats = arrayCount(writeOnlySurfaceFormats); -const size_t numReadWriteSurfaceFormats = arrayCount(readWriteSurfaceFormats); +ArrayRef SurfaceFormats::readWrite() noexcept { + return ArrayRef(readWriteSurfaceFormats); +} + +ArrayRef SurfaceFormats::packedYuv() noexcept { +#if SUPPORT_YUV + return ArrayRef(packedYuvSurfaceFormats); +#else + return ArrayRef(); +#endif +} + +ArrayRef SurfaceFormats::planarYuv() noexcept { +#if SUPPORT_YUV + return ArrayRef(planarYuvSurfaceFormats); +#else + return ArrayRef(); +#endif +} + +ArrayRef SurfaceFormats::readOnlyDepth() noexcept { + return ArrayRef(readOnlyDepthSurfaceFormats); +} + +ArrayRef SurfaceFormats::readWriteDepth() noexcept { + return ArrayRef(readWriteDepthSurfaceFormats); +} + +ArrayRef SurfaceFormats::surfaceFormats(cl_mem_flags flags) noexcept { + if (flags & CL_MEM_READ_ONLY) { + return readOnly(); + } + else if (flags & CL_MEM_WRITE_ONLY) { + return writeOnly(); + } + else { + return readWrite(); + } +} + +ArrayRef SurfaceFormats::surfaceFormats(cl_mem_flags flags, const cl_image_format *imageFormat) noexcept { + if (OCLRT::IsNV12Image(imageFormat)) { + return planarYuv(); + } + else if (IsPackedYuvImage(imageFormat)) { + return packedYuv(); + } + else if (Image::isDepthFormat(*imageFormat)) { + if (flags & CL_MEM_READ_ONLY) { + return readOnlyDepth(); + } + else { + return readWriteDepth(); + } + } + else if (flags & CL_MEM_READ_ONLY) { + return readOnly(); + } + else if (flags & CL_MEM_WRITE_ONLY) { + return writeOnly(); + } + else { + return readWrite(); + } +} // clang-format on } // namespace OCLRT diff --git a/runtime/helpers/surface_formats.h b/runtime/helpers/surface_formats.h index ce67cb0a71..4ea71db710 100644 --- a/runtime/helpers/surface_formats.h +++ b/runtime/helpers/surface_formats.h @@ -14,6 +14,7 @@ #endif #include "runtime/gmm_helper/gmm_lib.h" +#include "runtime/utilities/arrayref.h" namespace OCLRT { enum GFX3DSTATE_SURFACEFORMAT : unsigned short { @@ -227,26 +228,29 @@ struct McsSurfaceInfo { uint32_t multisampleCount; }; -extern const size_t numReadOnlySurfaceFormats; -extern const size_t numWriteOnlySurfaceFormats; -extern const size_t numReadWriteSurfaceFormats; - -extern const SurfaceFormatInfo readOnlySurfaceFormats[]; -extern const SurfaceFormatInfo writeOnlySurfaceFormats[]; -extern const SurfaceFormatInfo readWriteSurfaceFormats[]; -extern const SurfaceFormatInfo noAccessSurfaceFormats[]; - +class SurfaceFormats { + private: + static const SurfaceFormatInfo readOnlySurfaceFormats[]; + static const SurfaceFormatInfo writeOnlySurfaceFormats[]; + static const SurfaceFormatInfo readWriteSurfaceFormats[]; + static const SurfaceFormatInfo readOnlyDepthSurfaceFormats[]; + static const SurfaceFormatInfo readWriteDepthSurfaceFormats[]; #ifdef SUPPORT_YUV -extern const size_t numPackedYuvSurfaceFormats; -extern const size_t numPlanarYuvSurfaceFormats; -extern const SurfaceFormatInfo packedYuvSurfaceFormats[]; -extern const SurfaceFormatInfo planarYuvSurfaceFormats[]; + static const SurfaceFormatInfo packedYuvSurfaceFormats[]; + static const SurfaceFormatInfo planarYuvSurfaceFormats[]; #endif -extern const size_t numReadOnlyDepthSurfaceFormats; -extern const size_t numReadWriteDepthSurfaceFormats; + public: + static ArrayRef readOnly() noexcept; + static ArrayRef writeOnly() noexcept; + static ArrayRef readWrite() noexcept; + static ArrayRef packedYuv() noexcept; + static ArrayRef planarYuv() noexcept; + static ArrayRef readOnlyDepth() noexcept; + static ArrayRef readWriteDepth() noexcept; -extern const SurfaceFormatInfo readOnlyDepthSurfaceFormats[]; -extern const SurfaceFormatInfo readWriteDepthSurfaceFormats[]; + static ArrayRef surfaceFormats(cl_mem_flags flags) noexcept; + static ArrayRef surfaceFormats(cl_mem_flags flags, const cl_image_format *imageFormat) noexcept; +}; } // namespace OCLRT diff --git a/runtime/mem_obj/image.cpp b/runtime/mem_obj/image.cpp index 6a99b956dd..85df475cb2 100644 --- a/runtime/mem_obj/image.cpp +++ b/runtime/mem_obj/image.cpp @@ -776,6 +776,8 @@ Image *Image::redescribeFillImage() { uint32_t redescribeTableCol = this->surfaceFormatInfo.NumChannels / 2; uint32_t redescribeTableRow = this->surfaceFormatInfo.PerChannelSizeInBytes / 2; + ArrayRef readWriteSurfaceFormats = SurfaceFormats::readWrite(); + uint32_t surfaceFormatIdx = redescribeTable[redescribeTableRow][redescribeTableCol]; surfaceFormat = &readWriteSurfaceFormats[surfaceFormatIdx]; @@ -822,6 +824,8 @@ Image *Image::redescribe() { DEBUG_BREAK_IF(exponent >= 32); uint32_t surfaceFormatIdx = redescribeTableBytes[exponent % 5]; + ArrayRef readWriteSurfaceFormats = SurfaceFormats::readWrite(); + surfaceFormat = &readWriteSurfaceFormats[surfaceFormatIdx]; imageFormatNew.image_channel_order = surfaceFormat->OCLImageFormat.image_channel_order; @@ -925,52 +929,17 @@ const SurfaceFormatInfo *Image::getSurfaceFormatFromTable(cl_mem_flags flags, co DEBUG_BREAK_IF("Invalid format"); return nullptr; } - const SurfaceFormatInfo *surfaceFormatTable = nullptr; - size_t numSurfaceFormats = 0; - bool isDepthFormat = Image::isDepthFormat(*imageFormat); - if (IsNV12Image(imageFormat)) { -#if SUPPORT_YUV - surfaceFormatTable = planarYuvSurfaceFormats; - numSurfaceFormats = numPlanarYuvSurfaceFormats; -#else - return nullptr; -#endif - } else if (IsPackedYuvImage(imageFormat)) { -#if SUPPORT_YUV - surfaceFormatTable = packedYuvSurfaceFormats; - numSurfaceFormats = numPackedYuvSurfaceFormats; -#else - return nullptr; -#endif - } else if ((flags & CL_MEM_READ_ONLY) == CL_MEM_READ_ONLY) { - surfaceFormatTable = isDepthFormat ? readOnlyDepthSurfaceFormats : readOnlySurfaceFormats; - numSurfaceFormats = isDepthFormat ? numReadOnlyDepthSurfaceFormats : numReadOnlySurfaceFormats; - } else if ((flags & CL_MEM_WRITE_ONLY) == CL_MEM_WRITE_ONLY) { - surfaceFormatTable = isDepthFormat ? readWriteDepthSurfaceFormats : writeOnlySurfaceFormats; - numSurfaceFormats = isDepthFormat ? numReadWriteDepthSurfaceFormats : numWriteOnlySurfaceFormats; - } else { - surfaceFormatTable = isDepthFormat ? readWriteDepthSurfaceFormats : readWriteSurfaceFormats; - numSurfaceFormats = isDepthFormat ? numReadWriteDepthSurfaceFormats : numReadWriteSurfaceFormats; - } + ArrayRef formats = SurfaceFormats::surfaceFormats(flags, imageFormat); - // Find a matching surface format - size_t indexSurfaceFormat = 0; - while (indexSurfaceFormat < numSurfaceFormats) { - const auto &surfaceFormat = surfaceFormatTable[indexSurfaceFormat].OCLImageFormat; - if (surfaceFormat.image_channel_data_type == imageFormat->image_channel_data_type && - surfaceFormat.image_channel_order == imageFormat->image_channel_order) { - break; + for (auto &format : formats) { + if (format.OCLImageFormat.image_channel_data_type == imageFormat->image_channel_data_type && + format.OCLImageFormat.image_channel_order == imageFormat->image_channel_order) { + return &format; } - ++indexSurfaceFormat; } - - if (indexSurfaceFormat >= numSurfaceFormats) { - DEBUG_BREAK_IF("Invalid format"); - return nullptr; - } - - return &surfaceFormatTable[indexSurfaceFormat]; + DEBUG_BREAK_IF("Invalid format"); + return nullptr; } bool Image::isImage2d(cl_mem_object_type imageType) { diff --git a/runtime/sharings/d3d/d3d_sharing.cpp b/runtime/sharings/d3d/d3d_sharing.cpp index 5eae67023c..4cb9b5af32 100644 --- a/runtime/sharings/d3d/d3d_sharing.cpp +++ b/runtime/sharings/d3d/d3d_sharing.cpp @@ -83,26 +83,11 @@ void D3DSharing::updateImgInfo(Gmm *gmm, ImageInfo &imgInfo, cl_image_desc template const SurfaceFormatInfo *D3DSharing::findSurfaceFormatInfo(GMM_RESOURCE_FORMAT_ENUM gmmFormat, cl_mem_flags flags) { - const SurfaceFormatInfo *surfaceFormatTable = nullptr; - const SurfaceFormatInfo *surfaceFormatInfo = nullptr; - size_t numSurfaceFormats = 0; - - if ((flags & CL_MEM_READ_ONLY) == CL_MEM_READ_ONLY) { - surfaceFormatTable = readOnlySurfaceFormats; - numSurfaceFormats = numReadOnlySurfaceFormats; - } else if ((flags & CL_MEM_WRITE_ONLY) == CL_MEM_WRITE_ONLY) { - surfaceFormatTable = writeOnlySurfaceFormats; - numSurfaceFormats = numWriteOnlySurfaceFormats; - } else { - surfaceFormatTable = readWriteSurfaceFormats; - numSurfaceFormats = numReadWriteSurfaceFormats; - } - - for (size_t i = 0; i < numSurfaceFormats; i++) { - if (gmmFormat == surfaceFormatTable[i].GMMSurfaceFormat) { - surfaceFormatInfo = &surfaceFormatTable[i]; - break; + ArrayRef formats = SurfaceFormats::surfaceFormats(flags); + for (auto &format : formats) { + if (gmmFormat == format.GMMSurfaceFormat) { + return &format; } } - return surfaceFormatInfo; + return nullptr; } diff --git a/unit_tests/context/get_supported_image_formats_tests.cpp b/unit_tests/context/get_supported_image_formats_tests.cpp index 2dc2c9a629..b64e156467 100644 --- a/unit_tests/context/get_supported_image_formats_tests.cpp +++ b/unit_tests/context/get_supported_image_formats_tests.cpp @@ -146,12 +146,12 @@ TEST_P(GetSupportedImageFormatsTest, retrieveImageFormatsSRGB) { } TEST(ImageFormats, isDepthFormat) { - for (size_t i = 0; i < numReadOnlySurfaceFormats; i++) { - EXPECT_FALSE(Image::isDepthFormat(readOnlySurfaceFormats[i].OCLImageFormat)); + for (auto &format : SurfaceFormats::readOnly()) { + EXPECT_FALSE(Image::isDepthFormat(format.OCLImageFormat)); } - for (size_t i = 0; i < numReadOnlyDepthSurfaceFormats; i++) { - EXPECT_TRUE(Image::isDepthFormat(readOnlyDepthSurfaceFormats[i].OCLImageFormat)); + for (auto &format : SurfaceFormats::readOnlyDepth()) { + EXPECT_TRUE(Image::isDepthFormat(format.OCLImageFormat)); } } @@ -274,17 +274,17 @@ TEST_P(NV12ExtensionSupportedImageFormatsTest, givenNV12ExtensionWhenQueriedForI nullptr, &numImageFormats); - size_t expectedNumReadOnlyFormats = numReadOnlySurfaceFormats; + size_t expectedNumReadOnlyFormats = SurfaceFormats::readOnly().size(); if (Image::isImage2dOr2dArray(imageFormats) && imageFormatsFlags == CL_MEM_READ_ONLY) { - expectedNumReadOnlyFormats += numReadOnlyDepthSurfaceFormats; + expectedNumReadOnlyFormats += SurfaceFormats::readOnlyDepth().size(); } if (Image::isImage2d(imageFormats)) { if (imageFormatsFlags == CL_MEM_READ_ONLY) { - EXPECT_EQ(expectedNumReadOnlyFormats + numPlanarYuvSurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(expectedNumReadOnlyFormats + SurfaceFormats::planarYuv().size(), static_cast(numImageFormats)); } if (imageFormatsFlags == CL_MEM_NO_ACCESS_INTEL) { - EXPECT_EQ(expectedNumReadOnlyFormats + numPlanarYuvSurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(expectedNumReadOnlyFormats + SurfaceFormats::planarYuv().size(), static_cast(numImageFormats)); } } else { if (imageFormatsFlags == CL_MEM_READ_ONLY) { @@ -344,17 +344,19 @@ TEST_P(NV12ExtensionUnsupportedImageFormatsTest, givenNV12ExtensionWhenQueriedFo if (imageFormatsFlags == CL_MEM_WRITE_ONLY) { if (!Image::isImage2dOr2dArray(imageFormats)) { - EXPECT_EQ(numWriteOnlySurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(SurfaceFormats::writeOnly().size(), static_cast(numImageFormats)); } else { - EXPECT_EQ(numWriteOnlySurfaceFormats + numReadWriteDepthSurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(SurfaceFormats::writeOnly().size() + SurfaceFormats::readWriteDepth().size(), + static_cast(numImageFormats)); } } if (imageFormatsFlags == CL_MEM_READ_WRITE) { if (!Image::isImage2dOr2dArray(imageFormats)) { - EXPECT_EQ(numReadWriteSurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(SurfaceFormats::readWrite().size(), static_cast(numImageFormats)); } else { - EXPECT_EQ(numReadWriteSurfaceFormats + numReadWriteDepthSurfaceFormats, static_cast(numImageFormats)); + EXPECT_EQ(SurfaceFormats::readWrite().size() + SurfaceFormats::readWriteDepth().size(), + static_cast(numImageFormats)); } } diff --git a/unit_tests/d3d_sharing/d3d_tests.cpp b/unit_tests/d3d_sharing/d3d_tests.cpp index 0df456972c..6368d4b23d 100644 --- a/unit_tests/d3d_sharing/d3d_tests.cpp +++ b/unit_tests/d3d_sharing/d3d_tests.cpp @@ -801,46 +801,46 @@ TYPED_TEST_P(D3DTests, givenInvalidSubresourceWhenCreateTexture3dIsCalledThenFai } TYPED_TEST_P(D3DTests, givenReadonlyFormatWhenLookingForSurfaceFormatThenReturnValidFormat) { - EXPECT_GT(numReadOnlySurfaceFormats, 0u); - for (size_t i = 0; i < numReadOnlySurfaceFormats; i++) { + EXPECT_GT(SurfaceFormats::readOnly().size(), 0u); + for (auto &format : SurfaceFormats::readOnly()) { // only RGBA, BGRA, RG, R allowed for D3D - if (readOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RGBA || - readOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_BGRA || - readOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RG || - readOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_R) { - auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(readOnlySurfaceFormats[i].GMMSurfaceFormat, CL_MEM_READ_ONLY); + if (format.OCLImageFormat.image_channel_order == CL_RGBA || + format.OCLImageFormat.image_channel_order == CL_BGRA || + format.OCLImageFormat.image_channel_order == CL_RG || + format.OCLImageFormat.image_channel_order == CL_R) { + auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(format.GMMSurfaceFormat, CL_MEM_READ_ONLY); ASSERT_NE(nullptr, surfaceFormat); - EXPECT_EQ(&readOnlySurfaceFormats[i], surfaceFormat); + EXPECT_EQ(&format, surfaceFormat); } } } TYPED_TEST_P(D3DTests, givenWriteOnlyFormatWhenLookingForSurfaceFormatThenReturnValidFormat) { - EXPECT_GT(numWriteOnlySurfaceFormats, 0u); - for (size_t i = 0; i < numWriteOnlySurfaceFormats; i++) { + EXPECT_GT(SurfaceFormats::writeOnly().size(), 0u); + for (auto &format : SurfaceFormats::writeOnly()) { // only RGBA, BGRA, RG, R allowed for D3D - if (writeOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RGBA || - writeOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_BGRA || - writeOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RG || - writeOnlySurfaceFormats[i].OCLImageFormat.image_channel_order == CL_R) { - auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(writeOnlySurfaceFormats[i].GMMSurfaceFormat, CL_MEM_WRITE_ONLY); + if (format.OCLImageFormat.image_channel_order == CL_RGBA || + format.OCLImageFormat.image_channel_order == CL_BGRA || + format.OCLImageFormat.image_channel_order == CL_RG || + format.OCLImageFormat.image_channel_order == CL_R) { + auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(format.GMMSurfaceFormat, CL_MEM_WRITE_ONLY); ASSERT_NE(nullptr, surfaceFormat); - EXPECT_EQ(&writeOnlySurfaceFormats[i], surfaceFormat); + EXPECT_EQ(&format, surfaceFormat); } } } TYPED_TEST_P(D3DTests, givenReadWriteFormatWhenLookingForSurfaceFormatThenReturnValidFormat) { - EXPECT_GT(numReadWriteSurfaceFormats, 0u); - for (size_t i = 0; i < numReadWriteSurfaceFormats; i++) { + EXPECT_GT(SurfaceFormats::readWrite().size(), 0u); + for (auto &format : SurfaceFormats::readWrite()) { // only RGBA, BGRA, RG, R allowed for D3D - if (readWriteSurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RGBA || - readWriteSurfaceFormats[i].OCLImageFormat.image_channel_order == CL_BGRA || - readWriteSurfaceFormats[i].OCLImageFormat.image_channel_order == CL_RG || - readWriteSurfaceFormats[i].OCLImageFormat.image_channel_order == CL_R) { - auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(readWriteSurfaceFormats[i].GMMSurfaceFormat, CL_MEM_READ_WRITE); + if (format.OCLImageFormat.image_channel_order == CL_RGBA || + format.OCLImageFormat.image_channel_order == CL_BGRA || + format.OCLImageFormat.image_channel_order == CL_RG || + format.OCLImageFormat.image_channel_order == CL_R) { + auto surfaceFormat = D3DSharing::findSurfaceFormatInfo(format.GMMSurfaceFormat, CL_MEM_READ_WRITE); ASSERT_NE(nullptr, surfaceFormat); - EXPECT_EQ(&readWriteSurfaceFormats[i], surfaceFormat); + EXPECT_EQ(&format, surfaceFormat); } } } diff --git a/unit_tests/mem_obj/create_image_format_tests.cpp b/unit_tests/mem_obj/create_image_format_tests.cpp index 0c8d5df6df..fef2b5bc56 100644 --- a/unit_tests/mem_obj/create_image_format_tests.cpp +++ b/unit_tests/mem_obj/create_image_format_tests.cpp @@ -1,23 +1,8 @@ /* - * Copyright (c) 2017, Intel Corporation + * Copyright (C) 2017-2018 Intel Corporation * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: + * SPDX-License-Identifier: MIT * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR - * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, - * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR - * OTHER DEALINGS IN THE SOFTWARE. */ #include "runtime/helpers/surface_formats.h" @@ -41,22 +26,10 @@ class CreateImageFormatTest : public testing::TestWithParam { void SetUp() override { indexImageFormat = GetParam(); - const SurfaceFormatInfo *surfaceFormatTable = nullptr; - size_t numSurfaceFormats = 0; + ArrayRef surfaceFormatTable = SurfaceFormats::surfaceFormats(flags); + ASSERT_GT(surfaceFormatTable.size(), indexImageFormat); - if ((flags & CL_MEM_READ_ONLY) == CL_MEM_READ_ONLY) { - surfaceFormatTable = readOnlySurfaceFormats; - numSurfaceFormats = numReadOnlySurfaceFormats; - } else if ((flags & CL_MEM_WRITE_ONLY) == CL_MEM_WRITE_ONLY) { - surfaceFormatTable = writeOnlySurfaceFormats; - numSurfaceFormats = numWriteOnlySurfaceFormats; - } else { - surfaceFormatTable = readWriteSurfaceFormats; - numSurfaceFormats = numReadWriteSurfaceFormats; - } - ASSERT_GT(numSurfaceFormats, indexImageFormat); - - surfaceFormat = (SurfaceFormatInfo *)&surfaceFormatTable[indexImageFormat]; + surfaceFormat = &surfaceFormatTable[indexImageFormat]; // clang-format off imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D; imageDesc.image_width = testImageDimensions; @@ -74,7 +47,7 @@ class CreateImageFormatTest : public testing::TestWithParam { void TearDown() override { } - SurfaceFormatInfo *surfaceFormat; + const SurfaceFormatInfo *surfaceFormat; size_t indexImageFormat; cl_image_format imageFormat; cl_image_desc imageDesc; @@ -104,7 +77,7 @@ static const size_t zero = 0; INSTANTIATE_TEST_CASE_P( CreateImage, ReadWriteFormatTest, - testing::Range(zero, numReadWriteSurfaceFormats)); + testing::Range(zero, SurfaceFormats::readWrite().size())); typedef CreateImageFormatTest ReadOnlyFormatTest; @@ -125,7 +98,7 @@ TEST_P(ReadOnlyFormatTest, returnsSuccess) { INSTANTIATE_TEST_CASE_P( CreateImage, ReadOnlyFormatTest, - testing::Range(zero, numReadOnlySurfaceFormats)); + testing::Range(zero, SurfaceFormats::readOnly().size())); typedef CreateImageFormatTest WriteOnlyFormatTest; @@ -146,4 +119,4 @@ TEST_P(WriteOnlyFormatTest, returnsSuccess) { INSTANTIATE_TEST_CASE_P( CreateImage, WriteOnlyFormatTest, - testing::Range(zero, numWriteOnlySurfaceFormats)); + testing::Range(zero, SurfaceFormats::writeOnly().size())); diff --git a/unit_tests/mem_obj/image_redescribe_tests.cpp b/unit_tests/mem_obj/image_redescribe_tests.cpp index a2dcdaf61d..ad8f4faf0b 100644 --- a/unit_tests/mem_obj/image_redescribe_tests.cpp +++ b/unit_tests/mem_obj/image_redescribe_tests.cpp @@ -27,6 +27,7 @@ class ImageRedescribeTest : public testing::TestWithParamGetParam(); + ArrayRef readWriteSurfaceFormats = SurfaceFormats::readWrite(); auto &surfaceFormatInfo = readWriteSurfaceFormats[indexImageFormat]; imageFormat = surfaceFormatInfo.OCLImageFormat; @@ -144,6 +145,7 @@ TEST_P(ImageRedescribeTest, givenImageWithMaxSizesWhenItIsRedescribedThenNewImag auto memoryManager = (OsAgnosticMemoryManager *)context.getMemoryManager(); memoryManager->turnOnFakingBigAllocations(); + ArrayRef readWriteSurfaceFormats = SurfaceFormats::readWrite(); auto &surfaceFormatInfo = readWriteSurfaceFormats[indexImageFormat]; imageFormat = surfaceFormatInfo.OCLImageFormat; @@ -208,10 +210,10 @@ static uint32_t ImageType[] = { CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY}; -decltype(numReadWriteSurfaceFormats) readWriteSurfaceFormatsStart = 0u; +decltype(SurfaceFormats::readWrite().size()) readWriteSurfaceFormatsStart = 0u; INSTANTIATE_TEST_CASE_P( Redescribe, ImageRedescribeTest, testing::Combine( - ::testing::Range(readWriteSurfaceFormatsStart, numReadWriteSurfaceFormats), + ::testing::Range(readWriteSurfaceFormatsStart, SurfaceFormats::readWrite().size()), ::testing::ValuesIn(ImageType))); diff --git a/unit_tests/mem_obj/image_snorm_tests.cpp b/unit_tests/mem_obj/image_snorm_tests.cpp index 313d6d8c67..4e3b4ef0d8 100644 --- a/unit_tests/mem_obj/image_snorm_tests.cpp +++ b/unit_tests/mem_obj/image_snorm_tests.cpp @@ -14,11 +14,10 @@ using namespace OCLRT; const cl_mem_flags flagsForTests[] = {CL_MEM_READ_ONLY, CL_MEM_WRITE_ONLY, CL_MEM_READ_WRITE}; -const std::tuple paramsForSnormTests[] = { - std::make_tuple(readOnlySurfaceFormats, &numReadOnlySurfaceFormats), - std::make_tuple(writeOnlySurfaceFormats, &numWriteOnlySurfaceFormats), - std::make_tuple(readWriteSurfaceFormats, &numReadWriteSurfaceFormats), -}; +const ArrayRef paramsForSnormTests[] = { + SurfaceFormats::readOnly(), + SurfaceFormats::writeOnly(), + SurfaceFormats::readWrite()}; const std::array referenceSnormSurfaceFormats = {{ // clang-format off @@ -45,14 +44,13 @@ TEST_P(SnormSurfaceFormatAccessFlagsTests, givenSnormFormatWhenGetSurfaceFormatF } } -using SnormSurfaceFormatTests = ::testing::TestWithParam>; +using SnormSurfaceFormatTests = ::testing::TestWithParam>; TEST_P(SnormSurfaceFormatTests, givenSnormOclFormatWhenCheckingrReadOnlySurfaceFormatsThenFindExactCount) { - const SurfaceFormatInfo *formatsTable = std::get<0>(GetParam()); - size_t formatsTableCount = *std::get<1>(GetParam()); + ArrayRef formatsTable = GetParam(); size_t snormFormatsFound = 0; - for (size_t i = 0; i < formatsTableCount; i++) { + for (size_t i = 0; i < formatsTable.size(); ++i) { auto oclFormat = formatsTable[i].OCLImageFormat; if (CL_SNORM_INT8 == oclFormat.image_channel_data_type || CL_SNORM_INT16 == oclFormat.image_channel_data_type) { EXPECT_TRUE(oclFormat.image_channel_order == CL_R || oclFormat.image_channel_order == CL_RG || oclFormat.image_channel_order == CL_RGBA); diff --git a/unit_tests/mocks/mock_gmm.h b/unit_tests/mocks/mock_gmm.h index 5652f43a76..d3a29bb48b 100644 --- a/unit_tests/mocks/mock_gmm.h +++ b/unit_tests/mocks/mock_gmm.h @@ -29,6 +29,7 @@ class MockGmm : public Gmm { imgInfo.baseMipLevel = baseMipLevel; imgInfo.imgDesc = &imgDesc; if (!surfaceFormat) { + ArrayRef readWriteSurfaceFormats = SurfaceFormats::readWrite(); MockGmmParams::mockSurfaceFormat = readWriteSurfaceFormats[0]; // any valid format imgInfo.surfaceFormat = &MockGmmParams::mockSurfaceFormat; } else { diff --git a/unit_tests/mocks/mock_gmm_resource_info.cpp b/unit_tests/mocks/mock_gmm_resource_info.cpp index a3a508ae3c..6c3c3afec5 100644 --- a/unit_tests/mocks/mock_gmm_resource_info.cpp +++ b/unit_tests/mocks/mock_gmm_resource_info.cpp @@ -76,26 +76,26 @@ void MockGmmResourceInfo::computeRowPitch() { } void MockGmmResourceInfo::setSurfaceFormat() { - auto iterate = [&](const SurfaceFormatInfo *formats, const size_t numFormats) { + auto iterate = [&](ArrayRef formats) { if (!surfaceFormatInfo) { - for (size_t i = 0; i < numFormats; i++) { - if (mockResourceCreateParams.Format == formats[i].GMMSurfaceFormat) { - surfaceFormatInfo = &formats[i]; + for (auto &format : formats) { + if (mockResourceCreateParams.Format == format.GMMSurfaceFormat) { + surfaceFormatInfo = &format; break; } } } }; - iterate(readOnlySurfaceFormats, numReadOnlySurfaceFormats); - iterate(writeOnlySurfaceFormats, numWriteOnlySurfaceFormats); - iterate(readWriteSurfaceFormats, numReadWriteSurfaceFormats); + iterate(SurfaceFormats::readOnly()); + iterate(SurfaceFormats::writeOnly()); + iterate(SurfaceFormats::readWrite()); - iterate(packedYuvSurfaceFormats, numPackedYuvSurfaceFormats); - iterate(planarYuvSurfaceFormats, numPlanarYuvSurfaceFormats); + iterate(SurfaceFormats::packedYuv()); + iterate(SurfaceFormats::planarYuv()); - iterate(readOnlyDepthSurfaceFormats, numReadOnlyDepthSurfaceFormats); - iterate(readWriteDepthSurfaceFormats, numReadWriteDepthSurfaceFormats); + iterate(SurfaceFormats::readOnlyDepth()); + iterate(SurfaceFormats::readWriteDepth()); ASSERT_NE(nullptr, surfaceFormatInfo); }