Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Return error code for unsuported image arg in gen12lp"

Browse Source 
This reverts commit bbc31e6aac


Signed-off-by: Maciej Plewka maciej.plewka@intel.com
This commit is contained in:
Maciej Plewka
2022-11-02 07:29:46 +00:00
committed by Compute-Runtime-Automation
parent 0353116964
commit 7f38c5e633
24 changed files with 126 additions and 624 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -637,12 +637,6 @@ ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void
const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescImage>();
const auto image = Image::fromHandle(*static_cast<const ze_image_handle_t *>(argVal));
auto surfFormat = image->getImageInfo().surfaceFormat->GenxSurfaceFormat;
auto &hwHelper = NEO::HwHelper::get(this->module->getDevice()->getHwInfo().platform.eRenderCoreFamily);
if (isMediaBlockImage && !hwHelper.isSurfaceFormatSupportedForMediaBlockOperation(surfFormat)) {
return ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT;
}
if (kernelImmData->getDescriptor().kernelAttributes.imageAddressingMode == NEO::KernelDescriptor::Bindless) {
image->copySurfaceStateToSSH(patchBindlessSurfaceState(image->getAllocation(), arg.bindless), 0u, isMediaBlockImage);
} else {

1
level_zero/core/test/unit_tests/gen12lp/CMakeLists.txt
View File

@ -11,7 +11,6 @@ if(TESTS_GEN12LP)
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdlist_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_events_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_kernel_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_l0_hw_helper_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_module_gen12lp.cpp
)

68
level_zero/core/test/unit_tests/gen12lp/test_kernel_gen12lp.cpp
View File

@ -1,68 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/source/image/image_format_desc_helper.h"
#include "level_zero/core/source/image/image_hw.h"
#include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
namespace NEO {
}
namespace L0 {
namespace ult {
using SetKernelArg = Test<ModuleFixture>;
template <GFXCORE_FAMILY gfxCoreFamily>
struct MyMockImageMediaBlock : public WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>> {
using WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>>::imgInfo;
void copySurfaceStateToSSH(void *surfaceStateHeap, const uint32_t surfaceStateOffset, bool isMediaBlockArg) override {
isMediaBlockPassedValue = isMediaBlockArg;
}
bool isMediaBlockPassedValue = false;
};
HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImageHaveUnsuportedMediaBlockFormatThenSetArgReturnErrCode, IsGen12LP) {
auto hwInfo = device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
createKernel();
auto argIndex = 3u;
auto &arg = const_cast<NEO::ArgDescriptor &>(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]);
auto imageHW = std::make_unique<MyMockImageMediaBlock<gfxCoreFamily>>();
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
auto ret = imageHW->initialize(device, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
auto handle = imageHW->toHandle();
hwInfo->capabilityTable.supportsMediaBlock = true;
arg.getExtendedTypeInfo().isMediaBlockImage = true;
SurfaceFormatInfo surfInfo = {GMM_FORMAT_R32G32B32A32_FLOAT_TYPE, NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT, 0, 4, 4, 16};
imageHW.get()->imgInfo.surfaceFormat = &surfInfo;
EXPECT_EQ(kernel->setArgImage(argIndex, sizeof(imageHW.get()), &handle), ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
}
HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImagehaveSuportedMediaBlockFormatThenSetArgReturnSuccess, IsGen12LP) {
auto hwInfo = device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
createKernel();
auto argIndex = 3u;
auto &arg = const_cast<NEO::ArgDescriptor &>(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]);
auto imageHW = std::make_unique<MyMockImageMediaBlock<gfxCoreFamily>>();
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
auto ret = imageHW->initialize(device, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
auto handle = imageHW->toHandle();
hwInfo->capabilityTable.supportsMediaBlock = true;
arg.getExtendedTypeInfo().isMediaBlockImage = true;
SurfaceFormatInfo surfInfo = {GMM_FORMAT_Y216, NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM, 0, 4, 2, 8};
imageHW.get()->imgInfo.surfaceFormat = &surfInfo;
EXPECT_EQ(kernel->setArgImage(argIndex, sizeof(imageHW.get()), &handle), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

3
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -143,7 +143,6 @@ TEST_F(SetKernelArgCacheTest, givenValidBufferArgumentWhenSetMultipleTimesThenSe
EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation));
EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled);
// update allocationsCounter to 1
++svmAllocsManager->allocationsCounter;
ASSERT_EQ(mockKernel.kernelArgInfos[0].allocIdMemoryManagerCounter, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation));
@ -169,7 +168,6 @@ TEST_F(SetKernelArgCacheTest, givenValidBufferArgumentWhenSetMultipleTimesThenSe
EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation));
EXPECT_EQ(callCounter, mockKernel.setArgBufferWithAllocCalled);
// same setArg but different allocId - called
allocData->setAllocId(2u);
++svmAllocsManager->allocationsCounter;
ASSERT_NE(mockKernel.kernelArgInfos[0].allocIdMemoryManagerCounter, svmAllocsManager->allocationsCounter);
@ -2256,7 +2254,6 @@ HWTEST2_F(SetKernelArg, givenImageAndBindfulKernelWhenSetArgImageThenCopySurface
template <GFXCORE_FAMILY gfxCoreFamily>
struct MyMockImageMediaBlock : public WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>> {
using WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>>::imgInfo;
void copySurfaceStateToSSH(void *surfaceStateHeap, const uint32_t surfaceStateOffset, bool isMediaBlockArg) override {
isMediaBlockPassedValue = isMediaBlockArg;
}

6
opencl/source/kernel/kernel.cpp
View File

@ -1587,12 +1587,6 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
auto pImage = castToObject<Image>(clMemObj);
if (pImage && argSize == sizeof(cl_mem *)) {
auto surfFormat = pImage->getSurfaceFormatInfo().surfaceFormat.GenxSurfaceFormat;
auto &hwHelper = HwHelper::get(getHardwareInfo().platform.eRenderCoreFamily);
if (arg.getExtendedTypeInfo().isMediaBlockImage && !hwHelper.isSurfaceFormatSupportedForMediaBlockOperation(surfFormat)) {
return CL_INVALID_ARG_VALUE;
}
if (pImage->peekSharingHandler()) {
usingSharedObjArgs = true;
}

2
opencl/test/unit_test/fixtures/CMakeLists.txt
View File

@ -19,8 +19,6 @@ set(IGDRCL_SRCS_tests_fixtures
${CMAKE_CURRENT_SOURCE_DIR}/hello_world_kernel_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/image_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/image_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/image_set_arg_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/image_set_arg_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_data_fixture.cpp

82
opencl/test/unit_test/fixtures/image_set_arg_fixture.cpp
View File

@ -1,82 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/fixtures/image_set_arg_fixture.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "gtest/gtest.h"
namespace NEO {
void ImageSetArgTest::SetUp() {
ClDeviceFixture::setUp();
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00);
pKernelInfo->addArgImage(1, 0x40);
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
retVal = CL_INVALID_VALUE;
pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex), &retVal);
pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, retVal);
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
}
void ImageSetArgTest::TearDown() {
delete srcImage;
delete pMultiDeviceKernel;
delete context;
ClDeviceFixture::tearDown();
};
void ImageMediaBlockSetArgTest::SetUp() {
ClDeviceFixture::setUp();
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK);
pKernelInfo->addArgImage(0, 0x40, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK);
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
retVal = CL_INVALID_VALUE;
pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex), &retVal);
pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, retVal);
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
}
} // namespace NEO

72
opencl/test/unit_test/fixtures/image_set_arg_fixture.h
View File

@ -1,72 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/test.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "gtest/gtest.h"
namespace NEO {
class Kernel;
class Image;
class ImageSetArgTest : public ClDeviceFixture,
public testing::Test {
public:
ImageSetArgTest() = default;
protected:
template <typename FamilyType>
void setupChannels(int imgChannelOrder) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
if (imgChannelOrder == CL_A) {
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RA ||
imgChannelOrder == CL_R ||
imgChannelOrder == CL_Rx) {
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RG ||
imgChannelOrder == CL_RGx) {
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
}
void SetUp() override;
void TearDown() override;
cl_int retVal = CL_SUCCESS;
MockContext *context;
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
MultiDeviceKernel *pMultiDeviceKernel = nullptr;
std::unique_ptr<MockKernelInfo> pKernelInfo;
char surfaceStateHeap[0x80] = {};
Image *srcImage = nullptr;
GraphicsAllocation *srcAllocation = nullptr;
int expectedChannelRed = 0;
int expectedChannelGreen = 0;
int expectedChannelBlue = 0;
};
class ImageMediaBlockSetArgTest : public ImageSetArgTest {
protected:
void SetUp() override;
};
} // namespace NEO

1
opencl/test/unit_test/gen12lp/CMakeLists.txt
View File

@ -19,7 +19,6 @@ if(TESTS_GEN12LP)
${CMAKE_CURRENT_SOURCE_DIR}/gen12lp_tests_wrapper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gpgpu_walker_tests_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/image_set_arg_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/image_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/profiling_tests_gen12lp.inl

1
opencl/test/unit_test/gen12lp/gen12lp_tests_wrapper.cpp
View File

@ -9,7 +9,6 @@
#include "opencl/test/unit_test/gen12lp/command_stream_receiver_hw_tests_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/enqueue_media_kernel_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/hw_helper_tests_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/image_set_arg_tests_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/image_tests_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/kernel_tests_gen12lp.inl"
#include "opencl/test/unit_test/gen12lp/profiling_tests_gen12lp.inl"

32
opencl/test/unit_test/gen12lp/image_set_arg_tests_gen12lp.inl
View File

@ -1,32 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/fixtures/image_set_arg_fixture.h"
GEN12LPTEST_F(ImageMediaBlockSetArgTest, givenKernelWithMediaBlockOperationWhenSupportedFormatPassedThenSetKernelArgReturnSuccess) {
const_cast<ClSurfaceFormatInfo &>(srcImage->getSurfaceFormatInfo()).surfaceFormat.GenxSurfaceFormat = NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM;
cl_mem memObj = srcImage;
retVal = clSetKernelArg(
pMultiDeviceKernel,
0,
sizeof(memObj),
&memObj);
ASSERT_EQ(CL_SUCCESS, retVal);
}
GEN12LPTEST_F(ImageMediaBlockSetArgTest, givenKernelWithMediaBlockOperationWhenUnSupportedFormatPassedThenSetKernelArgReturnErrCode) {
const_cast<ClSurfaceFormatInfo &>(srcImage->getSurfaceFormatInfo()).surfaceFormat.GenxSurfaceFormat = NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT;
cl_mem memObj = srcImage;
retVal = clSetKernelArg(
pMultiDeviceKernel,
0,
sizeof(memObj),
&memObj);
ASSERT_EQ(CL_INVALID_ARG_VALUE, retVal);
}

119
opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
View File

@ -21,15 +21,100 @@
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/fixtures/image_set_arg_fixture.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "opencl/test/unit_test/mocks/mock_program.h"
#include "gtest/gtest.h"
using namespace NEO;
using namespace ::testing;
class ImageSetArgTest : public ClDeviceFixture,
public testing::Test {
public:
ImageSetArgTest() = default;
protected:
template <typename FamilyType>
void setupChannels(int imgChannelOrder) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
if (imgChannelOrder == CL_A) {
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RA ||
imgChannelOrder == CL_R ||
imgChannelOrder == CL_Rx) {
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RG ||
imgChannelOrder == CL_RGx) {
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
}
void SetUp() override {
ClDeviceFixture::setUp();
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00);
pKernelInfo->addArgImage(1, 0x40);
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
retVal = CL_INVALID_VALUE;
pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex), &retVal);
pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, retVal);
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
expectedChannelRed = 0;
expectedChannelGreen = 0;
expectedChannelBlue = 0;
}
void TearDown() override {
delete srcImage;
delete pMultiDeviceKernel;
delete context;
ClDeviceFixture::tearDown();
}
cl_int retVal = CL_SUCCESS;
MockContext *context;
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
MultiDeviceKernel *pMultiDeviceKernel = nullptr;
std::unique_ptr<MockKernelInfo> pKernelInfo;
char surfaceStateHeap[0x80] = {};
Image *srcImage = nullptr;
GraphicsAllocation *srcAllocation = nullptr;
int expectedChannelRed;
int expectedChannelGreen;
int expectedChannelBlue;
};
HWTEST_F(ImageSetArgTest, WhenSettingKernelArgImageThenSurfaceBaseAddressIsSetCorrectly) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
@ -829,6 +914,38 @@ HWTEST_F(ImageSetArgTest, givenNonCompressedResourceWhenSettingImgArgThenDontSet
}
/* cl_intel_media_block_io */
class ImageMediaBlockSetArgTest : public ImageSetArgTest {
protected:
void SetUp() override {
ClDeviceFixture::setUp();
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
// define kernel info
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
// setup kernel arg offsets
pKernelInfo->addArgImage(0, 0x00, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK);
pKernelInfo->addArgImage(0, 0x40, iOpenCL::IMAGE_MEMORY_OBJECT_2D_MEDIA_BLOCK);
program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
retVal = CL_INVALID_VALUE;
pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex), &retVal);
pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, retVal);
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
}
};
HWTEST_F(ImageMediaBlockSetArgTest, WhenSettingKernelArgImageThenPropertiesAreCorrect) {
auto gmmHelper = pDevice->getGmmHelper();
auto imageMocs = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_IMAGE);

6
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@ -15,7 +15,6 @@ using Family = NEO::Gen12LpFamily;
#include "shared/source/helpers/hw_helper_bdw_and_later.inl"
#include "shared/source/helpers/hw_helper_tgllp_and_later.inl"
#include "shared/source/helpers/logical_state_helper.inl"
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/os_interface/hw_info_config.h"
#include "engine_node.h"
@ -212,11 +211,6 @@ bool HwHelperHw<Family>::forceNonGpuCoherencyWA(bool requiresCoherency) const {
return false;
}
template <>
bool HwHelperHw<Family>::isSurfaceFormatSupportedForMediaBlockOperation(NEO::GFX3DSTATE_SURFACEFORMAT format) const {
return SupportedMediaFormatsHelper::isMediaFormatSupported(format);
}
template class HwHelperHw<Family>;
template class FlatBatchBufferHelperHw<Family>;
template struct MemorySynchronizationCommands<Family>;

2
shared/source/helpers/CMakeLists.txt
View File

@ -129,8 +129,6 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/stdio.h
${CMAKE_CURRENT_SOURCE_DIR}/string.h
${CMAKE_CURRENT_SOURCE_DIR}/string_helpers.h
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats.cpp
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats.h
${CMAKE_CURRENT_SOURCE_DIR}/surface_format_info.h
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet.cpp
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet.h

4
shared/source/helpers/hw_helper.h
View File

@ -35,7 +35,7 @@ struct AllocationProperties;
struct EncodeSurfaceStateArgs;
struct RootDeviceEnvironment;
struct PipeControlArgs;
enum GFX3DSTATE_SURFACEFORMAT : unsigned short;
class HwHelper {
public:
static HwHelper &get(GFXCORE_FAMILY gfxCore);
@ -161,7 +161,6 @@ class HwHelper {
virtual bool copyThroughLockedPtrEnabled() const = 0;
virtual uint32_t getAmountOfAllocationsToFill() const = 0;
virtual bool isChipsetUniqueUUIDSupported() const = 0;
virtual bool isSurfaceFormatSupportedForMediaBlockOperation(NEO::GFX3DSTATE_SURFACEFORMAT format) const = 0;
virtual bool isTimestampShiftRequired() const = 0;
protected:
@ -406,7 +405,6 @@ class HwHelperHw : public HwHelper {
bool copyThroughLockedPtrEnabled() const override;
uint32_t getAmountOfAllocationsToFill() const override;
bool isChipsetUniqueUUIDSupported() const override;
bool isSurfaceFormatSupportedForMediaBlockOperation(NEO::GFX3DSTATE_SURFACEFORMAT format) const override;
bool isTimestampShiftRequired() const override;
protected:

4
shared/source/helpers/hw_helper_base.inl
View File

@ -733,10 +733,6 @@ template <typename gfxProduct>
bool HwHelperHw<gfxProduct>::isChipsetUniqueUUIDSupported() const {
return false;
}
template <typename gfxProduct>
bool HwHelperHw<gfxProduct>::isSurfaceFormatSupportedForMediaBlockOperation(NEO::GFX3DSTATE_SURFACEFORMAT format) const {
return true;
}
template <typename gfxProduct>
bool HwHelperHw<gfxProduct>::isTimestampShiftRequired() const {

61
shared/source/helpers/supported_media_surface_formats.cpp
View File

@ -1,61 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include <algorithm>
#include <array>
namespace NEO {
constexpr std::array<NEO::GFX3DSTATE_SURFACEFORMAT, 42> supportedMediaSurfaceFormats = {NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R11G11B10_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_A16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY,
NEO::GFX3DSTATE_SURFACEFORMAT_PACKED_422_16};
bool SupportedMediaFormatsHelper::isMediaFormatSupported(NEO::GFX3DSTATE_SURFACEFORMAT format) {
return std::find(NEO::supportedMediaSurfaceFormats.begin(), NEO::supportedMediaSurfaceFormats.end(), format) != NEO::supportedMediaSurfaceFormats.end();
}
} // namespace NEO

16
shared/source/helpers/supported_media_surface_formats.h
View File

@ -1,16 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace NEO {
enum GFX3DSTATE_SURFACEFORMAT : unsigned short;
class SupportedMediaFormatsHelper {
public:
static bool isMediaFormatSupported(GFX3DSTATE_SURFACEFORMAT format);
};
} // namespace NEO

1
shared/test/unit_test/gen12lp/CMakeLists.txt
View File

@ -15,7 +15,6 @@ if(TESTS_GEN12LP)
${CMAKE_CURRENT_SOURCE_DIR}/excludes_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gen12lp_shared_tests_wrapper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_gen12lp_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sampler_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/simd_helper_tests_gen12lp.cpp

1
shared/test/unit_test/gen12lp/excludes_gen12lp.cpp
View File

@ -8,4 +8,3 @@
#include "shared/test/common/test_macros/hw_test_base.h"
HWTEST_EXCLUDE_PRODUCT(CommandEncodeStatesTest, whenAdjustPipelineSelectIsCalledThenNothingHappens, IGFX_GEN12LP_CORE);
HWTEST_EXCLUDE_PRODUCT(HwHelperMediaFormatsTest, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned, IGFX_GEN12LP_CORE);

25
shared/test/unit_test/gen12lp/hw_helper_tests_gen12lp.cpp
View File

@ -1,25 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/test/common/helpers/hw_helper_tests.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test.h"
extern std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>
formatsWithSupportValue[171];
using HwHelperMediaFormatsTestGen12LP = ::testing::TestWithParam<std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>>;
INSTANTIATE_TEST_CASE_P(AllFormatsWithMediaBlockSupportValue,
HwHelperMediaFormatsTestGen12LP,
::testing::ValuesIn(formatsWithSupportValue));
GEN12LPTEST_P(HwHelperMediaFormatsTestGen12LP, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned) {
auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_EQ(helper.isSurfaceFormatSupportedForMediaBlockOperation(GetParam().first), GetParam().second);
}

2
shared/test/unit_test/helpers/CMakeLists.txt
View File

@ -27,7 +27,6 @@ target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/get_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/heap_assigner_shared_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_helpers_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/l3_range_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/matcher_tests.cpp
@ -37,7 +36,6 @@ target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_to_hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats_test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_debug_variables.inl
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config.cpp
${CMAKE_CURRENT_SOURCE_DIR}/cache_policy_tests.cpp

27
shared/test/unit_test/helpers/hw_helper_tests.cpp
View File

@ -1,27 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/helpers/hw_helper_tests.h"
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test.h"
extern std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>
formatsWithSupportValue[171];
using HwHelperMediaFormatsTest = ::testing::TestWithParam<std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>>;
INSTANTIATE_TEST_CASE_P(AllFormatsWithMediaBlockSupportValue,
HwHelperMediaFormatsTest,
::testing::ValuesIn(formatsWithSupportValue));
HWTEST_P(HwHelperMediaFormatsTest, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned) {
auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_TRUE(helper.isSurfaceFormatSupportedForMediaBlockOperation(GetParam().first));
}

194
shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp
View File

@ -1,194 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/test/common/test_macros/test.h"
std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>
formatsWithSupportValue[171]{
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_X32_TYPELESS_G8X24_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10_SNORM_A2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R11G11B10_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_X24_TYPELESS_G8_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16A16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R9G9B9E5_SHAREDEXP, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10X2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10X2_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R5G5_SNORM_B6_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_Y8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_DXT1_RGB_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R1_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC1_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC3_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC5_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC3_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_MONO8, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_DXT1_RGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_FXT1, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64B64A64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64B64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC4_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC5_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC6H_SF16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC7_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC7_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC6H_UF16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PACKED_422_16, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_RAW, false)};
using MediaBlockSupportedFormatsTests = ::testing::TestWithParam<std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>>;
INSTANTIATE_TEST_CASE_P(AllFormatsWithMediaBlockSupportValue,
MediaBlockSupportedFormatsTests,
::testing::ValuesIn(formatsWithSupportValue));
TEST_P(MediaBlockSupportedFormatsTests, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned) {
EXPECT_EQ(NEO::SupportedMediaFormatsHelper::isMediaFormatSupported(GetParam().first), GetParam().second);
}