Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
compute-runtime/unit_tests/api/cl_get_image_info_tests.inl

388 lines
14 KiB
C++
Raw Blame History

/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/context/context.h"
#include "runtime/helpers/hw_info.h"
#include "runtime/mem_obj/image.h"
#include "unit_tests/mocks/mock_device.h"
#include "cl_api_tests.h"
using namespace NEO;
namespace ULT {
struct clGetImageInfoTests : public api_fixture,
public ::testing::Test {
void SetUp() override {
api_fixture::SetUp();
imageFormat.image_channel_order = CL_RGBA;
imageFormat.image_channel_data_type = CL_UNORM_INT8;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
imageDesc.image_width = 32;
imageDesc.image_height = 32;
imageDesc.image_depth = 1;
imageDesc.image_array_size = 1;
imageDesc.image_row_pitch = 0;
imageDesc.image_slice_pitch = 0;
imageDesc.num_mip_levels = 0;
imageDesc.num_samples = 0;
imageDesc.mem_object = nullptr;
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc,
nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
}
void TearDown() override {
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
api_fixture::TearDown();
}
cl_image_format imageFormat;
cl_image_desc imageDesc;
cl_mem image;
};
TEST_F(clGetImageInfoTests, GivenBufferWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
size_t paramRetSize = 0;
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 42, nullptr, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(buffer, CL_IMAGE_ELEMENT_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
clReleaseMemObject(buffer);
}
TEST_F(clGetImageInfoTests, GivenNullWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
size_t paramRetSize = 0;
retVal = clGetImageInfo(nullptr, CL_IMAGE_ELEMENT_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clGetImageInfoTests, GivenInvalidParamNameWhenGettingImageInfoThenInvalidValueErrorIsReturned) {
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_MEM_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
ASSERT_EQ(0u, paramRetSize);
}
TEST_F(clGetImageInfoTests, GivenClImageFormatWhenGettingImageInfoThenImageFormatIsReturned) {
cl_image_format imgFmtRet;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_FORMAT, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(cl_image_format), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_FORMAT, paramRetSize, &imgFmtRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageFormat.image_channel_data_type, imgFmtRet.image_channel_data_type);
ASSERT_EQ(this->imageFormat.image_channel_order, imgFmtRet.image_channel_order);
}
TEST_F(clGetImageInfoTests, GivenClImageElementSizeWhenGettingImageInfoThenSizeOfImageElementIsReturned) {
size_t elemSize = 4;
size_t sizeRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, paramRetSize, &sizeRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(elemSize, sizeRet);
}
TEST_F(clGetImageInfoTests, GivenClImageRowPitchWhenGettingImageInfoThenSizeOfRowIsReturned) {
size_t rowPitchRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, paramRetSize, &rowPitchRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(0u, rowPitchRet);
}
TEST_F(clGetImageInfoTests, GivenClImageSlicePitchAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
size_t slicePitchRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, paramRetSize, &slicePitchRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(0u, slicePitchRet);
}
TEST_F(clGetImageInfoTests, GivenClImageWidthWhenGettingImageInfoThenWidthOfImageIsReturned) {
size_t widthRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, paramRetSize, &widthRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageDesc.image_width, widthRet);
}
TEST_F(clGetImageInfoTests, GivenImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
auto initialWidth = this->imageDesc.image_width;
auto initialHeight = this->imageDesc.image_height;
auto pImage = castToObject<Image>(image);
size_t returnValue = 0;
size_t paramRetSize = sizeof(size_t);
for (int mipLevel = 0; mipLevel < 10; mipLevel++) {
pImage->setBaseMipLevel(mipLevel);
auto expectedWidth = initialWidth >> mipLevel;
expectedWidth = expectedWidth == 0 ? 1 : expectedWidth;
auto expectedHeight = initialHeight >> mipLevel;
expectedHeight = expectedHeight == 0 ? 1 : expectedHeight;
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, paramRetSize, &returnValue, NULL);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(expectedWidth, returnValue);
retVal = clGetImageInfo(image, CL_IMAGE_HEIGHT, paramRetSize, &returnValue, NULL);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(expectedHeight, returnValue);
}
}
TEST_F(clGetImageInfoTests, GivenClImageHeightWhenGettingImageInfoThenHeightOfImageIsReturned) {
size_t heightRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_HEIGHT, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_HEIGHT, paramRetSize, &heightRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageDesc.image_height, heightRet);
}
TEST_F(clGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
size_t widthRet;
size_t expectedWidth;
size_t heightRet;
size_t expectedHeight;
size_t depthRet;
size_t expectedDepth;
cl_image_format imageFormat2;
cl_image_desc imageDesc2;
cl_mem image2;
imageFormat2.image_channel_order = CL_RGBA;
imageFormat2.image_channel_data_type = CL_UNORM_INT8;
imageDesc2.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc2.image_width = 8;
imageDesc2.image_height = 8;
imageDesc2.image_depth = 4;
imageDesc2.image_array_size = 1;
imageDesc2.image_row_pitch = 0;
imageDesc2.image_slice_pitch = 0;
imageDesc2.num_mip_levels = 5;
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
auto pImgObj = castToObject<Image>(image2);
for (cl_uint n = 0; n <= imageDesc2.num_mip_levels; n++) {
pImgObj->setBaseMipLevel(n);
retVal = clGetImageInfo(image2, CL_IMAGE_WIDTH, sizeof(widthRet), &widthRet, NULL);
EXPECT_EQ(CL_SUCCESS, retVal);
expectedWidth = imageDesc2.image_width >> n;
expectedWidth = (expectedWidth == 0) ? 1 : expectedWidth;
ASSERT_EQ(expectedWidth, widthRet);
retVal = clGetImageInfo(image2, CL_IMAGE_HEIGHT, sizeof(heightRet), &heightRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
expectedHeight = imageDesc2.image_height >> n;
expectedHeight = (expectedHeight == 0) ? 1 : expectedHeight;
ASSERT_EQ(expectedHeight, heightRet);
retVal = clGetImageInfo(image2, CL_IMAGE_DEPTH, sizeof(depthRet), &depthRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
expectedDepth = imageDesc2.image_depth >> n;
expectedDepth = (expectedDepth == 0) ? 1 : expectedDepth;
ASSERT_EQ(expectedDepth, depthRet);
}
retVal = clReleaseMemObject(image2);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
size_t widthRet;
size_t expectedWidth;
size_t heightRet;
size_t depthRet;
cl_image_format imageFormat2;
cl_image_desc imageDesc2;
cl_mem image2;
imageFormat2.image_channel_order = CL_RGBA;
imageFormat2.image_channel_data_type = CL_UNORM_INT8;
imageDesc2.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc2.image_width = 8;
imageDesc2.image_height = 1;
imageDesc2.image_depth = 1;
imageDesc2.image_array_size = 1;
imageDesc2.image_row_pitch = 0;
imageDesc2.image_slice_pitch = 0;
imageDesc2.num_mip_levels = 5;
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
auto pImgObj = castToObject<Image>(image2);
for (cl_uint n = 0; n <= imageDesc2.num_mip_levels; n++) {
pImgObj->setBaseMipLevel(n);
retVal = clGetImageInfo(image2, CL_IMAGE_WIDTH, sizeof(widthRet), &widthRet, NULL);
EXPECT_EQ(CL_SUCCESS, retVal);
expectedWidth = imageDesc2.image_width >> n;
expectedWidth = (expectedWidth == 0) ? 1 : expectedWidth;
ASSERT_EQ(expectedWidth, widthRet);
retVal = clGetImageInfo(image2, CL_IMAGE_HEIGHT, sizeof(heightRet), &heightRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(0u, heightRet);
retVal = clGetImageInfo(image2, CL_IMAGE_DEPTH, sizeof(depthRet), &depthRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(0u, depthRet);
}
retVal = clReleaseMemObject(image2);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetImageInfoTests, GivenClImageDepthAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
size_t depthRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, paramRetSize, &depthRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(0U, depthRet);
}
TEST_F(clGetImageInfoTests, GivenClImageArraySizeAndNonArrayImageWhenGettingImageInfoThenZeroIsReturned) {
size_t arraySizeRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(size_t), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, paramRetSize, &arraySizeRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(0u, arraySizeRet);
}
TEST_F(clGetImageInfoTests, GivenClImageBufferWhenGettingImageInfoThenBufferIsReturned) {
cl_mem bufferRet = nullptr;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_BUFFER, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(cl_mem), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_BUFFER, paramRetSize, &bufferRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageDesc.buffer, bufferRet);
}
TEST_F(clGetImageInfoTests, GivenClImageNumMipLevelsWhenGettingImageInfoThenCorrectMipMapLevelIsReturned) {
cl_uint numMipLevelRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(cl_uint), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, paramRetSize, &numMipLevelRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageDesc.num_mip_levels, numMipLevelRet);
}
TEST_F(clGetImageInfoTests, GivenClImageNumSamplesWhenGettingImageInfoThenCorrectNumberOfSamplesIsReturned) {
cl_uint numSamplesRet = 0;
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(sizeof(cl_uint), paramRetSize);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, paramRetSize, &numSamplesRet, NULL);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_EQ(this->imageDesc.num_samples, numSamplesRet);
}
TEST_F(clGetImageInfoTests, givenMultisampleCountForMcsWhenAskingForRowPitchThenReturnNewValueIfGreaterThanOne) {
McsSurfaceInfo mcsInfo = {1, 1, 0};
imageDesc.num_samples = 16;
size_t receivedRowPitch = 0;
clReleaseMemObject(image);
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
auto imageObj = castToObject<Image>(image);
auto formatInfo = imageObj->getSurfaceFormatInfo();
size_t multisampleRowPitch = imageDesc.image_width * formatInfo.ImageElementSizeInBytes * imageDesc.num_samples;
EXPECT_NE(multisampleRowPitch, imageObj->getHostPtrRowPitch());
for (uint32_t multisampleCount = 0; multisampleCount <= 4; multisampleCount++) {
mcsInfo.multisampleCount = multisampleCount;
imageObj->setMcsSurfaceInfo(mcsInfo);
clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(size_t), &receivedRowPitch, nullptr);
if (multisampleCount > 1) {
EXPECT_EQ(multisampleRowPitch, receivedRowPitch);
} else {
EXPECT_EQ(imageObj->getHostPtrRowPitch(), receivedRowPitch);
}
}
}
} // namespace ULT
Reference in New Issue View Git Blame Copy Permalink