intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove not used image transforming logic

Browse Source 
image transformer logic was used on gen9 and gen11

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-09-17 14:21:15 +00:00
committed by Compute-Runtime-Automation
parent 927b797071
commit 16458ca0ac
16 changed files with 4 additions and 673 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/kernel/CMakeLists.txt
View File

@@ -1,13 +1,11 @@
#
# Copyright (C) 2018-2022 Intel Corporation
# Copyright (C) 2018-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(RUNTIME_SRCS_KERNEL
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/image_transformer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/image_transformer.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_info_cl.h

51
opencl/source/kernel/image_transformer.cpp
View File

@@ -1,51 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/source/kernel/image_transformer.h"
#include "shared/source/compiler_interface/external_functions.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/kernel/implicit_args_helper.h"
#include "shared/source/program/kernel_info.h"
#include "opencl/source/mem_obj/image.h"
namespace NEO {
void ImageTransformer::registerImage3d(uint32_t argIndex) {
if (std::find(argIndexes.begin(), argIndexes.end(), argIndex) == argIndexes.end()) {
argIndexes.push_back(argIndex);
}
}
void ImageTransformer::transformImagesTo2dArray(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh) {
for (auto const &argIndex : argIndexes) {
const auto &arg = kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[argIndex];
if (arg.getExtendedTypeInfo().isTransformable) {
auto clMemObj = static_cast<cl_mem>(kernelArguments.at(argIndex).object);
auto image = castToObjectOrAbort<Image>(clMemObj);
auto surfaceState = ptrOffset(ssh, arg.as<ArgDescImage>().bindful);
image->transformImage3dTo2dArray(surfaceState);
}
}
transformed = true;
}
void ImageTransformer::transformImagesTo3d(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh) {
for (auto const &argIndex : argIndexes) {
const auto &arg = kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[argIndex];
auto clMemObj = static_cast<cl_mem>(kernelArguments.at(argIndex).object);
auto image = castToObjectOrAbort<Image>(clMemObj);
auto surfaceState = ptrOffset(ssh, arg.as<ArgDescImage>().bindful);
image->transformImage2dArrayTo3d(surfaceState);
}
transformed = false;
}
bool ImageTransformer::didTransform() const {
return transformed;
}
bool ImageTransformer::hasRegisteredImages3d() const {
return !argIndexes.empty();
}
} // namespace NEO

25
opencl/source/kernel/image_transformer.h
View File

@@ -1,25 +0,0 @@
/*
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "opencl/source/kernel/kernel.h"
namespace NEO {
class ImageTransformer {
public:
void registerImage3d(uint32_t argIndex);
void transformImagesTo2dArray(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh);
void transformImagesTo3d(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh);
bool didTransform() const;
bool hasRegisteredImages3d() const;
protected:
bool transformed = false;
std::vector<uint32_t> argIndexes;
};
} // namespace NEO

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

@@ -56,7 +56,6 @@
#include "opencl/source/helpers/dispatch_info.h"
#include "opencl/source/helpers/get_info_status_mapper.h"
#include "opencl/source/helpers/sampler_helpers.h"
#include "opencl/source/kernel/image_transformer.h"
#include "opencl/source/kernel/kernel_info_cl.h"
#include "opencl/source/mem_obj/buffer.h"
#include "opencl/source/mem_obj/image.h"
@@ -85,7 +84,6 @@ Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &c
kernelInfo(kernelInfoArg) {
program->retain();
program->retainForKernel();
imageTransformer.reset(new ImageTransformer);
auto &deviceInfo = getDevice().getDevice().getDeviceInfo();
if (isSimd1(kernelInfoArg.kernelDescriptor.kernelAttributes.simdSize)) {
auto &productHelper = getDevice().getProductHelper();
@@ -894,8 +892,6 @@ void Kernel::markArgPatchedAndResolveArgs(uint32_t argIndex) {
migratableArgsMap.erase(argIndex);
}
}
resolveArgs();
}
cl_int Kernel::setArg(uint32_t argIndex, size_t argSize, const void *argVal) {
@@ -1725,10 +1721,6 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
auto &imageFormat = pImage->getImageFormat();
auto graphicsAllocation = pImage->getGraphicsAllocation(rootDeviceIndex);
if (imageDesc.image_type == CL_MEM_OBJECT_IMAGE3D) {
imageTransformer->registerImage3d(argIndex);
}
patch<uint32_t, cl_uint>(imageDesc.num_samples, crossThreadData, argAsImg.metadataPayload.numSamples);
patch<uint32_t, cl_uint>(imageDesc.num_mip_levels, crossThreadData, argAsImg.metadataPayload.numMipLevels);
patch<uint32_t, uint64_t>(imageDesc.image_width, crossThreadData, argAsImg.metadataPayload.imgWidth);
@@ -1980,34 +1972,6 @@ cl_int Kernel::checkCorrectImageAccessQualifier(cl_uint argIndex,
return CL_SUCCESS;
}
void Kernel::resolveArgs() {
if (!Kernel::isPatched() || !imageTransformer->hasRegisteredImages3d() || !canTransformImages())
return;
bool canTransformImageTo2dArray = true;
const auto &args = kernelInfo.kernelDescriptor.payloadMappings.explicitArgs;
for (uint32_t i = 0; i < patchedArgumentsNum; i++) {
if (args[i].is<ArgDescriptor::argTSampler>()) {
auto sampler = castToObject<Sampler>(kernelArguments.at(i).object);
if (sampler->isTransformable()) {
canTransformImageTo2dArray = true;
} else {
canTransformImageTo2dArray = false;
break;
}
}
}
if (canTransformImageTo2dArray) {
imageTransformer->transformImagesTo2dArray(kernelInfo, kernelArguments, getSurfaceStateHeap());
} else if (imageTransformer->didTransform()) {
imageTransformer->transformImagesTo3d(kernelInfo, kernelArguments, getSurfaceStateHeap());
}
}
bool Kernel::canTransformImages() const {
return false;
}
std::unique_ptr<KernelObjsForAuxTranslation> Kernel::fillWithKernelObjsForAuxTranslation() {
auto kernelObjsForAuxTranslation = std::make_unique<KernelObjsForAuxTranslation>();
kernelObjsForAuxTranslation->reserve(getKernelArgsNumber());

4
opencl/source/kernel/kernel.h
View File

@@ -37,7 +37,6 @@ class Buffer;
class CommandQueue;
class CommandStreamReceiver;
class GraphicsAllocation;
class ImageTransformer;
class Surface;
class PrintfHandler;
class MultiDeviceKernel;
@@ -142,7 +141,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
MOCKABLE_VIRTUAL cl_int cloneKernel(Kernel *pSourceKernel);
MOCKABLE_VIRTUAL bool canTransformImages() const;
MOCKABLE_VIRTUAL bool isPatched() const;
// API entry points
@@ -453,7 +451,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
void provideInitializationHints();
void markArgPatchedAndResolveArgs(uint32_t argIndex);
void resolveArgs();
void reconfigureKernel();
bool hasDirectStatelessAccessToSharedBuffer() const;
@@ -484,7 +481,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
std::vector<PatchInfoData> patchInfoDataList;
std::vector<size_t> slmSizes;
std::unique_ptr<ImageTransformer> imageTransformer;
std::unique_ptr<char[]> pSshLocal;
std::unique_ptr<ImplicitArgs> pImplicitArgs = nullptr;

8
opencl/source/sampler/sampler.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -217,12 +217,6 @@ cl_int Sampler::getInfo(cl_sampler_info paramName, size_t paramValueSize,
return retVal;
}
bool Sampler::isTransformable() const {
return addressingMode == CL_ADDRESS_CLAMP_TO_EDGE &&
filterMode == CL_FILTER_NEAREST &&
normalizedCoordinates == CL_FALSE;
}
void Sampler::storeProperties(const cl_sampler_properties *properties) {
if (properties) {
for (size_t i = 0; properties[i] != 0; i += 2) {

4
opencl/source/sampler/sampler.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -53,8 +53,6 @@ class Sampler : public BaseObject<_cl_sampler> {
virtual void setArg(void *memory, const RootDeviceEnvironment &rootDeviceEnvironment) = 0;
bool isTransformable() const;
Sampler(Context *context,
cl_bool normalizedCoordinates,
cl_addressing_mode addressingMode,

5
opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp
View File

@@ -89,7 +89,6 @@ HWTEST_F(EnqueueReadImageTest, whenEnqueueReadImageThenBuiltinKernelIsResolved)
auto pEvent = castToObject<Event>(outputEvent);
auto pCommand = static_cast<CommandComputeKernel *>(pEvent->peekCommand());
EXPECT_FALSE(pCommand->peekKernel()->Kernel::canTransformImages());
EXPECT_TRUE(pCommand->peekKernel()->isPatched());
userEvent.setStatus(CL_COMPLETE);
pEvent->release();
@@ -252,7 +251,6 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageThen
auto pEvent = castToObject<Event>(outputEvent);
auto pCommand = static_cast<CommandComputeKernel *>(pEvent->peekCommand());
auto pKernel = pCommand->peekKernel();
EXPECT_FALSE(pKernel->Kernel::canTransformImages());
EXPECT_TRUE(pKernel->isPatched());
EXPECT_TRUE(pKernel->requiresMemoryMigration());
@@ -306,7 +304,6 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageIsCa
auto pEvent0 = castToObject<Event>(outputEvent0);
auto pCommand0 = static_cast<CommandComputeKernel *>(pEvent0->peekCommand());
auto pKernel0 = pCommand0->peekKernel();
EXPECT_FALSE(pKernel0->Kernel::canTransformImages());
EXPECT_TRUE(pKernel0->isPatched());
EXPECT_TRUE(pKernel0->requiresMemoryMigration());
@@ -334,7 +331,6 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageIsCa
auto pEvent1 = castToObject<Event>(outputEvent1);
auto pCommand1 = static_cast<CommandComputeKernel *>(pEvent1->peekCommand());
auto pKernel1 = pCommand1->peekKernel();
EXPECT_FALSE(pKernel1->Kernel::canTransformImages());
EXPECT_TRUE(pKernel1->isPatched());
EXPECT_TRUE(pKernel1->requiresMemoryMigration());
@@ -527,7 +523,6 @@ HWTEST2_F(EnqueueReadImageTest, givenImageFromBufferThatRequiresMigrationWhenEnq
auto pEvent = castToObject<Event>(outputEvent);
auto pCommand = static_cast<CommandComputeKernel *>(pEvent->peekCommand());
auto pKernel = pCommand->peekKernel();
EXPECT_FALSE(pKernel->Kernel::canTransformImages());
EXPECT_TRUE(pKernel->isPatched());
EXPECT_TRUE(pKernel->requiresMemoryMigration());

4
opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp
View File

@@ -552,7 +552,6 @@ HWTEST_F(EnqueueWriteImageTest, whenEnqueueWriteImageThenBuiltinKernelIsResolved
auto pEvent = castToObject<Event>(outputEvent);
auto pCommand = static_cast<CommandComputeKernel *>(pEvent->peekCommand());
EXPECT_FALSE(pCommand->peekKernel()->Kernel::canTransformImages());
EXPECT_TRUE(pCommand->peekKernel()->isPatched());
userEvent.setStatus(CL_COMPLETE);
pEvent->release();
@@ -586,7 +585,6 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenEnqueueWriteImageTh
auto pEvent = castToObject<Event>(outputEvent);
auto pCommand = static_cast<CommandComputeKernel *>(pEvent->peekCommand());
auto pKernel = pCommand->peekKernel();
EXPECT_FALSE(pKernel->Kernel::canTransformImages());
EXPECT_TRUE(pKernel->isPatched());
EXPECT_TRUE(pKernel->requiresMemoryMigration());
@@ -640,7 +638,6 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenEnqueueWriteImageIs
auto pEvent0 = castToObject<Event>(outputEvent0);
auto pCommand0 = static_cast<CommandComputeKernel *>(pEvent0->peekCommand());
auto pKernel0 = pCommand0->peekKernel();
EXPECT_FALSE(pKernel0->Kernel::canTransformImages());
EXPECT_TRUE(pKernel0->isPatched());
EXPECT_TRUE(pKernel0->requiresMemoryMigration());
@@ -668,7 +665,6 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenEnqueueWriteImageIs
auto pEvent1 = castToObject<Event>(outputEvent1);
auto pCommand1 = static_cast<CommandComputeKernel *>(pEvent1->peekCommand());
auto pKernel1 = pCommand1->peekKernel();
EXPECT_FALSE(pKernel1->Kernel::canTransformImages());
EXPECT_TRUE(pKernel1->isPatched());
EXPECT_TRUE(pKernel1->requiresMemoryMigration());

7
opencl/test/unit_test/gen12lp/kernel_tests_gen12lp.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2023 Intel Corporation
* Copyright (C) 2019-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,11 +16,6 @@
using namespace NEO;
using Gen12LpKernelTest = Test<ClDeviceFixture>;
GEN12LPTEST_F(Gen12LpKernelTest, givenKernelWhenCanTransformImagesIsCalledThenReturnsFalse) {
MockKernelWithInternals mockKernel(*pClDevice);
auto retVal = mockKernel.mockKernel->Kernel::canTransformImages();
EXPECT_FALSE(retVal);
}
GEN12LPTEST_F(Gen12LpKernelTest, GivenKernelWhenNotUsingSharedObjArgsThenWaDisableRccRhwoOptimizationIsNotRequired) {
MockKernelWithInternals kernel(*pClDevice);

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

@@ -8,7 +8,6 @@ set(IGDRCL_SRCS_tests_kernel
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/cache_flush_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/clone_kernel_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/image_transformer_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_accelerator_arg_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_buffer_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_buffer_fixture.h
@@ -23,7 +22,6 @@ set(IGDRCL_SRCS_tests_kernel
${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_arg_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_transformable_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/debug_kernel_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/substitute_kernel_heap_tests.cpp
)

185
opencl/test/unit_test/kernel/image_transformer_tests.cpp
View File

@@ -1,185 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/program/kernel_info.h"
#include "shared/test/common/mocks/mock_kernel_info.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/kernel/image_transformer.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
using namespace NEO;
class ImageTransformerTest : public ::testing::Test {
public:
void SetUp() override {
using SimpleKernelArgInfo = Kernel::SimpleKernelArgInfo;
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->addArgImage(0, firstImageOffset, iOpenCL::IMAGE_MEMORY_OBJECT_2D, true);
pKernelInfo->addArgImage(1, secondImageOffset, iOpenCL::IMAGE_MEMORY_OBJECT_2D, true);
image1.reset(Image3dHelper<>::create(&context));
image2.reset(Image3dHelper<>::create(&context));
SimpleKernelArgInfo imageArg1;
SimpleKernelArgInfo imageArg2;
clImage1 = static_cast<cl_mem>(image2.get());
clImage2 = static_cast<cl_mem>(image2.get());
imageArg1.value = &clImage1;
imageArg1.object = clImage1;
imageArg2.value = &clImage2;
imageArg2.object = clImage2;
kernelArguments.push_back(imageArg1);
kernelArguments.push_back(imageArg2);
}
const int firstImageOffset = 0x20;
const int secondImageOffset = 0x40;
std::unique_ptr<MockKernelInfo> pKernelInfo;
ImageTransformer imageTransformer;
MockContext context;
std::unique_ptr<Image> image1;
std::unique_ptr<Image> image2;
cl_mem clImage1;
cl_mem clImage2;
char ssh[0x80];
std::vector<Kernel::SimpleKernelArgInfo> kernelArguments;
};
TEST_F(ImageTransformerTest, givenImageTransformerWhenRegisterImage3dThenTransformerHasRegisteredImages3d) {
bool retVal;
retVal = imageTransformer.hasRegisteredImages3d();
EXPECT_FALSE(retVal);
imageTransformer.registerImage3d(0);
retVal = imageTransformer.hasRegisteredImages3d();
EXPECT_TRUE(retVal);
}
TEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage2dArrayThenTransformerDidTransform) {
bool retVal;
retVal = imageTransformer.didTransform();
EXPECT_FALSE(retVal);
imageTransformer.transformImagesTo2dArray(*pKernelInfo, kernelArguments, nullptr);
retVal = imageTransformer.didTransform();
EXPECT_TRUE(retVal);
}
TEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage3dThenTransformerDidNotTransform) {
bool retVal;
retVal = imageTransformer.didTransform();
EXPECT_FALSE(retVal);
imageTransformer.transformImagesTo2dArray(*pKernelInfo, kernelArguments, nullptr);
imageTransformer.transformImagesTo3d(*pKernelInfo, kernelArguments, nullptr);
retVal = imageTransformer.didTransform();
EXPECT_FALSE(retVal);
}
HWTEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage2dArrayThenTransformOnlyRegisteredImages) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
firstSurfaceState->setSurfaceArray(false);
secondSurfaceState->setSurfaceArray(false);
imageTransformer.registerImage3d(1);
imageTransformer.transformImagesTo2dArray(*pKernelInfo, kernelArguments, ssh);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, secondSurfaceState->getSurfaceType());
EXPECT_TRUE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage2dArrayThenTransformOnlyTransformableImages) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
pKernelInfo->argAt(1).getExtendedTypeInfo().isTransformable = false;
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
firstSurfaceState->setSurfaceArray(false);
secondSurfaceState->setSurfaceArray(false);
imageTransformer.registerImage3d(0);
imageTransformer.registerImage3d(1);
imageTransformer.transformImagesTo2dArray(*pKernelInfo, kernelArguments, ssh);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage3dThenTransformAllRegisteredImages) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
pKernelInfo->argAt(1).getExtendedTypeInfo().isTransformable = false;
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
firstSurfaceState->setSurfaceArray(true);
secondSurfaceState->setSurfaceArray(true);
imageTransformer.registerImage3d(0);
imageTransformer.registerImage3d(1);
imageTransformer.transformImagesTo3d(*pKernelInfo, kernelArguments, ssh);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(ImageTransformerTest, givenImageTransformerWhenTransformToImage3dThenTransformOnlyRegisteredImages) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
pKernelInfo->argAt(1).getExtendedTypeInfo().isTransformable = false;
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
firstSurfaceState->setSurfaceArray(true);
secondSurfaceState->setSurfaceArray(true);
imageTransformer.registerImage3d(1);
imageTransformer.transformImagesTo3d(*pKernelInfo, kernelArguments, ssh);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
class MockImageTransformer : public ImageTransformer {
public:
using ImageTransformer::argIndexes;
};
TEST(ImageTransformerRegisterImageTest, givenImageTransformerWhenRegisterTheSameImageTwiceThenAppendOnlyOne) {
MockImageTransformer transformer;
EXPECT_EQ(0u, transformer.argIndexes.size());
transformer.registerImage3d(0);
EXPECT_EQ(1u, transformer.argIndexes.size());
transformer.registerImage3d(0);
EXPECT_EQ(1u, transformer.argIndexes.size());
transformer.registerImage3d(1);
EXPECT_EQ(2u, transformer.argIndexes.size());
}

310
opencl/test/unit_test/kernel/kernel_transformable_tests.cpp
View File

@@ -1,310 +0,0 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/program/kernel_info.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/sampler/sampler.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/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "opencl/test/unit_test/mocks/mock_sampler.h"
#include <memory>
using namespace NEO;
class KernelTransformableTest : public ::testing::Test {
public:
void SetUp() override {
context = std::make_unique<MockContext>(deviceFactory.rootDevices[rootDeviceIndex]);
pKernelInfo = std::make_unique<MockKernelInfo>();
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.surfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->addArgSampler(0, 0);
pKernelInfo->addArgSampler(1, 0);
pKernelInfo->addArgImage(2, firstImageOffset);
pKernelInfo->addArgImage(3, secondImageOffset);
pKernelInfo->kernelDescriptor.kernelAttributes.numArgsToPatch = 4;
program = std::make_unique<MockProgram>(context.get(), false, toClDeviceVector(*context->getDevice(0)));
pKernel.reset(new MockKernel(program.get(), *pKernelInfo, *deviceFactory.rootDevices[rootDeviceIndex]));
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
pKernel->setKernelArgHandler(0, &Kernel::setArgSampler);
pKernel->setKernelArgHandler(1, &Kernel::setArgSampler);
pKernel->setKernelArgHandler(2, &Kernel::setArgImage);
pKernel->setKernelArgHandler(3, &Kernel::setArgImage);
}
Sampler *createTransformableSampler() {
return new MockSampler(nullptr, CL_FALSE, CL_ADDRESS_CLAMP_TO_EDGE, CL_FILTER_NEAREST);
}
Sampler *createNonTransformableSampler() {
return new MockSampler(nullptr, CL_TRUE, CL_ADDRESS_CLAMP_TO_EDGE, CL_FILTER_NEAREST);
}
const int firstImageOffset = 0x20;
const int secondImageOffset = 0x40;
cl_int retVal = CL_SUCCESS;
UltClDeviceFactory deviceFactory{2, 0};
std::unique_ptr<MockContext> context;
std::unique_ptr<MockProgram> program;
std::unique_ptr<Sampler> sampler;
std::unique_ptr<MockKernelInfo> pKernelInfo;
std::unique_ptr<MockKernel> pKernel;
std::unique_ptr<Image> image;
SKernelBinaryHeaderCommon kernelHeader;
char surfaceStateHeap[0x80];
const uint32_t rootDeviceIndex = 1;
};
HWTEST_F(KernelTransformableTest, givenKernelThatCannotTranformImagesWithTwoTransformableImagesAndTwoTransformableSamplersWhenAllArgsAreSetThenImagesAreNotTransformed) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->canKernelTransformImages = false;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithTwoTransformableImagesAndTwoTransformableSamplersWhenAllArgsAreSetThenImagesAreTransformed) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, secondSurfaceState->getSurfaceType());
EXPECT_TRUE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithTwoTransformableImagesAndTwoTransformableSamplersWhenAnyArgIsResetThenImagesAreTransformedAgain) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = false;
pKernel->setArg(3, sizeof(clImage), &clImage);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithOneTransformableImageAndTwoTransformableSamplersWhenAnyArgIsResetThenOnlyOneImageIsTransformed) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = false;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithImages2dAndTwoTransformableSamplersWhenAnyArgIsResetThenImagesAreNotTransformed) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image2dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithTwoTransformableImagesAndTwoTransformableSamplersWhenChangeSamplerToNontransformableThenImagesAreTransformedTo3d) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
std::unique_ptr<Sampler> sampler2(createNonTransformableSampler());
cl_sampler clSampler2 = sampler2.get();
pKernel->setArg(1, sizeof(clSampler2), &clSampler2);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
pKernel.reset();
}
HWTEST_F(KernelTransformableTest, givenKernelWithNonTransformableSamplersWhenResetSamplerWithNontransformableThenImagesNotChangedAgain) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
sampler.reset(createNonTransformableSampler());
cl_mem clImage = image.get();
cl_sampler clSampler = sampler.get();
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->setArg(0, sizeof(clSampler), &clSampler);
pKernel->setArg(1, sizeof(clSampler), &clSampler);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
firstSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
secondSurfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL);
pKernel->setArg(0, sizeof(clSampler), &clSampler);
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL, firstSurfaceState->getSurfaceType());
EXPECT_FALSE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_NULL, secondSurfaceState->getSurfaceType());
EXPECT_FALSE(secondSurfaceState->getSurfaceArray());
}
HWTEST_F(KernelTransformableTest, givenKernelWithoutSamplersAndTransformableImagesWhenResolveKernelThenImagesAreTransformed) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
image.reset(Image3dHelper<>::create(context.get()));
cl_mem clImage = image.get();
pKernelInfo->kernelDescriptor.payloadMappings.explicitArgs.clear();
pKernelInfo->addArgImage(0, 0);
pKernelInfo->addArgImage(1, 0);
pKernelInfo->addArgImage(2, firstImageOffset);
pKernelInfo->argAt(2).getExtendedTypeInfo().isTransformable = true;
pKernelInfo->addArgImage(3, secondImageOffset);
pKernelInfo->argAt(3).getExtendedTypeInfo().isTransformable = true;
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
pKernel->setArg(0, sizeof(clImage), &clImage);
pKernel->setArg(1, sizeof(clImage), &clImage);
pKernel->setArg(2, sizeof(clImage), &clImage);
pKernel->setArg(3, sizeof(clImage), &clImage);
auto ssh = pKernel->getSurfaceStateHeap();
auto firstSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, firstImageOffset));
auto secondSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ptrOffset(ssh, secondImageOffset));
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, firstSurfaceState->getSurfaceType());
EXPECT_TRUE(firstSurfaceState->getSurfaceArray());
EXPECT_EQ(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D, secondSurfaceState->getSurfaceType());
EXPECT_TRUE(secondSurfaceState->getSurfaceArray());
}

4
opencl/test/unit_test/mocks/mock_kernel.cpp
View File

@@ -26,10 +26,6 @@ bool MockKernel::isPatched() const {
return isPatchedOverride;
}
bool MockKernel::canTransformImages() const {
return canKernelTransformImages;
}
void MockKernel::makeResident(CommandStreamReceiver &commandStreamReceiver) {
makeResidentCalls++;
Kernel::makeResident(commandStreamReceiver);

2
opencl/test/unit_test/mocks/mock_kernel.h
View File

@@ -183,8 +183,6 @@ class MockKernel : public Kernel {
bool isPatched() const override;
bool canTransformImages() const override;
////////////////////////////////////////////////////////////////////////////////
void setCrossThreadData(const void *crossThreadDataPattern, uint32_t newCrossThreadDataSize) {
if ((crossThreadData != nullptr) && (crossThreadData != mockCrossThreadData.data())) {

26
opencl/test/unit_test/sampler/sampler_tests.cpp
View File

@@ -93,32 +93,6 @@ INSTANTIATE_TEST_SUITE_P(Sampler,
::testing::ValuesIn(addressingModes),
::testing::ValuesIn(filterModes)));
typedef ::testing::TestWithParam<std::tuple<uint32_t /*normalizedCoords*/, uint32_t /*addressingMode*/, uint32_t /*filterMode*/>> TransformableSamplerTest;
TEST_P(TransformableSamplerTest, givenSamplerWhenHasProperParametersThenIsTransformable) {
bool expectedRetVal;
bool retVal;
cl_bool normalizedCoords;
cl_addressing_mode addressingMode;
cl_filter_mode filterMode;
std::tie(normalizedCoords, addressingMode, filterMode) = GetParam();
expectedRetVal = addressingMode == CL_ADDRESS_CLAMP_TO_EDGE &&
filterMode == CL_FILTER_NEAREST &&
normalizedCoords == CL_FALSE;
MockSampler sampler(nullptr, normalizedCoords, addressingMode, filterMode);
retVal = sampler.isTransformable();
EXPECT_EQ(expectedRetVal, retVal);
}
INSTANTIATE_TEST_SUITE_P(Sampler,
TransformableSamplerTest,
::testing::Combine(
::testing::ValuesIn(normalizedCoordModes),
::testing::ValuesIn(addressingModes),
::testing::ValuesIn(filterModes)));
TEST(castToSamplerTest, GivenGenericPointerWhichHoldsSamplerObjectWhenCastToSamplerIsCalledThenCastWithSuccess) {
cl_int retVal;
auto context = std::make_unique<MockContext>();