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

Check if origin + region doesn't exceed image dimensions 

Signed-off-by: Rafal Maziejuk <rafal.maziejuk@intel.com>
Related-To: NEO-6137
This commit is contained in:
Rafal Maziejuk 2022-01-21 11:22:24 +00:00 committed by Compute-Runtime-Automation
parent 43e147d84f
commit f064f7dd67
8 changed files with 76 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
opencl/source/command_queue/command_queue.cpp
View File

@ -828,7 +828,6 @@ bool CommandQueue::blitEnqueueImageAllowed(const size_t *origin, const size_t *r
blitEnqueueImageAllowed = DebugManager.flags.EnableBlitterForEnqueueImageOperations.get();
}
blitEnqueueImageAllowed &= (origin[0] + region[0] <= BlitterConstants::maxBlitWidth) && (origin[1] + region[1] <= BlitterConstants::maxBlitHeight);
blitEnqueueImageAllowed &= !isMipMapped(image.getImageDesc());
const auto &defaultGmm = image.getGraphicsAllocation(device->getRootDeviceIndex())->getDefaultGmm();

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

@ -1433,6 +1433,23 @@ cl_int Image::validateRegionAndOrigin(const size_t *origin, const size_t *region
return CL_INVALID_VALUE;
}
if (origin[0] + region[0] > imgDesc.image_width) {
return CL_INVALID_VALUE;
}
if (imgDesc.image_type == CL_MEM_OBJECT_IMAGE2D || imgDesc.image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY ||
imgDesc.image_type == CL_MEM_OBJECT_IMAGE3D) {
if (origin[1] + region[1] > imgDesc.image_height) {
return CL_INVALID_VALUE;
}
}
if (imgDesc.image_type == CL_MEM_OBJECT_IMAGE3D) {
if (origin[2] + region[2] > imgDesc.image_depth) {
return CL_INVALID_VALUE;
}
}
bool notMipMapped = (false == isMipMapped(imgDesc));
if ((imgDesc.image_type == CL_MEM_OBJECT_IMAGE1D || imgDesc.image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) &&

24
opencl/test/unit_test/api/cl_enqueue_image_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -93,6 +93,26 @@ TEST_P(ValidateRegionAndOriginTests, givenAnyZeroRegionParamWhenEnqueueCalledThe
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ValidateRegionAndOriginTests, givenMaxImage2DFirstAndSecondRegionCoordinateAndAnyNonZeroFirstOrSecondOriginCoordinateWhenEnqueueCalledThenReturnError) {
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(context.get()));
EXPECT_NE(nullptr, image.get());
const auto &deviceInfo = context->getDevice(0)->getDevice().getDeviceInfo();
size_t region[3] = {deviceInfo.image2DMaxWidth, deviceInfo.image2DMaxHeight, 1};
std::array<size_t, 3> origin = {{0, 1, 0}};
GetParam()(cmdQ.get(), image.get(), &origin[0], region, retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
origin = {{1, 0, 0}};
GetParam()(cmdQ.get(), image.get(), &origin[0], region, retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
origin = {{1, 1, 0}};
GetParam()(cmdQ.get(), image.get(), &origin[0], region, retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ValidateRegionAndOriginTests, givenSecondOriginCoordinateAndNotAllowedImgTypeWhenEnqueueCalledThenReturnError) {
size_t region[3] = {1, 1, 1};
size_t origin[3] = {0, 1, 0};
@ -146,7 +166,7 @@ TEST_P(ValidateRegionAndOriginTests, givenSecondRegionCoordinateAndNotAllowedImg
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_P(ValidateRegionAndOriginTests, givenThirdRegionnCoordinateAndNotAllowedImgTypeWhenEnqueueCalledThenReturnError) {
TEST_P(ValidateRegionAndOriginTests, givenThirdRegionCoordinateAndNotAllowedImgTypeWhenEnqueueCalledThenReturnError) {
size_t region[3] = {1, 1, 2};
size_t origin[3] = {0, 0, 0};

38
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -1349,6 +1349,15 @@ TEST(CommandQueue, givenImageTransferClCommandWhenCallingBlitEnqueueAllowedThenR
CsrSelectionArgs args{CL_COMMAND_COPY_IMAGE, &image, &image, 0u, region, origin, origin};
EXPECT_TRUE(queue.blitEnqueueAllowed(args));
}
{
MockImageBase dstImage{};
dstImage.imageDesc.num_mip_levels = 2;
auto dstAlloc = static_cast<MockGraphicsAllocation *>(dstImage.getGraphicsAllocation(0));
dstAlloc->memoryPool = MemoryPool::System4KBPages;
CsrSelectionArgs args{CL_COMMAND_COPY_IMAGE, &image, &dstImage, 0u, region, origin, origin};
EXPECT_FALSE(queue.blitEnqueueAllowed(args));
}
}
TEST(CommandQueue, givenImageToBufferClCommandWhenCallingBlitEnqueueAllowedThenReturnCorrectValue) {
@ -1645,33 +1654,6 @@ TEST_F(CsrSelectionCommandQueueWithQueueFamiliesBlitterTests, givenBlitterSelect
}
}
TEST(CommandQueue, givenCopySizeAndOffsetWhenCallingBlitEnqueueImageAllowedThenReturnCorrectValue) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);
MockContext context{};
MockCommandQueue queue(&context, context.getDevice(0), 0, false);
MockImageBase image;
image.imageDesc.num_mip_levels = 1;
auto maxBlitWidth = static_cast<size_t>(BlitterConstants::maxBlitWidth);
auto maxBlitHeight = static_cast<size_t>(BlitterConstants::maxBlitHeight);
std::tuple<size_t, size_t, size_t, size_t, bool> testParams[]{
{1, 1, 0, 0, true},
{maxBlitWidth, maxBlitHeight, 0, 0, true},
{maxBlitWidth + 1, maxBlitHeight, 0, 0, false},
{maxBlitWidth, maxBlitHeight + 1, 0, 0, false},
{maxBlitWidth, maxBlitHeight, 1, 0, false},
{maxBlitWidth, maxBlitHeight, 0, 1, false},
{maxBlitWidth - 1, maxBlitHeight - 1, 1, 1, true}};
for (auto &[regionX, regionY, originX, originY, expectedResult] : testParams) {
size_t region[3] = {regionX, regionY, 0};
size_t origin[3] = {originX, originY, 0};
EXPECT_EQ(expectedResult, queue.blitEnqueueImageAllowed(origin, region, image));
}
}
TEST(CommandQueue, givenMipMappedImageWhenCallingBlitEnqueueImageAllowedThenCorrectResultIsReturned) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);

56
opencl/test/unit_test/command_queue/enqueue_copy_image_tests.cpp
View File

@ -210,62 +210,6 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenNumberOfPipelineSelectsIsOne)
EXPECT_EQ(1, numCommands);
}
HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
DebugManagerStateRestore restorer;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(1);
DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);
auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
hwInfo->capabilityTable.blitterOperationsSupported = true;
REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
size_t srcOrigin[] = {0, 0, 0};
size_t dstOrigin[] = {0, 0, 0};
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(context));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(context));
{
size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
size_t dstOrigin[] = {10, 10, 10};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
auto supportExpected = hwInfoConfig->isBlitterForImagesSupported();
EXPECT_EQ(supportExpected, mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(0);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueOperations.set(0);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
}
HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenCopyingImageThenMediaVfeStateIsSetCorrectly) {
enqueueCopyImage<FamilyType>();
validateMediaVFEState<FamilyType>(&pDevice->getHardwareInfo(), cmdMediaVfeState, cmdList, itorMediaVfeState);

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

@ -866,43 +866,6 @@ struct EnqueueReadImageTestWithBcs : EnqueueReadImageTest {
}
};
HWTEST_F(EnqueueReadImageTestWithBcs, givenDeviceWithBlitterSupportWhenEnqueueReadImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);
auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
hwInfo->capabilityTable.blitterOperationsSupported = true;
REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
size_t origin[] = {0, 0, 0};
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> image(Image2dHelper<>::create(context));
{
size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
auto supportExpected = hwInfoConfig->isBlitterForImagesSupported();
EXPECT_EQ(supportExpected, mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(0);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
}
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));

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

@ -209,44 +209,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, WhenWritingImageThenMediaVfeS
validateMediaVFEState<FamilyType>(&pDevice->getHardwareInfo(), cmdMediaVfeState, cmdList, itorMediaVfeState);
}
HWTEST_F(EnqueueWriteImageTest, givenDeviceWithBlitterSupportWhenEnqueueWriteImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
DebugManagerStateRestore restorer;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(1);
DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);
auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
hwInfo->capabilityTable.blitterOperationsSupported = true;
REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
size_t origin[] = {0, 0, 0};
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> image(Image2dHelper<>::create(context));
{
size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
auto supportExpected = hwInfoConfig->isBlitterForImagesSupported();
EXPECT_EQ(supportExpected, mockCmdQ->isBlitEnqueueImageAllowed);
}
{
DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(0);
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
}
HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenReadWriteImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
auto &imageDesc = dstImage2->getImageDesc();

27
opencl/test/unit_test/mem_obj/image_tests.cpp
View File

@ -1577,6 +1577,30 @@ TEST(ImageConvertDescriptorTest, givenImageDescriptorWhenConvertedThenCorrectClI
EXPECT_EQ(nullptr, clDesc.mem_object);
}
TEST(ImageTest, givenImageWhenValidateRegionAndOriginIsCalledThenAdditionalOriginAndRegionCoordinatesAreAnalyzed) {
size_t origin[3]{};
size_t region[3]{1, 1, 1};
for (uint32_t imageType : {CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D}) {
cl_image_desc desc = {};
desc.image_type = imageType;
EXPECT_EQ(CL_INVALID_VALUE, Image::validateRegionAndOrigin(origin, region, desc));
desc.image_width = 1;
EXPECT_EQ(CL_INVALID_VALUE, Image::validateRegionAndOrigin(origin, region, desc));
desc.image_height = 1;
desc.image_depth = 1;
EXPECT_EQ(CL_SUCCESS, Image::validateRegionAndOrigin(origin, region, desc));
if (imageType == CL_MEM_OBJECT_IMAGE3D) {
desc.image_depth = 0;
EXPECT_EQ(CL_INVALID_VALUE, Image::validateRegionAndOrigin(origin, region, desc));
}
}
}
typedef ::testing::TestWithParam<uint32_t> MipLevelCoordinateTest;
TEST_P(MipLevelCoordinateTest, givenMipmappedImageWhenValidateRegionAndOriginIsCalledThenAdditionalOriginCoordinateIsAnalyzed) {
@ -1585,6 +1609,9 @@ TEST_P(MipLevelCoordinateTest, givenMipmappedImageWhenValidateRegionAndOriginIsC
cl_image_desc desc = {};
desc.image_type = GetParam();
desc.num_mip_levels = 2;
desc.image_width = 1;
desc.image_height = 1;
desc.image_depth = 1;
origin[getMipLevelOriginIdx(desc.image_type)] = 1;
EXPECT_EQ(CL_SUCCESS, Image::validateRegionAndOrigin(origin, region, desc));
origin[getMipLevelOriginIdx(desc.image_type)] = 2;