Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add check if device support Images.

Browse Source 
Related-To: NEO-4675
Change-Id: I0c2b6e04536e45e70748983521e8469dd3dad697
This commit is contained in:
Sebastian Luzynski
2020-05-25 10:21:04 +02:00
committed by sys_ocldev
parent d635eb6300
commit fa3cb35fde
15 changed files with 236 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
opencl/source/api/api.cpp
View File

@ -834,9 +834,15 @@ cl_mem CL_API_CALL clCreateImage(cl_context context,
cl_mem_properties *properties = nullptr;
cl_mem_flags_intel flagsIntel = 0;
cl_mem image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal);
ErrorCodeHelper err(errcodeRet, retVal);
retVal = Image::checkIfDeviceSupportsImages(context);
cl_mem image = nullptr;
if (retVal == CL_SUCCESS) {
image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal);
}
ErrorCodeHelper{errcodeRet, retVal};
DBG_LOG_INPUTS("image", image);
TRACING_EXIT(clCreateImage, &image);
return image;
@ -866,7 +872,13 @@ cl_mem CL_API_CALL clCreateImageWithProperties(cl_context context,
API_ENTER(&retVal);
cl_mem_flags_intel flagsIntel = 0;
cl_mem image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal);
retVal = Image::checkIfDeviceSupportsImages(context);
cl_mem image = nullptr;
if (retVal == CL_SUCCESS) {
image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal);
}
ErrorCodeHelper{errcodeRet, retVal};
DBG_LOG_INPUTS("image", image);
@ -935,7 +947,13 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context,
cl_mem_properties *properties = nullptr;
cl_mem_flags_intel flagsIntel = 0;
cl_mem image2D = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, &imageDesc, hostPtr, retVal);
retVal = Image::checkIfDeviceSupportsImages(context);
cl_mem image2D = nullptr;
if (retVal == CL_SUCCESS) {
image2D = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, &imageDesc, hostPtr, retVal);
}
ErrorCodeHelper{errcodeRet, retVal};
DBG_LOG_INPUTS("image 2D", image2D);
@ -981,7 +999,13 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context,
cl_mem_properties *properties = nullptr;
cl_mem_flags_intel intelFlags = 0;
cl_mem image3D = ImageFunctions::validateAndCreateImage(context, properties, flags, intelFlags, imageFormat, &imageDesc, hostPtr, retVal);
retVal = Image::checkIfDeviceSupportsImages(context);
cl_mem image3D = nullptr;
if (retVal == CL_SUCCESS) {
image3D = ImageFunctions::validateAndCreateImage(context, properties, flags, intelFlags, imageFormat, &imageDesc, hostPtr, retVal);
}
ErrorCodeHelper{errcodeRet, retVal};
DBG_LOG_INPUTS("image 3D", image3D);

15
opencl/source/mem_obj/image.cpp
View File

@ -1453,4 +1453,19 @@ bool Image::hasValidParentImageFormat(const cl_image_format &imageFormat) const
return false;
}
}
cl_int Image::checkIfDeviceSupportsImages(cl_context context) {
auto pContext = castToObject<Context>(context);
if (pContext != nullptr) {
auto capabilityTable = pContext->getDevice(0)->getHardwareInfo().capabilityTable;
if (!capabilityTable.supportsImages) {
return CL_INVALID_OPERATION;
}
return CL_SUCCESS;
}
return CL_INVALID_CONTEXT;
}
} // namespace NEO

2
opencl/source/mem_obj/image.h
View File

@ -197,6 +197,8 @@ class Image : public MemObj {
bool isImageFromBuffer() const { return castToObject<Buffer>(static_cast<cl_mem>(associatedMemObject)) ? true : false; }
bool isImageFromImage() const { return castToObject<Image>(static_cast<cl_mem>(associatedMemObject)) ? true : false; }
static cl_int checkIfDeviceSupportsImages(cl_context context);
protected:
Image(Context *context,
const MemoryProperties &memoryProperties,

146
opencl/test/unit_test/api/cl_create_image_tests.cpp
View File

@ -55,6 +55,7 @@ struct clCreateImageTests : public ApiFixture<>,
typedef clCreateImageTests<::testing::Test> clCreateImageTest;
TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
@ -70,6 +71,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAnd
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingTiledImageThenInvalidOperationErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
@ -99,6 +101,7 @@ HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingTiledI
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingNonTiledImageThenCreate) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
@ -127,7 +130,68 @@ HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingNonTil
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImageWithPropertiesINTELThenImageCreatedAndSuccessIsReturned) {
DebugManagerStateRestore stateRestore;
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
mockClDevice.sharedDeviceInfo.imageSupport = CL_FALSE;
cl_bool imageSupportInfo = CL_TRUE;
auto status = clGetDeviceInfo(&mockClDevice, CL_DEVICE_IMAGE_SUPPORT, sizeof(imageSupportInfo), &imageSupportInfo, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
cl_bool expectedValue = CL_FALSE;
EXPECT_EQ(expectedValue, imageSupportInfo);
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc.image_height = 1;
DebugManager.flags.ForceLinearImages.set(true);
auto image = clCreateImageWithPropertiesINTEL(
&mockContext,
nullptr,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithPropertiesAndWithoutThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage(pContext.get(), CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, image);
auto imageWithProperties = clCreateImageWithProperties(pContext.get(), nullptr, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, imageWithProperties);
}
TEST_F(clCreateImageTest, GivenNullContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
auto image = clCreateImageWithProperties(
nullptr,
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndAlignedRowPitchWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 128;
@ -146,6 +210,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndAlignedRowPitchWhenCreatingImage
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndUnalignedRowPitchWhenCreatingImageThenInvalidImageDescriptotErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 129;
auto image = clCreateImage(
@ -160,6 +225,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndUnalignedRowPitchWhenCreatingIma
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndSmallRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
@ -174,6 +240,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndSmallRowPitchWhenCreatingImageTh
}
TEST_F(clCreateImageTest, GivenUnrestrictedIntelFlagWhenCreatingImageWithInvalidFlagCombinationThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL;
auto image = clCreateImage(
pContext,
@ -191,6 +258,7 @@ TEST_F(clCreateImageTest, GivenUnrestrictedIntelFlagWhenCreatingImageWithInvalid
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndNoHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
auto image = clCreateImage(
pContext,
@ -204,6 +272,7 @@ TEST_F(clCreateImageTest, GivenNotNullHostPtrAndNoHostPtrFlagWhenCreatingImageTh
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = (1 << 12);
auto image = clCreateImage(
pContext,
@ -221,6 +290,7 @@ TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageThenInvalidValueE
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageFromAnotherImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
auto image = clCreateImage(
pContext,
@ -255,6 +325,7 @@ TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageFromAnotherImageT
}
TEST_F(clCreateImageTest, GivenInvalidRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 655;
auto image = clCreateImage(
pContext,
@ -271,6 +342,7 @@ TEST_F(clCreateImageTest, GivenInvalidRowPitchWhenCreatingImageThenInvalidImageD
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndCopyHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
@ -283,6 +355,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrAndCopyHostPtrFlagWhenCreatingImageThe
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndMemUseHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
@ -295,6 +368,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrAndMemUseHostPtrFlagWhenCreatingImageT
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndNonZeroRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
pContext,
@ -322,9 +396,9 @@ TEST_F(clCreateImageTest, GivenDeviceNotSupportingImagesWhenCreatingImageFromBuf
imageDesc.mem_object = buffer;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
auto image = clCreateImage(
auto image = clCreateImageWithPropertiesINTEL(
pContext.get(),
CL_MEM_READ_WRITE,
nullptr,
&imageFormat,
&imageDesc,
nullptr,
@ -367,6 +441,7 @@ TEST_F(clCreateImageTest, GivenNonZeroPitchWhenCreatingImageFromBufferThenImageI
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndRowPitchIsNotGreaterThanWidthTimesElementSizeWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 64;
auto image = clCreateImage(
pContext,
@ -437,6 +512,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenParametersAreCorrec
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectlySet) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
VariableBackup<ImageFunctions::ValidateAndCreateImageFunc> imageCreateBackup{&ImageFunctions::validateAndCreateImage};
cl_mem_properties *properties = nullptr;
@ -466,6 +542,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectl
}
TEST_F(clCreateImageTest, GivenImageCreatedWithNullPropertiesWhenQueryingPropertiesThenNothingIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
auto image = clCreateImageWithProperties(pContext, nullptr, 0, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(retVal, CL_SUCCESS);
@ -480,6 +557,7 @@ TEST_F(clCreateImageTest, GivenImageCreatedWithNullPropertiesWhenQueryingPropert
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrectlyStored) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
cl_mem_properties properties[5];
size_t propertiesSize;
@ -508,6 +586,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrec
typedef clCreateImageTests<::testing::Test> clCreateImageTestYUV;
TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
auto image = clCreateImage(
pContext,
@ -524,6 +603,7 @@ TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValu
}
TEST_F(clCreateImageTestYUV, Given1DImageTypeWhenCreatingYuvImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
auto image = clCreateImage(
@ -562,6 +642,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(validFlags));
TEST_P(clCreateImageValidFlags, GivenValidFlagsWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = GetParam();
std::unique_ptr<char[]> ptr;
char *hostPtr = nullptr;
@ -607,6 +688,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(invalidFlagsCombinations));
TEST_P(clCreateImageInvalidFlags, GivenInvalidFlagsCombinationsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char ptr[10];
imageDesc.image_row_pitch = 128;
@ -763,7 +845,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(invalidFlagsAndParentFlags));
TEST_P(clCreateImageInvalidFlagsAndParentFlagsCombinations, GivenInvalidFlagsAndParentFlagsWhenCreatingImageThenInvalidMemObjectErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
ImageFlags imageFlags = GetParam();
cl_mem_flags parentFlags = imageFlags.parentFlags;
@ -815,7 +897,7 @@ INSTANTIATE_TEST_CASE_P(validImage2DSizes,
::testing::ValuesIn(validImage2DSizes));
TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
ImageSizes sizes = GetParam();
imageDesc.image_width = sizes.width;
imageDesc.image_height = sizes.height;
@ -837,6 +919,7 @@ TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsC
typedef clCreateImageTests<::testing::Test> clCreateImage2DTest;
TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
@ -855,6 +938,7 @@ TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCr
}
TEST_F(clCreateImage2DTest, GivenNoPtrToReturnValueWhenCreating2DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
@ -886,9 +970,30 @@ TEST_F(clCreateImage2DTest, GivenInvalidContextsWhenCreating2DImageThenInvalidCo
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage2DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage2DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage2D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImage3DTest;
TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
@ -909,6 +1014,7 @@ TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCr
}
TEST_F(clCreateImage3DTest, GivenNoPtrToReturnValueWhenCreating3DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
@ -944,6 +1050,28 @@ TEST_F(clCreateImage3DTest, GivenInvalidContextsWhenCreating3DImageThenInvalidCo
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage3DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage3DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage3D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
using clCreateImageWithPropertiesINTELTest = clCreateImageTest;
TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
@ -1166,13 +1294,7 @@ struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
public ::testing::WithParamInterface<uint32_t /*image type*/> {
void SetUp() override {
clCreateImageFromImageTest::SetUp();
image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
image = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageDesc.mem_object = image;
@ -1185,7 +1307,7 @@ struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
};
TEST_P(clCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_type = GetParam();
auto imageFromImageObject = clCreateImage(
pContext,

34
opencl/test/unit_test/api/cl_enqueue_copy_buffer_to_image_tests.inl
View File

@ -7,6 +7,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/buffer_fixture.h"
#include "cl_api_tests.h"
@ -86,13 +87,8 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidSrcBufferWhenCopyingBufferTo
TEST_F(clEnqueueCopyBufferToImageTests, GivenValidParametersWhenCopyingBufferToImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
cl_mem dstImage = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc,
nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
@ -119,13 +115,7 @@ typedef clEnqueueCopyBufferToImageTests clEnqueueCopyBufferToImageYUV;
TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToImageThenSuccessIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {2, 2, 0};
@ -148,13 +138,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToIm
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {1, 2, 0};
@ -177,13 +161,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyin
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidRegionAndValidYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {2, 2, 0};

96
opencl/test/unit_test/api/cl_enqueue_copy_image_tests.inl
View File

@ -99,21 +99,9 @@ TEST_F(clEnqueueCopyImageTests, GivenNullDstBufferWhenCopyingImageThenInvalidMem
TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingImageThenImageFormatMismatchErrorIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
imageFormat.image_channel_order = CL_BGRA;
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@ -139,20 +127,8 @@ TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingIm
TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@ -179,20 +155,8 @@ TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessI
typedef clEnqueueCopyImageTests clEnqueueCopyImageYUVTests;
TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSuccessIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@ -217,20 +181,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSu
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@ -256,20 +208,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenI
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@ -295,20 +235,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenI
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginFor2dImageWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);

32
opencl/test/unit_test/api/cl_enqueue_copy_image_to_buffer_tests.inl
View File

@ -86,13 +86,7 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidBufferWhenCopyingImageToBuff
TEST_F(clEnqueueCopyImageToBufferTests, GivenValidParametersWhenCopyingImageToBufferThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
@ -119,13 +113,7 @@ typedef clEnqueueCopyImageToBufferTests clEnqueueCopyImageToBufferYUVTests;
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvImageToBufferThenSuccessIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {2, 2, 0};
@ -148,13 +136,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvIma
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {1, 2, 0};
@ -177,13 +159,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImage
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidRegionWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {2, 2, 0};

32
opencl/test/unit_test/api/cl_enqueue_map_image_tests.inl
View File

@ -48,13 +48,7 @@ struct clEnqueueMapImageTests : public ApiFixture<>,
};
TEST_F(clEnqueueMapImageTests, GivenValidParametersWhenMappingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@ -112,13 +106,7 @@ struct clEnqueueMapImageYUVTests : public ApiFixture<>,
};
TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@ -143,13 +131,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessI
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@ -174,13 +156,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInval
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidRegionWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

33
opencl/test/unit_test/api/cl_enqueue_read_image_tests.inl
View File

@ -8,6 +8,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/context/context.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@ -83,13 +84,7 @@ TEST_F(clEnqueueReadImageTests, GivenNullImageWhenReadingImageThenInvalidMemObje
TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@ -115,13 +110,7 @@ TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessI
typedef clEnqueueReadImageTests clEnqueueReadImageYuv;
TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@ -145,13 +134,7 @@ TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsRet
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@ -175,13 +158,7 @@ TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidVa
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidRegionWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

33
opencl/test/unit_test/api/cl_enqueue_write_image_tests.inl
View File

@ -8,6 +8,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/context/context.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@ -83,13 +84,7 @@ TEST_F(clEnqueueWriteImageTests, GivenNullImageWhenWritingImageThenInvalidMemObj
TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@ -115,13 +110,7 @@ TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccess
typedef clEnqueueWriteImageTests clEnqueueWriteImageYUV;
TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@ -145,13 +134,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSucces
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@ -174,13 +157,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidV
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidRegionWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

12
opencl/test/unit_test/api/cl_get_image_info_tests.inl
View File

@ -37,8 +37,8 @@ struct clGetImageInfoTests : public ApiFixture<>,
imageDesc.num_samples = 0;
imageDesc.mem_object = nullptr;
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc,
nullptr, &retVal);
image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
}
@ -218,8 +218,7 @@ TEST_F(clGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidth
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
image2 = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat2, &imageDesc2, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
@ -273,8 +272,7 @@ TEST_F(clGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidth
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
image2 = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat2, &imageDesc2, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
@ -372,7 +370,7 @@ TEST_F(clGetImageInfoTests, givenMultisampleCountForMcsWhenAskingForRowPitchThen
size_t receivedRowPitch = 0;
clReleaseMemObject(image);
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto imageObj = castToObject<Image>(image);
auto formatInfo = imageObj->getSurfaceFormatInfo();

7
opencl/test/unit_test/api/cl_set_mem_object_destructor_callback_tests.inl
View File

@ -6,6 +6,7 @@
*/
#include "opencl/source/context/context.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@ -60,8 +61,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenNullMemObjWhenSettingMemObjCa
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhenSettingMemObjCallbackThenSuccessIsReturned) {
auto image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat,
&imageDesc, nullptr, &retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, destructorCallback, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -72,8 +72,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhe
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat,
&imageDesc, nullptr, &retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);

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

@ -780,7 +780,9 @@ HWTEST_F(ImageSetArgTest, GivenImageFrom1dBufferWhenSettingKernelArgThenProperti
cl_image_format imageFormat = {0};
imageFormat.image_channel_data_type = CL_FLOAT;
imageFormat.image_channel_order = CL_RGBA;
auto imageFromBuffer = clCreateImage(context, 0, &imageFormat, &imageDesc, nullptr, nullptr);
cl_int retVal;
auto imageFromBuffer = Image::validateAndCreateImage(context, nullptr, 0, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, imageFromBuffer);
retVal = clSetKernelArg(

3
opencl/test/unit_test/sharings/gl/windows/gl_sharing_tests.cpp
View File

@ -874,6 +874,9 @@ TEST_F(glSharingTests, givenContextWhenCreateFromSharedBufferThenSharedImageIsRe
ASSERT_NE(nullptr, glBuffer);
auto parentbBuffer = castToObject<Buffer>(glBuffer);
auto hardwareInfo = context.getDevice(0)->getRootDeviceEnvironment().getMutableHardwareInfo();
hardwareInfo->capabilityTable.supportsImages = true;
cl_image_format format = {CL_RGBA, CL_FLOAT};
cl_image_desc image_desc = {CL_MEM_OBJECT_IMAGE1D_BUFFER, 1, 1, 1, 1, 0, 0, 0, 0, {glBuffer}};
cl_mem image = clCreateImage(&context, CL_MEM_READ_WRITE, &format, &image_desc, 0, &retVal);

6
opencl/test/unit_test/test_macros/test_checks_ocl.h
View File

@ -33,6 +33,12 @@ bool supportsPipes(const ClDevice *pClDevice);
GTEST_SKIP(); \
}
#define REQUIRE_IMAGE_SUPPORT_OR_SKIP(param) \
auto hwInfo = castToObject<Context>(param)->getDevice(0)->getHardwareInfo(); \
if (!hwInfo.capabilityTable.supportsImages) { \
GTEST_SKIP(); \
}
#define REQUIRE_OCL_21_OR_SKIP(param) \
if (NEO::TestChecks::supportsOcl21(param) == false) { \
GTEST_SKIP(); \