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

test: ImageHelper rename to ImageHelperUlt

Browse Source 
Related-to: NEO-13669

Signed-off-by: Damian Tomczak <damian.tomczak@intel.com>
This commit is contained in:
Damian Tomczak
2025-06-02 17:25:07 +00:00
committed by Compute-Runtime-Automation
parent d9ec4b1a18
commit a7c9bfafb3
58 changed files with 348 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -56,7 +56,7 @@ class MediaImageSetArgTest : public ClDeviceFixture,
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
srcImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
ASSERT_NE(nullptr, srcImage);
}

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -1367,7 +1367,7 @@ using clCreateImageWithMultiDeviceContextTests = MultiRootDeviceFixture;
TEST_F(clCreateImageWithMultiDeviceContextTests, GivenImageCreatedWithoutHostPtrAndWithContextdWithMultiDeviceThenGraphicsAllocationsAreProperlyCreatedAndMapPtrIsNotSet) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(image->getMultiGraphicsAllocation().getGraphicsAllocations().size(), 3u);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), nullptr);
@@ -1382,7 +1382,7 @@ TEST_F(clCreateImageWithMultiDeviceContextTests, GivenImageCreatedWithHostPtrAnd
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
DebugManagerStateRestore dbgRestore;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context.get()));
EXPECT_EQ(image->getMultiGraphicsAllocation().getGraphicsAllocations().size(), 3u);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), nullptr);
@@ -1401,7 +1401,7 @@ TEST_F(clCreateImageWithMultiDeviceContextTests, GivenContextdWithMultiDeviceFai
static_cast<MockMemoryManager *>(context->getMemoryManager())->successAllocatedGraphicsMemoryIndex = 0u;
static_cast<MockMemoryManager *>(context->getMemoryManager())->maxSuccessAllocatedGraphicsMemoryIndex = 0u;
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(nullptr, image);
}
@@ -1410,7 +1410,7 @@ TEST_F(clCreateImageWithMultiDeviceContextTests, GivenContextdWithMultiDeviceFai
static_cast<MockMemoryManager *>(context->getMemoryManager())->successAllocatedGraphicsMemoryIndex = 0u;
static_cast<MockMemoryManager *>(context->getMemoryManager())->maxSuccessAllocatedGraphicsMemoryIndex = 1u;
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(nullptr, image);
}

10
opencl/test/unit_test/api/cl_enqueue_fill_image_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,7 +19,7 @@ using ClEnqueueFillImageTests = ApiTests;
namespace ULT {
TEST_F(ClEnqueueFillImageTests, GivenNullCommandQueueWhenFillingImageThenInvalidCommandQueueErrorIsReturned) {
auto image = std::unique_ptr<Image>(Image2dHelper<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
uint32_t fillColor[4] = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd};
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 1};
@@ -56,7 +56,7 @@ TEST_F(ClEnqueueFillImageTests, GivenNullImageWhenFillingImageThenInvalidMemObje
}
TEST_F(ClEnqueueFillImageTests, GivenNullFillColorWhenFillingImageThenInvalidValueErrorIsReturned) {
auto image = std::unique_ptr<Image>(Image2dHelper<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 1};
@@ -74,7 +74,7 @@ TEST_F(ClEnqueueFillImageTests, GivenNullFillColorWhenFillingImageThenInvalidVal
}
TEST_F(ClEnqueueFillImageTests, GivenCorrectArgumentsWhenFillingImageThenSuccessIsReturned) {
auto image = std::unique_ptr<Image>(Image2dHelper<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
uint32_t fillColor[4] = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd};
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 1};
@@ -93,7 +93,7 @@ TEST_F(ClEnqueueFillImageTests, GivenCorrectArgumentsWhenFillingImageThenSuccess
}
TEST_F(ClEnqueueFillImageTests, GivenQueueIncapableWhenFillingImageThenInvalidOperationReturned) {
auto image = std::unique_ptr<Image>(Image2dHelper<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(pContext));
uint32_t fillColor[4] = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd};
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 1};

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -40,13 +40,13 @@ struct ValidateRegionAndOriginTests : public ::testing::TestWithParam<ImageEnque
}
static void copyImageWithCorrectSrc(MockCommandQueue *cmdQ, Image *dstImage, size_t *dstOrigin, size_t *region, int32_t &retVal) {
std::unique_ptr<Image> srcImage(ImageHelper<Image3dDefaults>::create(&cmdQ->getContext()));
std::unique_ptr<Image> srcImage(ImageHelperUlt<Image3dDefaults>::create(&cmdQ->getContext()));
size_t srcOrigin[3] = {0, 0, 0};
retVal = clEnqueueCopyImage(cmdQ, srcImage.get(), dstImage, srcOrigin, dstOrigin, region, 0, nullptr, nullptr);
}
static void copyImageWithCorrectDst(MockCommandQueue *cmdQ, Image *srcImage, size_t *srcOrigin, size_t *region, int32_t &retVal) {
std::unique_ptr<Image> dstImage(ImageHelper<Image3dDefaults>::create(&cmdQ->getContext()));
std::unique_ptr<Image> dstImage(ImageHelperUlt<Image3dDefaults>::create(&cmdQ->getContext()));
size_t dstOrigin[3] = {0, 0, 0};
retVal = clEnqueueCopyImage(cmdQ, srcImage, dstImage.get(), srcOrigin, dstOrigin, region, 0, nullptr, nullptr);
}
@@ -71,7 +71,7 @@ struct ValidateRegionAndOriginTests : public ::testing::TestWithParam<ImageEnque
};
TEST_P(ValidateRegionAndOriginTests, givenAnyZeroRegionParamWhenEnqueueCalledThenReturnError) {
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(context.get()));
EXPECT_NE(nullptr, image.get());
size_t origin[3] = {0, 0, 0};
@@ -94,7 +94,7 @@ TEST_P(ValidateRegionAndOriginTests, givenAnyZeroRegionParamWhenEnqueueCalledThe
}
TEST_P(ValidateRegionAndOriginTests, givenMaxImage2DFirstAndSecondRegionCoordinateAndAnyNonZeroFirstOrSecondOriginCoordinateWhenEnqueueCalledThenReturnError) {
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dDefaults>::create(context.get()));
EXPECT_NE(nullptr, image.get());
const auto &deviceInfo = context->getDevice(0)->getDevice().getDeviceInfo();
@@ -117,13 +117,13 @@ TEST_P(ValidateRegionAndOriginTests, givenSecondOriginCoordinateAndNotAllowedImg
size_t region[3] = {1, 1, 1};
size_t origin[3] = {0, 1, 0};
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
auto image1dBufferDesc = Image1dDefaults::imageDesc;
image1dBufferDesc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
image.reset(ImageHelper<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
image.reset(ImageHelperUlt<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
@@ -132,21 +132,21 @@ TEST_P(ValidateRegionAndOriginTests, givenThirdOriginCoordinateAndNotAllowedImgT
size_t region[3] = {1, 1, 1};
size_t origin[3] = {0, 0, 1};
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
image.reset(ImageHelper<Image2dDefaults>::create(context.get()));
image.reset(ImageHelperUlt<Image2dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
image.reset(ImageHelper<Image1dArrayDefaults>::create(context.get()));
image.reset(ImageHelperUlt<Image1dArrayDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
auto image1dBufferDesc = Image1dDefaults::imageDesc;
image1dBufferDesc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
image.reset(ImageHelper<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
image.reset(ImageHelperUlt<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
@@ -155,13 +155,13 @@ TEST_P(ValidateRegionAndOriginTests, givenSecondRegionCoordinateAndNotAllowedImg
size_t region[3] = {1, 2, 1};
size_t origin[3] = {0, 0, 0};
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
auto image1dBufferDesc = Image1dDefaults::imageDesc;
image1dBufferDesc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
image.reset(ImageHelper<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
image.reset(ImageHelperUlt<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
@@ -170,21 +170,21 @@ TEST_P(ValidateRegionAndOriginTests, givenThirdRegionCoordinateAndNotAllowedImgT
size_t region[3] = {1, 1, 2};
size_t origin[3] = {0, 0, 0};
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context.get()));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
image.reset(ImageHelper<Image2dDefaults>::create(context.get()));
image.reset(ImageHelperUlt<Image2dDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
image.reset(ImageHelper<Image1dArrayDefaults>::create(context.get()));
image.reset(ImageHelperUlt<Image1dArrayDefaults>::create(context.get()));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
auto image1dBufferDesc = Image1dDefaults::imageDesc;
image1dBufferDesc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
image.reset(ImageHelper<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
image.reset(ImageHelperUlt<Image1dDefaults>::create(context.get(), &image1dBufferDesc));
GetParam()(cmdQ.get(), image.get(), origin, &region[0], retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}

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

@@ -169,17 +169,17 @@ struct ClEnqueueUnmapImageTests : ClEnqueueUnmapMemObjTests,
Image *createImage(cl_mem_object_type type) {
switch (type) {
case CL_MEM_OBJECT_IMAGE1D:
return Image1dHelper<>::create(pContext);
return Image1dHelperUlt<>::create(pContext);
case CL_MEM_OBJECT_IMAGE1D_BUFFER:
return Image1dBufferHelper<>::create(pContext);
return Image1dBufferHelperUlt<>::create(pContext);
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
return Image1dArrayHelper<>::create(pContext);
return Image1dArrayHelperUlt<>::create(pContext);
case CL_MEM_OBJECT_IMAGE2D:
return Image2dHelper<>::create(pContext);
return Image2dHelperUlt<>::create(pContext);
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
return Image2dArrayHelper<>::create(pContext);
return Image2dArrayHelperUlt<>::create(pContext);
case CL_MEM_OBJECT_IMAGE3D:
return Image3dHelper<>::create(pContext);
return Image3dHelperUlt<>::create(pContext);
default:
return nullptr;
}

14
opencl/test/unit_test/aub_mem_dump/cl_aub_alloc_dump_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -56,7 +56,7 @@ HWTEST_F(AubAllocDumpTests, givenWritableBufferWhenDumpAllocationIsCalledAndAubD
HWTEST_F(AubAllocDumpTests, givenWritableImageWhenDumpAllocationIsCalledAndAubDumpImageFormatIsNotSetThenImageShouldNotBeDumped) {
MockContext context;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
@@ -147,7 +147,7 @@ HWTEST_F(AubAllocDumpTests, givenWritableImageWhenDumpAllocationIsCalledAndAubDu
debugManager.flags.AUBDumpImageFormat.set("BMP");
MockContext context(pClDevice);
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
@@ -190,7 +190,7 @@ HWTEST_F(AubAllocDumpTests, givenWritableImageWhenDumpAllocationIsCalledAndAubDu
debugManager.flags.AUBDumpImageFormat.set("TRE");
MockContext context(pClDevice);
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
@@ -230,7 +230,7 @@ HWTEST_F(AubAllocDumpTests, givenCompressedImageWritableWhenDumpAllocationIsCall
debugManager.flags.AUBDumpImageFormat.set("TRE");
MockContext context(pClDevice);
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
@@ -249,7 +249,7 @@ HWTEST_F(AubAllocDumpTests, givenMultisampleImageWritableWhenDumpAllocationIsCal
debugManager.flags.AUBDumpImageFormat.set("TRE");
MockContext context(pClDevice);
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
@@ -266,7 +266,7 @@ HWTEST_F(AubAllocDumpTests, givenMultisampleImageWritableWhenDumpAllocationIsCal
HWTEST_F(AubAllocDumpTests, givenMultisampleImageWritableWheGetDumpSurfaceIsCalledAndDumpFormatIsSpecifiedThenNullSurfaceInfoIsReturned) {
MockContext context(pClDevice);
std::unique_ptr<Image> image(ImageHelper<Image2dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dDefaults>::create(&context));
ASSERT_NE(nullptr, image);
auto gfxAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());

26
opencl/test/unit_test/built_ins/built_in_tests.cpp
View File

@@ -1097,7 +1097,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToImageStateles
MockBuffer srcBuffer;
srcBuffer.size = static_cast<size_t>(bigSize);
std ::unique_ptr<Image> pDstImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> pDstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, pDstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyBufferToImage3dStateless, *pClDevice);
@@ -1129,7 +1129,7 @@ HWTEST_F(BuiltInTests, givenHeaplessWhenBuilderCopyBufferToImageHeaplessIsUsedTh
GTEST_SKIP();
}
MockBuffer buffer;
std ::unique_ptr<Image> image(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyBufferToImage3dHeapless, *pClDevice);
@@ -1156,7 +1156,7 @@ HWTEST_F(BuiltInTests, givenHeaplessWhenBuilderCopyImageToBufferHeaplessIsUsedTh
GTEST_SKIP();
}
MockBuffer buffer;
std ::unique_ptr<Image> image(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImage3dToBufferHeapless, *pClDevice);
@@ -1182,8 +1182,8 @@ HWTEST_F(BuiltInTests, givenHeaplessWhenBuilderCopyImageToImageHeaplessIsUsedThe
if (!heaplessAllowed) {
GTEST_SKIP();
}
std ::unique_ptr<Image> srcImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(pContext));
std ::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, srcImage.get());
ASSERT_NE(nullptr, dstImage.get());
@@ -1208,8 +1208,8 @@ HWTEST_F(BuiltInTests, WhenBuilderCopyImageToImageIsUsedThenParamsAreCorrect) {
USE_REAL_FILE_SYSTEM();
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
std ::unique_ptr<Image> srcImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(pContext));
std ::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, srcImage.get());
ASSERT_NE(nullptr, dstImage.get());
@@ -1238,7 +1238,7 @@ HWTEST_F(BuiltInTests, givenHeaplessWhenBuilderFillImageHeaplessIsUsedThenParams
GTEST_SKIP();
}
MockBuffer fillColor;
std ::unique_ptr<Image> image(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::fillImage3dHeapless, *pClDevice);
@@ -1260,7 +1260,7 @@ HWTEST_F(BuiltInTests, WhenBuilderFillImageIsUsedThenParamsAreCorrect) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
USE_REAL_FILE_SYSTEM();
MockBuffer fillColor;
std ::unique_ptr<Image> image(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::fillImage3d, *pClDevice);
@@ -1286,7 +1286,7 @@ HWTEST_F(BuiltInTests, givenHeaplessWhenBuilderFillImage1dBufferHeaplessIsUsedTh
GTEST_SKIP();
}
MockBuffer fillColor;
std ::unique_ptr<Image> image(Image1dBufferHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image1dBufferHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::fillImage1dBufferHeapless, *pClDevice);
@@ -1308,7 +1308,7 @@ HWTEST_F(BuiltInTests, WhenBuilderFillImage1dBufferIsUsedThenParamsAreCorrect) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
USE_REAL_FILE_SYSTEM();
MockBuffer fillColor;
std ::unique_ptr<Image> image(Image1dBufferHelper<>::create(pContext));
std ::unique_ptr<Image> image(Image1dBufferHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::fillImage1dBuffer, *pClDevice);
@@ -1337,7 +1337,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToSystemBufferSt
MockBuffer dstBuffer;
dstBuffer.size = static_cast<size_t>(bigSize);
dstBuffer.mockGfxAllocation.setAllocationType(AllocationType::bufferHostMemory);
std ::unique_ptr<Image> pSrcImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> pSrcImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, pSrcImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImage3dToBufferStateless, *pClDevice);
@@ -1375,7 +1375,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToLocalBufferSta
MockBuffer dstBuffer;
dstBuffer.size = static_cast<size_t>(bigSize);
dstBuffer.mockGfxAllocation.setAllocationType(AllocationType::buffer);
std ::unique_ptr<Image> pSrcImage(Image2dHelper<>::create(pContext));
std ::unique_ptr<Image> pSrcImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, pSrcImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImage3dToBufferStateless, *pClDevice);

2
opencl/test/unit_test/command_queue/command_enqueue_fixture.h
View File

@@ -100,7 +100,7 @@ struct NegativeFailAllocationCommandEnqueueBaseFixture : public CommandEnqueueBa
BufferDefaults::context = context;
Image2dDefaults::context = context;
buffer.reset(BufferHelper<>::create());
image.reset(ImageHelper<Image2dDefaults>::create());
image.reset(ImageHelperUlt<Image2dDefaults>::create());
ptr = static_cast<void *>(array);
oldMemManager = pDevice->getExecutionEnvironment()->memoryManager.release();
pDevice->injectMemoryManager(failMemManager.release());

2
opencl/test/unit_test/command_queue/command_queue_hw_1_tests.cpp
View File

@@ -1480,7 +1480,7 @@ HWTEST_F(CommandQueueHwTest, givenDirectSubmissionAndSharedDisplayableImageWhenR
auto directSubmission = new MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>(ultCsr);
ultCsr.directSubmission.reset(directSubmission);
auto image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context));
image->setSharingHandler(mockSharingHandler);
image->getGraphicsAllocation(0u)->setAllocationType(AllocationType::sharedImage);

6
opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp
View File

@@ -231,7 +231,7 @@ HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltin
reinterpret_cast<MockCommandQueueHw<FamilyType> *>(pCmdQ)->heaplessModeEnabled = useHeapless;
setUpImpl(EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyBufferToImage3d>(false, useHeapless));
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
std::unique_ptr<Image> dstImage(ImageHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
@@ -274,7 +274,7 @@ HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadImageCallWhenBuiltinP
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
setUpImpl(EBuiltInOps::adjustBuiltinType<EBuiltInOps::copyImage3dToBuffer>(false, pCmdQ->getHeaplessModeEnabled()));
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
std::unique_ptr<Image> dstImage(ImageHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
@@ -1606,7 +1606,7 @@ HWTEST_F(IoqCommandQueueHwBlitTest, givenImageWithHostPtrWhenCreateImageThenStop
directSubmission->initialize(true);
EXPECT_TRUE(directSubmission->ringStart);
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(context));
EXPECT_FALSE(directSubmission->ringStart);
}

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

@@ -1348,7 +1348,7 @@ HWTEST_F(CommandQueueTests, givenEnqueuesForSharedObjectsWithImageWhenUsingShari
MockCommandQueue cmdQ(&context, context.getDevice(0), 0, false);
MockSharingHandler *mockSharingHandler = new MockSharingHandler;
auto image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(&context));
image->setSharingHandler(mockSharingHandler);
image->getGraphicsAllocation(0u)->setAllocationType(AllocationType::sharedImage);
@@ -1372,7 +1372,7 @@ HWTEST_F(CommandQueueTests, givenDirectSubmissionAndSharedImageWhenReleasingShar
MockCommandQueue cmdQ(&context, context.getDevice(0), 0, false);
MockSharingHandler *mockSharingHandler = new MockSharingHandler;
auto image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(&context));
image->setSharingHandler(mockSharingHandler);
image->getGraphicsAllocation(0u)->setAllocationType(AllocationType::sharedImage);
@@ -1400,7 +1400,7 @@ TEST(CommandQueue, givenEnqueuesForSharedObjectsWithImageWhenUsingSharingHandler
MockCommandQueue cmdQ(&context, mockDevice.get(), 0, false);
MockSharingHandler *mockSharingHandler = new MockSharingHandler;
auto image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(&context));
image->setSharingHandler(mockSharingHandler);
cl_mem memObject = image.get();
@@ -2216,11 +2216,11 @@ TEST(CommandQueue, given64KBTileWith3DImageTypeWhenCallingBlitEnqueueImageAllowe
size_t correctRegion[3] = {10u, 10u, 0};
size_t correctOrigin[3] = {1u, 1u, 0};
std::array<std::unique_ptr<Image>, 5> images = {
std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(&context))};
std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(&context)),
std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(&context))};
for (auto blitterEnabled : {0, 1}) {
debugManager.flags.EnableBlitterForEnqueueImageOperations.set(blitterEnabled);

2
opencl/test/unit_test/command_queue/enqueue_copy_buffer_to_image_fixture.h
View File

@@ -28,7 +28,7 @@ struct EnqueueCopyBufferToImageTest : public CommandEnqueueFixture,
BufferDefaults::context = new MockContext(pClDevice);
context = new MockContext(pClDevice);
srcBuffer = BufferHelper<>::create(context);
dstImage = Image2dHelper<>::create(context);
dstImage = Image2dHelperUlt<>::create(context);
}
void TearDown() override {

12
opencl/test/unit_test/command_queue/enqueue_copy_buffer_to_image_tests.cpp
View File

@@ -241,25 +241,25 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
@@ -300,7 +300,7 @@ struct EnqueueCopyBufferToImageHw : public ::testing::Test {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
device = std::make_unique<MockClDevice>(MockClDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
context = std::make_unique<MockContext>(device.get());
dstImage = std::unique_ptr<Image>(Image2dHelper<>::create(context.get()));
dstImage = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context.get()));
}
std::unique_ptr<MockClDevice> device;

4
opencl/test/unit_test/command_queue/enqueue_copy_image_fixture.h
View File

@@ -24,8 +24,8 @@ struct EnqueueCopyImageTest : public CommandEnqueueFixture,
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
CommandEnqueueFixture::setUp();
context = new MockContext(pClDevice);
srcImage = Image2dHelper<>::create(context);
dstImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
dstImage = Image2dHelperUlt<>::create(context);
}
void TearDown(void) override {

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

@@ -275,25 +275,25 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
switch (srcImageType) {
case CL_MEM_OBJECT_IMAGE1D:
srcOrigin[1] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &srcImageDesc));
srcImage = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
srcImageDesc.image_array_size = 2;
srcOrigin[2] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &srcImageDesc));
srcImage = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
srcOrigin[2] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &srcImageDesc));
srcImage = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
srcImageDesc.image_array_size = 2;
srcOrigin[3] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &srcImageDesc));
srcImage = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
srcOrigin[3] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &srcImageDesc));
srcImage = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &srcImageDesc));
break;
}
@@ -302,24 +302,24 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
switch (dstImageType) {
case CL_MEM_OBJECT_IMAGE1D:
dstOrigin[1] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &dstImageDesc));
dstImage = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
dstImageDesc.image_array_size = 2;
dstOrigin[2] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &dstImageDesc));
dstImage = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
dstOrigin[2] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &dstImageDesc));
dstImage = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
dstOrigin[3] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &dstImageDesc));
dstImage = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
dstOrigin[3] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &dstImageDesc));
dstImage = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &dstImageDesc));
break;
}
@@ -385,10 +385,10 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyImage1dBufferToImage1dBufferThenCorrectBu
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
std::unique_ptr<Image> srcImage1dBuffer;
srcImage1dBuffer.reset(Image1dBufferHelper<>::create(context));
srcImage1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> srcImageBackup(&srcImage, srcImage1dBuffer.get());
std::unique_ptr<Image> dstImage1dBuffer;
dstImage1dBuffer.reset(Image1dBufferHelper<>::create(context));
dstImage1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> dstImageBackup(&dstImage, dstImage1dBuffer.get());
mockCmdQ->storeMultiDispatchInfo = true;
EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
@@ -400,7 +400,7 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyImage1dBufferToImageThenCorrectBuitInIsSe
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
std::unique_ptr<Image> srcImage1dBuffer;
srcImage1dBuffer.reset(Image1dBufferHelper<>::create(context));
srcImage1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> srcImageBackup(&srcImage, srcImage1dBuffer.get());
mockCmdQ->storeMultiDispatchInfo = true;
EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
@@ -412,7 +412,7 @@ HWTEST_F(EnqueueCopyImageTest, WhenCopyImageToImage1dBufferThenCorrectBuitInIsSe
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
std::unique_ptr<Image> dstImage1dBuffer;
dstImage1dBuffer.reset(Image1dBufferHelper<>::create(context));
dstImage1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> dstImageBackup(&dstImage, dstImage1dBuffer.get());
mockCmdQ->storeMultiDispatchInfo = true;
EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);

2
opencl/test/unit_test/command_queue/enqueue_copy_image_to_buffer_fixture.h
View File

@@ -26,7 +26,7 @@ struct EnqueueCopyImageToBufferTest : public CommandEnqueueFixture,
CommandEnqueueFixture::setUp();
BufferDefaults::context = new MockContext(pClDevice);
context = new MockContext(pClDevice);
srcImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
dstBuffer = BufferHelper<>::create(context);
}

12
opencl/test/unit_test/command_queue/enqueue_copy_image_to_buffer_tests.cpp
View File

@@ -251,25 +251,25 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
@@ -309,7 +309,7 @@ struct EnqueueCopyImageToBufferHw : public ::testing::Test {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
device = std::make_unique<MockClDevice>(MockClDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
context = std::make_unique<MockContext>(device.get());
srcImage = std::unique_ptr<Image>(Image2dHelper<>::create(context.get()));
srcImage = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context.get()));
}
std::unique_ptr<MockClDevice> device;

4
opencl/test/unit_test/command_queue/enqueue_fill_image_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,7 +19,7 @@ struct EnqueueFillImageTestFixture : public CommandEnqueueFixture {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
CommandEnqueueFixture::setUp();
context = new MockContext(pClDevice);
image = Image2dHelper<>::create(context);
image = Image2dHelperUlt<>::create(context);
}
void tearDown() {

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

@@ -221,7 +221,7 @@ HWTEST_F(EnqueueFillImageTest, WhenFillingImage1dBufferThenCorrectBuitInIsSelect
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
std::unique_ptr<Image> image1dBuffer;
image1dBuffer.reset(Image1dBufferHelper<>::create(context));
image1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> imageBackup(&image, image1dBuffer.get());
mockCmdQ->storeMultiDispatchInfo = true;
@@ -241,7 +241,7 @@ HWTEST_F(EnqueueFillImageTest, givenHeaplessWhenFillingImage1dBufferThenCorrectB
VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
std::unique_ptr<Image> image1dBuffer;
image1dBuffer.reset(Image1dBufferHelper<>::create(context));
image1dBuffer.reset(Image1dBufferHelperUlt<>::create(context));
VariableBackup<Image *> imageBackup(&image, image1dBuffer.get());
mockCmdQ->storeMultiDispatchInfo = true;

16
opencl/test/unit_test/command_queue/enqueue_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -88,7 +88,7 @@ struct EnqueueCopyBufferToImageHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> dstImageDelete(dstImage ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImageDelete(dstImage ? nullptr : Image2dHelperUlt<>::create(&context));
dstImage = dstImage ? dstImage : dstImageDelete.get();
size_t regionOut[3] = {
@@ -136,7 +136,7 @@ struct EnqueueCopyImageToBufferHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> srcImageDelete(srcImage ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImageDelete(srcImage ? nullptr : Image2dHelperUlt<>::create(&context));
srcImage = srcImage ? srcImage : srcImageDelete.get();
size_t regionIn[3] = {
@@ -183,8 +183,8 @@ struct EnqueueCopyImageHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> srcImageDelete(srcImage ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImageDelete(dstImage ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImageDelete(srcImage ? nullptr : Image2dHelperUlt<>::create(&context));
std::unique_ptr<Image> dstImageDelete(dstImage ? nullptr : Image2dHelperUlt<>::create(&context));
srcImage = srcImage ? srcImage : srcImageDelete.get();
dstImage = dstImage ? dstImage : dstImageDelete.get();
@@ -266,7 +266,7 @@ struct EnqueueFillImageHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelperUlt<>::create(&context));
image = image ? image : imageDelete.get();
size_t regionOut[3] = {
@@ -465,7 +465,7 @@ struct EnqueueReadImageHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelperUlt<>::create(&context));
image = image ? image : imageDelete.get();
size_t regionOut[3] = {
@@ -627,7 +627,7 @@ struct EnqueueWriteImageHelper {
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
auto &context = pCmdQ->getContext();
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelper<>::create(&context));
std::unique_ptr<Image> imageDelete(image ? nullptr : Image2dHelperUlt<>::create(&context));
image = image ? image : imageDelete.get();
size_t regionOut[3] = {

44
opencl/test/unit_test/command_queue/enqueue_map_image_tests.cpp
View File

@@ -41,7 +41,7 @@ struct EnqueueMapImageTest : public ClDeviceFixture,
ClDeviceFixture::setUp();
CommandQueueFixture::setUp(pClDevice, 0);
context = new MockContext(pClDevice);
image = ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context);
image = ImageHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(context);
}
void TearDown() override {
@@ -94,7 +94,7 @@ TEST_F(EnqueueMapImageTest, GivenTiledImageWhenMappingImageThenPointerIsReused)
}
HWTEST_F(EnqueueMapImageTest, givenAllocatedMapPtrAndMapWithDifferentOriginIsCalledThenReturnDifferentPointers) {
std::unique_ptr<Image> img(Image2dHelper<Image2dDefaults>::create(context));
std::unique_ptr<Image> img(Image2dHelperUlt<Image2dDefaults>::create(context));
auto mapFlags = CL_MAP_READ;
const size_t origin1[3] = {0, 0, 0};
const size_t origin2[3] = {2, 2, 0};
@@ -136,25 +136,25 @@ TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrWhenMapsWithDifferentMipMap
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D:
origin2[1] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
origin2[2] = 1;
imageDesc.image_array_size = 2;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin2[2] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
origin2[3] = 1;
imageDesc.image_array_size = 2;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin2[3] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
@@ -502,7 +502,7 @@ HWTEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenItIsMappedAndReturnsEventThe
auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
commandStreamReceiver.taskCount = forceTaskCount;
std::unique_ptr<Image> zeroCopyImage(ImageHelper<ImageWriteOnly<Image1dDefaults>>::create(context));
std::unique_ptr<Image> zeroCopyImage(ImageHelperUlt<ImageWriteOnly<Image1dDefaults>>::create(context));
ASSERT_TRUE(zeroCopyImage->isMemObjZeroCopy());
pCmdQ->taskCount = 40u;
@@ -550,7 +550,7 @@ TEST_F(EnqueueMapImageTest, GivenNonZeroCopyImageWhenMappedWithOffsetThenCorrect
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;
Image *nonZeroCopyImage = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
Image *nonZeroCopyImage = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context);
EXPECT_FALSE(nonZeroCopyImage->isMemObjZeroCopy());
@@ -592,7 +592,7 @@ TEST_F(EnqueueMapImageTest, GivenNonZeroCopyImageWhenMappedWithOffsetThenCorrect
}
HWTEST_F(EnqueueMapImageTest, givenSharingHandlerWhenNonReadOnlyMapAndUnmapOnNonTiledImageIsCalledThenMakeGpuCopy) {
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context));
ASSERT_NE(nullptr, image);
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->isTiledAllocation());
@@ -617,7 +617,7 @@ HWTEST_F(EnqueueMapImageTest, givenSharingHandlerWhenNonReadOnlyMapAndUnmapOnNon
}
HWTEST_F(EnqueueMapImageTest, givenSharingHandlerWhenReadOnlyMapAndUnmapOnNonTiledImageIsCalledThenMakeGpuCopy) {
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context));
ASSERT_NE(nullptr, image);
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->isTiledAllocation());
@@ -642,7 +642,7 @@ HWTEST_F(EnqueueMapImageTest, givenSharingHandlerWhenReadOnlyMapAndUnmapOnNonTil
}
HWTEST_F(EnqueueMapImageTest, givenImageWithouUsetHostPtrFlagWhenMappedOnCpuThenSetAllMapProperties) {
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context));
ASSERT_NE(nullptr, image);
EXPECT_TRUE(image->mappingOnCpuAllowed());
@@ -670,7 +670,7 @@ HWTEST_F(EnqueueMapImageTest, givenImageWithouUsetHostPtrFlagWhenMappedOnCpuThen
}
HWTEST_F(EnqueueMapImageTest, givenImageWithUseHostPtrFlagWhenMappedOnCpuThenSetAllMapProperties) {
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context));
ASSERT_NE(nullptr, image);
EXPECT_TRUE(image->mappingOnCpuAllowed());
@@ -743,7 +743,7 @@ TEST_F(EnqueueMapImageTest, givenBlockedCommandQueueWhenBlockingMapWith1DImageIs
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;
Image *image1D = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
Image *image1D = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context);
ASSERT_NE(nullptr, image1D);
class MockEventWithSetCompleteOnUpdate : public Event {
@@ -793,7 +793,7 @@ TEST_F(EnqueueMapImageTest, givenBlockedCommandQueueWhenBlockingCpuMapIsCalledTh
}
};
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dArrayDefaults>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
MyMockUserEvent blockingEvent;
@@ -807,7 +807,7 @@ TEST_F(EnqueueMapImageTest, givenBlockedCommandQueueWhenBlockingCpuMapIsCalledTh
EXPECT_NE(0u, retImageRowPitch);
EXPECT_NE(0u, retImageSlicePitch);
image.reset(ImageHelper<Image1dDefaults>::create(context));
image.reset(ImageHelperUlt<Image1dDefaults>::create(context));
pCmdQ->enqueueMapImage(image.get(), true, CL_MAP_READ, origin, region,
&retImageRowPitch, &retImageSlicePitch,
1, &blockingClEvent, nullptr, retVal);
@@ -823,7 +823,7 @@ TEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenMappedOnCpuThenReturnImageRowA
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dArrayDefaults>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
EXPECT_TRUE(image->isMemObjZeroCopy());
@@ -842,7 +842,7 @@ TEST_F(EnqueueMapImageTest, givenNonZeroCopyImageWhenMappedOnCpuThenReturnHostRo
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
EXPECT_FALSE(image->isMemObjZeroCopy());
@@ -861,7 +861,7 @@ TEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenMappedOnGpuThenReturnHostRowAn
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dArrayDefaults>::create(context));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
EXPECT_TRUE(image->isMemObjZeroCopy());
@@ -881,7 +881,7 @@ TEST_F(EnqueueMapImageTest, givenNonZeroCopyImageWhenMappedOnGpuThenReturnHostRo
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
EXPECT_FALSE(image->isMemObjZeroCopy());
@@ -908,7 +908,7 @@ TEST_F(EnqueueMapImageTest, givenMipMapImageWhenMappedThenReturnHostRowAndSliceP
imageDesc.image_height = 4;
imageDesc.image_depth = 4;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
@@ -992,7 +992,7 @@ struct EnqueueMapImageTypeTest : public CommandEnqueueFixture,
void SetUp() override {
CommandEnqueueFixture::setUp();
image = ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(&context);
image = ImageHelperUlt<ImageUseHostPtr<Image2dDefaults>>::create(&context);
}
void TearDown() override {

2
opencl/test/unit_test/command_queue/enqueue_read_image_fixture.h
View File

@@ -28,7 +28,7 @@ struct EnqueueReadImageTest : public CommandEnqueueFixture,
CommandEnqueueFixture::setUp();
context = new MockContext(pClDevice);
srcImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
const auto &imageDesc = srcImage->getImageDesc();
dstPtr = new float[imageDesc.image_width * imageDesc.image_height];

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

@@ -112,7 +112,7 @@ HWTEST_F(EnqueueReadImageTest, givenCommandQueueAndFailingAllocationForHostSurfa
CommandStreamReceiver *oldCommandStreamReceiver = &cmdQ.getGpgpuCommandStreamReceiver();
cmdQ.gpgpuEngine->commandStreamReceiver = failCsr.get();
auto srcImage = Image2dHelper<>::create(context);
auto srcImage = Image2dHelperUlt<>::create(context);
auto retVal = cmdQ.enqueueReadImage(srcImage, CL_FALSE,
EnqueueReadImageTraits::origin,
EnqueueReadImageTraits::region,
@@ -136,7 +136,7 @@ HWTEST_F(EnqueueReadImageTest, givenCommandQueueAndFailingAllocationForHostSurfa
CommandStreamReceiver *oldCommandStreamReceiver = &cmdQ.getGpgpuCommandStreamReceiver();
cmdQ.gpgpuEngine->commandStreamReceiver = failCsr.get();
auto srcImage = Image2dHelper<>::create(context);
auto srcImage = Image2dHelperUlt<>::create(context);
auto retVal = cmdQ.enqueueReadImage(srcImage, CL_TRUE,
EnqueueReadImageTraits::origin,
EnqueueReadImageTraits::region,
@@ -230,7 +230,7 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageThen
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
UserEvent userEvent{};
@@ -280,7 +280,7 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageIsCa
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
UserEvent userEvent{};
@@ -360,7 +360,7 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenNonBlockedEnqueueRea
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
auto &ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> &>(pCmdQ1->getGpgpuCommandStreamReceiver());
@@ -385,7 +385,7 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenNonBlockedEnqueueRea
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
EXPECT_EQ(MigrationSyncData::locationUndefined, pImage->getMultiGraphicsAllocation().getMigrationSyncData()->getCurrentLocation());
@@ -421,7 +421,7 @@ HWTEST_F(EnqueueReadImageTest, givenMultiRootDeviceImageWhenEnqueueReadImageIsCa
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pCmdQ2 = createCommandQueue(context.getDevice(1), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
auto &ultCsr1 = static_cast<UltCommandStreamReceiver<FamilyType> &>(pCmdQ1->getGpgpuCommandStreamReceiver());
auto &ultCsr2 = static_cast<UltCommandStreamReceiver<FamilyType> &>(pCmdQ2->getGpgpuCommandStreamReceiver());
@@ -502,7 +502,7 @@ HWTEST2_F(EnqueueReadImageTest, givenImageFromBufferThatRequiresMigrationWhenEnq
imageDesc.mem_object = clBuffer;
EXPECT_TRUE(pBuffer->getMultiGraphicsAllocation().requiresMigrations());
auto pImage = Image2dHelper<>::create(&context, &imageDesc);
auto pImage = Image2dHelperUlt<>::create(&context, &imageDesc);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
UserEvent userEvent{};
@@ -711,7 +711,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, EnqueueReadImageTest, GivenBlockingEnqueueWhenRea
}
HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
std::unique_ptr<Image> srcImage(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
auto imageSize = imageDesc.image_width * imageDesc.image_array_size * 4;
size_t origin[] = {0, 0, 0};
@@ -741,7 +741,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
copyBuiltIn,
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, pCmdQ->getClDevice(), &origBuilder)));
std::unique_ptr<Image> srcImage(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_array_size, 1};
@@ -764,7 +764,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
}
HWTEST_F(EnqueueReadImageTest, GivenImage2DarrayWhenReadImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image2dArrayHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
auto imageSize = imageDesc.image_width * imageDesc.image_height * imageDesc.image_array_size * 4;
size_t origin[] = {0, 0, 0};
@@ -782,7 +782,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage2DarrayWhenReadImageIsCalledThenHostPtr
HWTEST_F(EnqueueReadImageTest, GivenImage1DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image1dHelper<>::create(context));
std::unique_ptr<Image> dstImage2(Image1dHelperUlt<>::create(context));
auto &imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pClDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
@@ -811,7 +811,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DAndImageShareTheSameStorageWithHostPt
HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> dstImage2(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = dstImage2->getImageDesc();
size_t origin[] = {imageDesc.image_width / 2, imageDesc.image_array_size / 2, 0};
size_t region[] = {imageDesc.image_width - (imageDesc.image_width / 2), imageDesc.image_array_size - (imageDesc.image_array_size / 2), 1};
@@ -839,7 +839,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithH
HWTEST_F(EnqueueReadImageTest, GivenImage1DThatIsZeroCopyWhenReadImageWithTheSamePointerAndOutputEventIsPassedThenEventHasCorrectCommandTypeSet) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage(Image1dHelper<>::create(context));
std::unique_ptr<Image> dstImage(Image1dHelperUlt<>::create(context));
auto &imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
@@ -881,7 +881,7 @@ struct EnqueueReadImageTestWithBcs : EnqueueReadImageTest {
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image2dArrayHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
@@ -893,7 +893,7 @@ HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThen
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageWithMapAllocationIsCalledThenItDoesntCallNotifyFunction) {
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image2dArrayHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
@@ -910,7 +910,7 @@ HWTEST_F(EnqueueReadImageTest, givenEnqueueReadImageBlockingWhenAUBDumpAllocsOnE
DebugManagerStateRestore dbgRestore;
debugManager.flags.AUBDumpAllocsOnEnqueueReadOnly.set(true);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image2dArrayHelperUlt<>::create(context));
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
@@ -927,7 +927,7 @@ HWTEST_F(EnqueueReadImageTest, givenEnqueueReadImageNonBlockingWhenAUBDumpAllocs
DebugManagerStateRestore dbgRestore;
debugManager.flags.AUBDumpAllocsOnEnqueueReadOnly.set(true);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image2dArrayHelperUlt<>::create(context));
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
@@ -971,25 +971,25 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
@@ -1240,7 +1240,7 @@ HWTEST_F(ReadImageStagingBufferTest, whenEnqueueStagingReadImageCalledFor3DImage
imageDesc.image_depth = 64;
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_READ_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -249,7 +249,7 @@ HWTEST_F(EnqueueUnmapMemObjTest, givenMemObjWhenUnmappingThenSetAubWritableBefor
DebugManagerStateRestore restore;
debugManager.flags.DisableZeroCopyForBuffers.set(true);
auto buffer = std::unique_ptr<Buffer>(BufferHelper<>::create());
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(BufferDefaults::context));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(BufferDefaults::context));
class MyMockCommandQueue : public MockCommandQueue {
public:

6
opencl/test/unit_test/command_queue/enqueue_waitlist_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -56,8 +56,8 @@ struct EnqueueWaitlistTest : public EnqueueWaitlistFixture,
EnqueueWaitlistFixture::setUp();
buffer = BufferHelper<>::create();
bufferNonZeroCopy = new UnalignedBuffer(BufferDefaults::context, &bufferNonZeroCopyAlloc);
image = Image1dHelper<>::create(BufferDefaults::context);
imageNonZeroCopy = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(BufferDefaults::context);
image = Image1dHelperUlt<>::create(BufferDefaults::context);
imageNonZeroCopy = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(BufferDefaults::context);
}
void TearDown() override {

2
opencl/test/unit_test/command_queue/enqueue_write_image_fixture.h
View File

@@ -25,7 +25,7 @@ struct EnqueueWriteImageTest : public CommandEnqueueFixture,
CommandEnqueueFixture::setUp();
context = new MockContext(pClDevice);
dstImage = Image2dHelper<>::create(context);
dstImage = Image2dHelperUlt<>::create(context);
dstAllocation = dstImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
const auto &imageDesc = dstImage->getImageDesc();

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

@@ -229,7 +229,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, EnqueueWriteImageTest, WhenWritingImageThenMediaV
}
HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenReadWriteImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> dstImage2(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = dstImage2->getImageDesc();
auto imageSize = imageDesc.image_width * imageDesc.image_array_size * 4;
size_t origin[] = {0, 0, 0};
@@ -268,7 +268,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, pCmdQ->getClDevice(), &origBuilder)));
std::unique_ptr<Image> image;
std::unique_ptr<Image> destImage(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> destImage(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = destImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_array_size, 1};
@@ -291,7 +291,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
}
HWTEST_F(EnqueueWriteImageTest, GivenImage2DarrayWhenReadWriteImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
std::unique_ptr<Image> dstImage(Image2dArrayHelper<>::create(context));
std::unique_ptr<Image> dstImage(Image2dArrayHelperUlt<>::create(context));
auto &imageDesc = dstImage->getImageDesc();
auto imageSize = imageDesc.image_width * imageDesc.image_height * imageDesc.image_array_size * 4;
size_t origin[] = {0, 0, 0};
@@ -313,7 +313,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage2DarrayWhenReadWriteImageIsCalledThenH
HWTEST_F(EnqueueWriteImageTest, GivenImage1DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage(Image1dHelper<>::create(context));
std::unique_ptr<Image> dstImage(Image1dHelperUlt<>::create(context));
auto &imageDesc = dstImage->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pClDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
@@ -340,7 +340,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DAndImageShareTheSameStorageWithHostP
HWTEST_F(EnqueueWriteImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage(Image1dArrayHelper<>::create(context));
std::unique_ptr<Image> dstImage(Image1dArrayHelperUlt<>::create(context));
auto &imageDesc = dstImage->getImageDesc();
size_t origin[] = {imageDesc.image_width / 2, imageDesc.image_array_size / 2, 0};
size_t region[] = {imageDesc.image_width - (imageDesc.image_width / 2), imageDesc.image_array_size - (imageDesc.image_array_size / 2), 1};
@@ -368,7 +368,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DArrayAndImageShareTheSameStorageWith
HWTEST_F(EnqueueWriteImageTest, GivenImage1DThatIsZeroCopyWhenWriteImageWithTheSamePointerAndOutputEventIsPassedThenEventHasCorrectCommandTypeSet) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> srcImage(Image1dHelper<>::create(context));
std::unique_ptr<Image> srcImage(Image1dHelperUlt<>::create(context));
auto &imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
@@ -433,25 +433,25 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
@@ -570,7 +570,7 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenEnqueueWriteImageTh
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
UserEvent userEvent{};
@@ -620,7 +620,7 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenEnqueueWriteImageIs
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
UserEvent userEvent{};
@@ -700,7 +700,7 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenNonBlockedEnqueueWr
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
auto &ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> &>(pCmdQ1->getGpgpuCommandStreamReceiver());
@@ -728,7 +728,7 @@ HWTEST_F(EnqueueWriteImageTest, givenMultiRootDeviceImageWhenNonBlockedEnqueueWr
auto pCmdQ1 = createCommandQueue(context.getDevice(0), nullptr, &context);
auto pImage = Image2dHelper<>::create(&context);
auto pImage = Image2dHelperUlt<>::create(&context);
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
EXPECT_EQ(MigrationSyncData::locationUndefined, pImage->getMultiGraphicsAllocation().getMigrationSyncData()->getCurrentLocation());
@@ -808,15 +808,15 @@ HWTEST_F(EnqueueWriteImageTest, whenisValidForStagingTransferCalledThenReturnCor
auto isStagingBuffersEnabled = pDevice->getProductHelper().isStagingBuffersEnabled();
unsigned char ptr[16];
std::unique_ptr<Image> image(Image1dHelper<>::create(context));
std::unique_ptr<Image> image(Image1dHelperUlt<>::create(context));
EXPECT_EQ(isStagingBuffersEnabled, pCmdQ->isValidForStagingTransfer(image.get(), ptr, image->getSize(), CL_COMMAND_WRITE_IMAGE, false, false));
pCmdQ->finish();
image.reset(Image2dHelper<>::create(context));
image.reset(Image2dHelperUlt<>::create(context));
EXPECT_EQ(isStagingBuffersEnabled, pCmdQ->isValidForStagingTransfer(image.get(), ptr, image->getSize(), CL_COMMAND_WRITE_IMAGE, false, false));
pCmdQ->finish();
image.reset(Image3dHelper<>::create(context));
image.reset(Image3dHelperUlt<>::create(context));
EXPECT_EQ(isStagingBuffersEnabled, pCmdQ->isValidForStagingTransfer(image.get(), ptr, image->getSize(), CL_COMMAND_WRITE_IMAGE, false, false));
}
@@ -961,7 +961,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledFor3DIma
imageDesc.image_depth = 64;
size_t origin[3] = {0, 0, 0};
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);
@@ -983,7 +983,7 @@ HWTEST_F(WriteImageStagingBufferTest, whenEnqueueStagingWriteImageCalledForMipMa
imageDesc.num_mip_levels = 2;
size_t origin[4] = {0, 0, 0, 10};
size_t region[3] = {2, 2, 4};
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(context, &imageDesc));
auto res = mockCommandQueueHw.enqueueStagingImageTransfer(CL_COMMAND_WRITE_IMAGE, image.get(), false, origin, region, 4u, pitchSize, ptr, nullptr);
EXPECT_EQ(res, CL_SUCCESS);

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

@@ -40,8 +40,8 @@ struct GetSizeRequiredImageTest : public CommandEnqueueFixture,
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
CommandEnqueueFixture::setUp();
srcImage = Image2dHelper<>::create(context);
dstImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
dstImage = Image2dHelperUlt<>::create(context);
pDevice->setPreemptionMode(PreemptionMode::Disabled);
}

6
opencl/test/unit_test/command_queue/oom_image_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -43,8 +43,8 @@ struct OOMCommandQueueImageTest : public ClDeviceFixture,
context = new MockContext(pClDevice);
CommandQueueFixture::setUp(context, pClDevice, 0);
srcImage = Image2dHelper<>::create(context);
dstImage = Image2dHelper<>::create(context);
srcImage = Image2dHelperUlt<>::create(context);
dstImage = Image2dHelperUlt<>::create(context);
const auto &oomSetting = GetParam();
auto oomSize = 10u;

30
opencl/test/unit_test/command_queue/zero_size_enqueue_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -418,7 +418,7 @@ struct ZeroSizeEnqueueHandlerImageTest : ZeroSizeEnqueueHandlerTest {
HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenReadingImageThenCommandMarkerShouldBeEnqueued) {
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t memory[1];
size_t origin[3] = {1024u, 1, 0};
@@ -455,7 +455,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenRead
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
cl_event event;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t memory[1];
size_t origin[3] = {1024u, 1, 0};
size_t zeroRegion[3] = {0, 0, 0};
@@ -475,7 +475,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenRead
HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenWritingImageThenCommandMarkerShouldBeEnqueued) {
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t memory[1];
size_t origin[3] = {1024u, 1, 0};
@@ -512,7 +512,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenWrit
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
cl_event event;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t memory[1];
size_t origin[3] = {1024u, 1, 0};
size_t zeroRegion[3] = {0, 0, 0};
@@ -532,8 +532,8 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenWrit
HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageThenCommandMarkerShouldBeEnqueued) {
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(&context));
size_t srcOrigin[3] = {1024u, 1, 0};
size_t dstOrigin[3] = {1024u, 1, 0};
@@ -570,8 +570,8 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
cl_event event;
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(&context));
size_t srcOrigin[3] = {1024u, 1, 0};
size_t dstOrigin[3] = {1024u, 1, 0};
size_t zeroRegion[3] = {0, 0, 0};
@@ -591,7 +591,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageToBufferThenCommandMarkerShouldBeEnqueued) {
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(&context));
std::unique_ptr<Buffer> dstBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
size_t srcOrigin[3] = {1024u, 1, 0};
@@ -628,7 +628,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
cl_event event;
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(&context));
std::unique_ptr<Buffer> dstBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
size_t srcOrigin[3] = {1024u, 1, 0};
size_t zeroRegion[3] = {0, 0, 0};
@@ -649,7 +649,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Buffer> srcBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(&context));
size_t dstOrigin[3] = {1024u, 1, 0};
size_t zeroRegion000[3] = {0, 0, 0};
@@ -686,7 +686,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
cl_event event;
std::unique_ptr<Buffer> srcBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(&context));
size_t dstOrigin[3] = {1024u, 1, 0};
size_t zeroRegion[3] = {0, 0, 0};
mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion, 0, nullptr, &event);
@@ -705,7 +705,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopy
HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenFillingImageThenCommandMarkerShouldBeEnqueued) {
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t origin[3] = {1024u, 1, 1};
int32_t fillColor[4] = {0xCC, 0xCC, 0xCC, 0xCC};
@@ -742,7 +742,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenFill
auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
cl_event event;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
size_t origin[3] = {1024u, 1, 1};
int32_t fillColor[4] = {0xCC, 0xCC, 0xCC, 0xCC};
size_t zeroRegion[3] = {0, 0, 0};

24
opencl/test/unit_test/command_stream/command_stream_receiver_hw_2_tests.cpp
View File

@@ -1849,7 +1849,7 @@ HWTEST_F(BcsTestsImages, givenImage1DWhenSetBlitPropertiesForImageIsCalledThenVa
imgDesc.image_width = 10u;
imgDesc.image_height = 0u;
imgDesc.image_depth = 0u;
std::unique_ptr<Image> image(Image1dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image1dHelperUlt<>::create(context.get(), &imgDesc));
size_t expectedBytesPerPixel = image->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
size_t expectedRowPitch = image->getImageDesc().image_row_pitch;
size_t expectedSlicePitch = image->getImageDesc().image_slice_pitch;
@@ -1892,7 +1892,7 @@ HWTEST_F(BcsTestsImages, givenImage1DBufferWhenSetBlitPropertiesForImageIsCalled
cl_image_format imgFormat{};
imgFormat.image_channel_order = CL_RGBA;
imgFormat.image_channel_data_type = CL_UNSIGNED_INT8;
std::unique_ptr<Image> image(Image1dHelper<>::create(context.get(), &imgDesc, &imgFormat));
std::unique_ptr<Image> image(Image1dHelperUlt<>::create(context.get(), &imgDesc, &imgFormat));
size_t originalBytesPerPixel = image->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
BlitProperties initBlitProperties{};
@@ -1956,7 +1956,7 @@ HWTEST_F(BcsTestsImages, givenImage2DArrayWhenSetBlitPropertiesForImageIsCalledT
imgDesc.image_array_size = 4u;
imgDesc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY;
std::unique_ptr<Image> image(Image2dArrayHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dArrayHelperUlt<>::create(context.get(), &imgDesc));
size_t expectedBytesPerPixel = image->getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes;
size_t expectedRowPitch = image->getImageDesc().image_row_pitch;
size_t expectedSlicePitch = image->getImageDesc().image_slice_pitch;
@@ -1982,7 +1982,7 @@ HWTEST_F(BcsTestsImages, givenImage2DArrayWhenSetBlitPropertiesForImageIsCalledT
HWTEST_F(BcsTestsImages, givenImageWithSurfaceOffsetWhenSetBlitPropertiesForImageIsCalledThenGpuAddressIsCorrect) {
cl_image_desc imgDesc = Image1dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dArrayHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dArrayHelperUlt<>::create(context.get(), &imgDesc));
uint64_t surfaceOffset = 0x01000;
image->setSurfaceOffsets(surfaceOffset, 0, 0, 0);
@@ -2001,7 +2001,7 @@ HWTEST_F(BcsTestsImages, givenImageWithSurfaceOffsetWhenSetBlitPropertiesForImag
HWTEST_F(BcsTestsImages, givenImageWithPlaneSetWhenAdjustBlitPropertiesForImageIsCalledThenPlaneIsCorrect) {
cl_image_desc imgDesc = Image1dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dArrayHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dArrayHelperUlt<>::create(context.get(), &imgDesc));
BlitProperties blitProperties{};
EXPECT_EQ(GMM_YUV_PLANE_ENUM::GMM_NO_PLANE, blitProperties.dstPlane);
@@ -2040,7 +2040,7 @@ HWTEST_F(BcsTests, givenHostPtrToImageWhenConstructPropertiesIsCalledThenValuesA
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.image_width = 10u;
imgDesc.image_height = 12u;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcPtr = hostPtr;
builtinOpParams.srcMemObj = nullptr;
@@ -2081,7 +2081,7 @@ HWTEST_F(BcsTests, givenImageToHostPtrWhenConstructPropertiesIsCalledThenValuesA
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.image_width = 10u;
imgDesc.image_height = 12u;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.dstPtr = hostPtr;
builtinOpParams.srcMemObj = image.get();
@@ -2120,7 +2120,7 @@ HWTEST_F(BcsTests, givenHostPtrToImageWithInputRowSlicePitchesWhenConstructPrope
void *hostPtr = reinterpret_cast<void *>(hostAllocationPtr.get());
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcPtr = hostPtr;
builtinOpParams.srcMemObj = nullptr;
@@ -2153,7 +2153,7 @@ HWTEST_F(BcsTests, givenImageToHostPtrWithInputRowSlicePitchesWhenConstructPrope
void *hostPtr = reinterpret_cast<void *>(hostAllocationPtr.get());
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.dstPtr = hostPtr;
builtinOpParams.srcMemObj = image.get();
@@ -2189,7 +2189,7 @@ HWTEST_F(BcsTests, givenHostPtrToImageWhenBlitBufferIsCalledThenBlitCmdIsFound)
auto hostAllocationPtr = allocateAlignedMemory(hostAllocationSize, MemoryConstants::pageSize);
void *hostPtr = reinterpret_cast<void *>(hostAllocationPtr.get());
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get()));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get()));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcPtr = hostPtr;
builtinOpParams.dstMemObj = image.get();
@@ -2217,7 +2217,7 @@ HWTEST_F(BcsTests, given1DTiledArrayImageWhenConstructPropertiesThenImageTransfo
resourceInfoSrc->mockResourceCreateParams.Type = GMM_RESOURCE_TYPE::RESOURCE_1D;
resourceInfoSrc->mockResourceCreateParams.ArraySize = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get()));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get()));
auto oldGmm = std::unique_ptr<Gmm>(image->getGraphicsAllocation(pDevice->getRootDeviceIndex())->getDefaultGmm());
image->getGraphicsAllocation(pDevice->getRootDeviceIndex())->setGmm(gmmSrc.release(), 0);
BuiltinOpParams builtinOpParams{};
@@ -2244,7 +2244,7 @@ HWTEST_F(BcsTests, given1DNotTiledArrayImageWhenConstructPropertiesThenImageNotT
resourceInfoSrc->mockResourceCreateParams.Type = GMM_RESOURCE_TYPE::RESOURCE_1D;
resourceInfoSrc->mockResourceCreateParams.ArraySize = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get()));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get()));
auto oldGmm = std::unique_ptr<Gmm>(image->getGraphicsAllocation(pDevice->getRootDeviceIndex())->getDefaultGmm());
image->getGraphicsAllocation(pDevice->getRootDeviceIndex())->setGmm(gmmSrc.release(), 0);
BuiltinOpParams builtinOpParams{};

14
opencl/test/unit_test/command_stream/command_stream_receiver_hw_3_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -37,7 +37,7 @@ HWTEST_F(BcsTests, given3dImageWhenBlitBufferIsCalledThenBlitCmdIsFoundZtimes) {
auto hostAllocationPtr = allocateAlignedMemory(hostAllocationSize, MemoryConstants::pageSize);
void *hostPtr = reinterpret_cast<void *>(hostAllocationPtr.get());
std::unique_ptr<Image> image(Image3dHelper<>::create(context.get()));
std::unique_ptr<Image> image(Image3dHelperUlt<>::create(context.get()));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcPtr = hostPtr;
builtinOpParams.dstMemObj = image.get();
@@ -68,7 +68,7 @@ HWTEST_F(BcsTests, givenImageToHostPtrWhenBlitBufferIsCalledThenBlitCmdIsFound)
auto hostAllocationPtr = allocateAlignedMemory(hostAllocationSize, MemoryConstants::pageSize);
void *hostPtr = reinterpret_cast<void *>(hostAllocationPtr.get());
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get()));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get()));
BuiltinOpParams builtinOpParams{};
builtinOpParams.dstPtr = hostPtr;
builtinOpParams.srcMemObj = image.get();
@@ -97,7 +97,7 @@ HWTEST_F(BcsTests, givenHostPtrToImageWhenBlitBufferIsCalledThenBlitCmdIsCorrect
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.image_width = 10;
imgDesc.image_height = 12;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcPtr = hostPtr;
builtinOpParams.srcMemObj = nullptr;
@@ -132,7 +132,7 @@ HWTEST_F(BcsTests, givenImageToHostPtrWhenBlitBufferIsCalledThenBlitCmdIsCorrect
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.image_width = 10u;
imgDesc.image_height = 12u;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.dstPtr = hostPtr;
builtinOpParams.srcMemObj = image.get();
@@ -163,8 +163,8 @@ HWTEST_F(BcsTests, givenImageToImageWhenBlitBufferIsCalledThenBlitCmdIsCorrectly
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.image_width = 10u;
imgDesc.image_height = 12u;
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(context.get(), &imgDesc));
BuiltinOpParams builtinOpParams{};
builtinOpParams.srcMemObj = srcImage.get();

12
opencl/test/unit_test/context/driver_diagnostics_enqueue_tests.cpp
View File

@@ -571,9 +571,9 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueMapImageIsCall
size_t region[] = {1, 1, 1};
if (isZeroCopyImage) {
image = ImageHelper<ImageReadOnly<Image1dDefaults>>::create(context);
image = ImageHelperUlt<ImageReadOnly<Image1dDefaults>>::create(context);
} else {
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
image = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context);
}
EXPECT_EQ(isZeroCopyImage, image->isMemObjZeroCopy());
pCmdQ->enqueueMapImage(
@@ -600,14 +600,14 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueMapImageIsCall
TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagAndBlockingEventWhenEnqueueMapImageIsCallingThenContextProvidesProperHint) {
auto image = std::unique_ptr<Image>(ImageHelper<ImageReadOnly<Image1dDefaults>>::create(context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<ImageReadOnly<Image1dDefaults>>::create(context));
bool isZeroCopyImage = GetParam();
size_t origin[] = {0, 0, 0};
size_t region[] = {1, 1, 1};
if (!isZeroCopyImage) {
image.reset(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
image.reset(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context));
}
EXPECT_EQ(isZeroCopyImage, image->isMemObjZeroCopy());
@@ -704,9 +704,9 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueUnmapIsCalling
size_t region[] = {1, 1, 1};
if (isZeroCopyImage) {
image = ImageHelper<ImageReadOnly<Image1dDefaults>>::create(context);
image = ImageHelperUlt<ImageReadOnly<Image1dDefaults>>::create(context);
} else {
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
image = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context);
}
EXPECT_EQ(isZeroCopyImage, image->isMemObjZeroCopy());

4
opencl/test/unit_test/context/driver_diagnostics_tests.cpp
View File

@@ -321,7 +321,7 @@ TEST_F(PerformanceHintTest, GivenContextAndDispatchinfoAndEnableComputeWorkSizeS
TEST_F(PerformanceHintTest, GivenZeroCopyImageAndContextWhenCreateImageThenContextProvidesHintAboutAlignment) {
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(context));
EXPECT_TRUE(image->isMemObjZeroCopy());
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_IMAGE_MEETS_ALIGNMENT_RESTRICTIONS], static_cast<cl_mem>(image.get()));
@@ -330,7 +330,7 @@ TEST_F(PerformanceHintTest, GivenZeroCopyImageAndContextWhenCreateImageThenConte
TEST_F(PerformanceHintTest, GivenNonZeroCopyImageAndContextWhenCreateImageThenContextDoesntProvidesHintAboutAlignment) {
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context));
EXPECT_FALSE(image->isMemObjZeroCopy());
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_IMAGE_MEETS_ALIGNMENT_RESTRICTIONS], static_cast<cl_mem>(image.get()));

4
opencl/test/unit_test/context/driver_diagnostics_tests.h
View File

@@ -174,8 +174,8 @@ struct PerformanceHintEnqueueImageTest : public PerformanceHintEnqueueTest {
PerformanceHintEnqueueTest::SetUp();
address = alignedMalloc(2 * MemoryConstants::cacheLineSize, MemoryConstants::cacheLineSize);
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
zeroCopyImage.reset(ImageHelper<Image1dDefaults>::create(context));
image = ImageHelperUlt<ImageUseHostPtr<Image1dDefaults>>::create(context);
zeroCopyImage.reset(ImageHelperUlt<Image1dDefaults>::create(context));
}
void TearDown() override {

2
opencl/test/unit_test/event/event_tests.cpp
View File

@@ -1632,7 +1632,7 @@ TEST_F(EventTest, givenCmdQueueWithoutProfilingWhenIsCpuProfilingIsCalledThenFal
}
TEST_F(EventTest, givenOutEventWhenBlockingEnqueueHandledOnCpuThenUpdateTaskCountAndFlushStampFromCmdQ) {
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&mockContext));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&mockContext));
EXPECT_TRUE(image->mappingOnCpuAllowed());
pCmdQ->flushStamp->setStamp(10);

4
opencl/test/unit_test/event/user_events_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -902,7 +902,7 @@ TEST_F(MockEventTests, GivenEnqueueReadImageWhenWaitingforEventThenSuccessIsRetu
uEvent = makeReleaseable<UserEvent>(context);
cl_event eventWaitList[] = {uEvent.get()};
auto image = clUniquePtr(Image2dHelper<>::create(this->context));
auto image = clUniquePtr(Image2dHelperUlt<>::create(this->context));
ASSERT_NE(nullptr, image);
auto retVal = EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ,

16
opencl/test/unit_test/fixtures/image_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -74,7 +74,7 @@ struct LuminanceImage : public ImageReadOnly<Image2dDefaults> {
};
template <typename Traits>
struct ImageHelper {
struct ImageHelperUlt {
using Context = NEO::Context;
using Image = NEO::Image;
using MockContext = NEO::MockContext;
@@ -98,27 +98,27 @@ struct ImageHelper {
};
template <typename Traits = Image1dDefaults>
struct Image1dHelper : public ImageHelper<Traits> {
struct Image1dHelperUlt : public ImageHelperUlt<Traits> {
};
template <typename Traits = Image1dBufferDefaults>
struct Image1dBufferHelper : public ImageHelper<Traits> {
struct Image1dBufferHelperUlt : public ImageHelperUlt<Traits> {
};
template <typename Traits = Image2dDefaults>
struct Image2dHelper : public ImageHelper<Traits> {
struct Image2dHelperUlt : public ImageHelperUlt<Traits> {
};
template <typename Traits = Image3dDefaults>
struct Image3dHelper : public ImageHelper<Traits> {
struct Image3dHelperUlt : public ImageHelperUlt<Traits> {
};
template <typename Traits = Image2dArrayDefaults>
struct Image2dArrayHelper : public ImageHelper<Traits> {
struct Image2dArrayHelperUlt : public ImageHelperUlt<Traits> {
};
template <typename Traits = Image1dArrayDefaults>
struct Image1dArrayHelper : public ImageHelper<Traits> {
struct Image1dArrayHelperUlt : public ImageHelperUlt<Traits> {
};
struct ImageClearColorFixture : ::testing::Test {

4
opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -70,7 +70,7 @@ void KernelImageArgTest::SetUp() {
crossThreadData[0x20 / sizeof(uint32_t)] = 0x12344321;
pKernel->setCrossThreadData(crossThreadData, sizeof(crossThreadData));
image.reset(Image2dHelper<>::create(context.get()));
image.reset(Image2dHelperUlt<>::create(context.get()));
ASSERT_NE(nullptr, image);
}

4
opencl/test/unit_test/fixtures/one_mip_level_image_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -44,7 +44,7 @@ struct OneMipLevelImageFixture {
Image *createImage() {
cl_image_desc imageDesc = Image3dDefaults::imageDesc;
imageDesc.num_mip_levels = 1;
return ImageHelper<Image3dDefaults>::create(&context, &imageDesc);
return ImageHelperUlt<Image3dDefaults>::create(&context, &imageDesc);
}
Buffer *createBuffer() {

16
opencl/test/unit_test/gen12lp/image_tests_gen12lp.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -26,7 +26,7 @@ typedef ::testing::Test gen12LpImageTests;
GEN12LPTEST_F(gen12LpImageTests, WhenAppendingSurfaceStateParamsThenSurfaceStateDoesNotChange) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(&context));
auto surfaceStateBefore = FamilyType::cmdInitRenderSurfaceState;
auto surfaceStateAfter = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
@@ -48,7 +48,7 @@ GEN12LPTEST_F(ImageClearColorFixture, givenImageForGen12LpWhenClearColorParamete
EXPECT_EQ(0u, surfaceState.getClearColorAddress());
EXPECT_EQ(0u, surfaceState.getClearColorAddressHigh());
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelper<Image2dDefaults>::create(&context)));
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelperUlt<Image2dDefaults>::create(&context)));
auto gmm = imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm();
gmm->gmmResourceInfo->getResourceFlags()->Gpu.IndirectClearColor = 1;
EncodeSurfaceState<FamilyType>::setClearColorParams(&surfaceState, gmm);
@@ -98,7 +98,7 @@ GEN12LPTEST_F(ImageClearColorFixture, givenImageForGen12LpWhenCanonicalAddresFor
EXPECT_THROW(surfaceState.setClearColorAddressHigh(static_cast<uint32_t>(canonicalAddress >> 32)), std::exception);
surfaceState.setSurfaceBaseAddress(canonicalAddress);
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelper<Image2dDefaults>::create(&context)));
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelperUlt<Image2dDefaults>::create(&context)));
auto gmm = imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm();
gmm->gmmResourceInfo->getResourceFlags()->Gpu.IndirectClearColor = 1;
EXPECT_NO_THROW(EncodeSurfaceState<FamilyType>::setClearColorParams(&surfaceState, gmm));
@@ -119,7 +119,7 @@ GEN12LPTEST_F(ImageClearColorFixture, givenMcsAllocationWhenSetArgIsCalledWithUn
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(context.get(), &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(context.get(), &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
@@ -147,7 +147,7 @@ GEN12LPTEST_F(gen12LpImageTests, givenCompressionThenSurfaceStateParamsAreSetFor
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo->getResourceFlags()->Info.RenderCompressed = true;
@@ -162,7 +162,7 @@ GEN12LPTEST_F(gen12LpImageTests, givenNoCompressionWhenProgramingImageSurfaceSta
MockContext context;
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
surfaceState.setMemoryCompressionEnable(true);
surfaceState.setAuxiliarySurfaceMode(RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
@@ -179,7 +179,7 @@ GEN12LPTEST_F(gen12LpImageTests, givenMediaCompressionThenSurfaceStateParamsAreS
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo->getResourceFlags()->Info.MediaCompressed = true;

4
opencl/test/unit_test/helpers/base_object_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -264,7 +264,7 @@ TEST(CastToBuffer, WhenCastingFromMemObjThenBehavesAsExpected) {
TEST(CastToImage, WhenCastingFromMemObjThenBehavesAsExpected) {
MockContext context;
auto image = Image2dHelper<>::create(&context);
auto image = Image2dHelperUlt<>::create(&context);
MemObj *memObj = image;
cl_mem clObj = image;

4
opencl/test/unit_test/helpers/dispatch_info_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -157,7 +157,7 @@ TEST_F(DispatchInfoTest, WhenMultiDispatchInfoIsCreatedThenItIsEmpty) {
TEST_F(DispatchInfoTest, GivenRedescribedSurfacesWhenCreatingMultiDispatchInfoThenRedescribedSurfacesSizeisOne) {
MultiDispatchInfo multiDispatchInfo;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(pContext));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, image);
auto imageRedescribed = image->redescribe();

16
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@@ -65,9 +65,9 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, HardwareCommandsTest, WhenProgramInterfaceDescrip
GPGPU_WALKER walkerCmd{};
CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, srcImage.get());
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImageToImage3d,
@@ -142,9 +142,9 @@ HWTEST_F(HardwareCommandsTest, WhenCrossThreadDataIsCreatedThenOnlyRequiredSpace
using DefaultWalkerType = typename FamilyType::DefaultWalkerType;
CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, srcImage.get());
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImageToImage3d,
@@ -305,9 +305,9 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, HardwareCommandsTest, WhenAllocatingIndirectState
CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
std::unique_ptr<Image> srcImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> srcImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, srcImage.get());
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImageToImage3d,
@@ -496,7 +496,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, HardwareCommandsTest, whenSendingIndirectStateThe
CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
std::unique_ptr<Image> img(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> img(Image2dHelperUlt<>::create(pContext));
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyImageToImage3d,
cmdQ.getClDevice());
@@ -590,7 +590,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, HardwareCommandsTest, WhenSendingIndirectStateThe
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
std::unique_ptr<Image> dstImage(Image2dHelper<>::create(pContext));
std::unique_ptr<Image> dstImage(Image2dHelperUlt<>::create(pContext));
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::copyBufferToImage3d,

2
opencl/test/unit_test/kernel/clone_kernel_tests.cpp
View File

@@ -238,7 +238,7 @@ TEST_F(CloneKernelTest, givenArgImageWhenCloningKernelThenKernelInfoIsCorrect) {
metaPayload.imgHeight = 0x8;
metaPayload.imgDepth = 0xc;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context.get()));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context.get()));
ASSERT_NE(nullptr, image);
auto rootDeviceIndex = *context->getRootDeviceIndices().begin();

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

@@ -231,7 +231,7 @@ INSTANTIATE_TEST_SUITE_P(
TEST(ImageRedescribeTestSimple, givenImageWhenItIsRedescribedThenCreateFunctionIsSameAsInOriginalImage) {
MockContext context;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&context));
std::unique_ptr<Image> imageNew(image->redescribe());
ASSERT_NE(nullptr, imageNew);
EXPECT_EQ(image->createFunction, imageNew->createFunction);
@@ -239,7 +239,7 @@ TEST(ImageRedescribeTestSimple, givenImageWhenItIsRedescribedThenCreateFunctionI
TEST(ImageRedescribeTestSimple, givenImageWhenItIsRedescribedThenPlaneIsSameAsInOriginalImage) {
MockContext context;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&context));
image->setPlane(GMM_PLANE_U);
std::unique_ptr<Image> imageNew(image->redescribe());
ASSERT_NE(nullptr, imageNew);

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -54,7 +54,7 @@ class ImageUnmapTest : public ::testing::Test {
void SetUp() override {
device = std::make_unique<MockClDevice>(MockClDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
context = std::make_unique<MockContext>(device.get());
image.reset(ImageHelper<ImageReadOnly<Image3dDefaults>>::create(context.get()));
image.reset(ImageHelperUlt<ImageReadOnly<Image3dDefaults>>::create(context.get()));
}
std::unique_ptr<MockClDevice> device;
std::unique_ptr<MockContext> context;

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

@@ -86,7 +86,7 @@ class ImageSetArgTest : public ClDeviceFixture,
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcImage = Image3dHelperUlt<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
@@ -187,7 +187,7 @@ HWTEST_F(ImageSetArgTest, givenCubeMapIndexWhenSetKernelArgImageIsCalledThenModi
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
uint32_t cubeFaceIndex = 2;
Image *src2dImage = Image2dHelper<>::create(context);
Image *src2dImage = Image2dHelperUlt<>::create(context);
src2dImage->setCubeFaceIndex(cubeFaceIndex);
@@ -219,7 +219,7 @@ struct ImageSetArgSurfaceArrayTest : ImageSetArgTest {
cl_image_desc imageDesc = Image2dDefaults::imageDesc;
imageDesc.image_array_size = imageArraySize;
imageDesc.image_type = imageType;
std::unique_ptr<Image> image{Image2dHelper<>::create(context, &imageDesc)};
std::unique_ptr<Image> image{Image2dHelperUlt<>::create(context, &imageDesc)};
image->setCubeFaceIndex(__GMM_NO_CUBE_MAP);
image->setImageArg(&surfaceState, false, 0, pClDevice->getRootDeviceIndex());
@@ -417,7 +417,7 @@ HWTEST_F(ImageSetArgTest, givenImage2DWithMipMapsWhenSetKernelArgIsCalledThenMip
HWTEST_F(ImageSetArgTest, Given2dArrayWhenSettingKernelArgThenPropertiesAreSetCorrectly) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
Image *image2Darray = Image2dArrayHelper<>::create(context);
Image *image2Darray = Image2dArrayHelperUlt<>::create(context);
auto graphicsAllocation = image2Darray->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
cl_mem memObj = image2Darray;
@@ -465,7 +465,7 @@ HWTEST_F(ImageSetArgTest, Given2dArrayWhenSettingKernelArgThenPropertiesAreSetCo
HWTEST_F(ImageSetArgTest, Given1dArrayWhenSettingKernelArgThenPropertiesAreSetCorrectly) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
Image *image1Darray = Image1dArrayHelper<>::create(context);
Image *image1Darray = Image1dArrayHelperUlt<>::create(context);
auto graphicsAllocation = image1Darray->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
cl_mem memObj = image1Darray;
@@ -521,7 +521,7 @@ HWTEST2_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithoutUnifiedAux
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
auto image = Image2dHelper<>::create(context, &imgDesc);
auto image = Image2dHelperUlt<>::create(context, &imgDesc);
image->setMcsSurfaceInfo(msi);
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image;
@@ -560,7 +560,7 @@ HWTEST2_F(ImageSetArgTest, givenDepthFormatWhenSetArgIsCalledThenProgramAuxField
imgDesc.num_samples = 8;
cl_image_format imgFormat = {CL_DEPTH, CL_FLOAT};
auto image = Image2dHelper<>::create(context, &imgDesc, &imgFormat);
auto image = Image2dHelperUlt<>::create(context, &imgDesc, &imgFormat);
image->setMcsSurfaceInfo(msi);
cl_mem memObj = image;
@@ -596,7 +596,7 @@ HWTEST_F(ImageSetArgTest, givenMultisampledR32Floatx8x24DepthStencilFormatWhenSe
imgDesc.num_samples = 8;
cl_image_format imgFormat = {CL_DEPTH_STENCIL, CL_FLOAT};
std::unique_ptr<Image> image(ImageHelper<ImageReadOnly<Image2dDefaults>>::create(context, &imgDesc, &imgFormat));
std::unique_ptr<Image> image(ImageHelperUlt<ImageReadOnly<Image2dDefaults>>::create(context, &imgDesc, &imgFormat));
image->setMcsSurfaceInfo(msi);
cl_mem memObj = image.get();
@@ -623,7 +623,7 @@ HWTEST2_F(ImageSetArgTest, givenMcsAllocationAndCompressionWhenSetArgOnMultisamp
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context, &imgDesc));
auto graphicsAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
graphicsAllocation->getDefaultGmm()->setCompressionEnabled(true);
image->setMcsSurfaceInfo(msi);
@@ -654,7 +654,7 @@ HWTEST2_F(ImageSetArgTest, givenDepthFormatAndCompressionWhenSetArgOnMultisample
cl_image_format imgFormat = {CL_DEPTH, CL_FLOAT};
imgDesc.num_samples = 8;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc, &imgFormat));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context, &imgDesc, &imgFormat));
auto graphicsAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
graphicsAllocation->getDefaultGmm()->setCompressionEnabled(true);
image->setMcsSurfaceInfo(msi);
@@ -688,7 +688,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context, &imgDesc));
image->setMcsSurfaceInfo(msi);
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
@@ -722,7 +722,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context, &imgDesc));
image->setMcsSurfaceInfo(msi);
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
@@ -753,7 +753,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc));
auto image = std::unique_ptr<Image>(Image2dHelperUlt<>::create(context, &imgDesc));
image->setMcsSurfaceInfo(msi);
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
@@ -840,7 +840,7 @@ HWTEST_F(ImageSetArgTest, GivenImageFrom1dBufferWhenSettingKernelArgThenProperti
HWTEST_F(ImageSetArgTest, GivenImageWithClLuminanceFormatWhenSettingKernelArgThenPropertiesAreSetCorrectly) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
Image *luminanceImage = Image3dHelper<LuminanceImage>::create(context);
Image *luminanceImage = Image3dHelperUlt<LuminanceImage>::create(context);
cl_mem memObj = luminanceImage;
retVal = clSetKernelArg(
@@ -949,7 +949,7 @@ class ImageMediaBlockSetArgTest : public ImageSetArgTest {
pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
pKernel->setKernelArgHandler(1, &Kernel::setArgImage);
context = new MockContext(pClDevice);
srcImage = Image3dHelper<>::create(context);
srcImage = Image3dHelperUlt<>::create(context);
srcAllocation = srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
ASSERT_NE(nullptr, srcImage);
}
@@ -1137,7 +1137,7 @@ HWTEST_F(ImageShaderChannelValueTest, GivenChannelDepthWhenGettingShaderChannelV
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
cl_image_format imgFormat = {CL_DEPTH, CL_UNORM_INT16};
std::unique_ptr<Image> image(ImageHelper<ImageReadOnly<Image2dDefaults>>::create(context, &imgDesc, &imgFormat));
std::unique_ptr<Image> image(ImageHelperUlt<ImageReadOnly<Image2dDefaults>>::create(context, &imgDesc, &imgFormat));
image->setImageArg(&surfaceState, false, 0, pClDevice->getRootDeviceIndex());

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

@@ -917,7 +917,7 @@ TEST_F(ImageTransfer, GivenNonZeroCopyImageWhenDataTransferedFromHostPtrToMemSto
ModifyableImage::imageFormat.image_channel_data_type = CL_FLOAT;
ModifyableImage::hostPtr = unalignedHostPtr;
Image *imageNonZeroCopy = ImageHelper<ImageUseHostPtr<ModifyableImage>>::create();
Image *imageNonZeroCopy = ImageHelperUlt<ImageUseHostPtr<ModifyableImage>>::create();
ASSERT_NE(nullptr, imageNonZeroCopy);
@@ -953,7 +953,7 @@ TEST_F(ImageTransfer, GivenNonZeroCopyNonZeroRowPitchImageWhenDataIsTransferedFr
createHostPtrs(imageSize);
ModifyableImage::hostPtr = unalignedHostPtr;
Image *imageNonZeroCopy = ImageHelper<ImageUseHostPtr<ModifyableImage>>::create();
Image *imageNonZeroCopy = ImageHelperUlt<ImageUseHostPtr<ModifyableImage>>::create();
ASSERT_NE(nullptr, imageNonZeroCopy);
@@ -1009,7 +1009,7 @@ TEST_F(ImageTransfer, GivenNonZeroCopyNonZeroRowPitchWithExtraBytes1DArrayImageW
}
ModifyableImage::hostPtr = unalignedHostPtr;
Image *imageNonZeroCopy = ImageHelper<ImageUseHostPtr<ModifyableImage>>::create();
Image *imageNonZeroCopy = ImageHelperUlt<ImageUseHostPtr<ModifyableImage>>::create();
ASSERT_NE(nullptr, imageNonZeroCopy);
@@ -1205,7 +1205,7 @@ TEST_F(ImageCompressionTests, givenNonTiledImageAndVariousFlagsWhenCreatingAlloc
TEST(ImageTest, givenImageWhenGettingCompressionOfImageThenCorrectValueIsReturned) {
MockContext context;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&context));
EXPECT_NE(nullptr, image);
auto allocation = image->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex());
@@ -1241,7 +1241,7 @@ HWTEST_F(ImageTests, givenImageWhenAskedForPtrOffsetForGpuMappingThenReturnCorre
GTEST_SKIP();
}
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{4, 5, 6}};
@@ -1255,7 +1255,7 @@ HWTEST_F(ImageTests, givenImageWhenAskedForPtrOffsetForGpuMappingThenReturnCorre
TEST(ImageTest, givenImageWhenAskedForMcsInfoThenDefaultValuesAreReturned) {
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx));
auto mcsInfo = image->getMcsSurfaceInfo();
EXPECT_EQ(0u, mcsInfo.multisampleCount);
@@ -1267,7 +1267,7 @@ TEST(ImageTest, givenImageWhenAskedForPtrOffsetForCpuMappingThenReturnCorrectVal
DebugManagerStateRestore restore;
debugManager.flags.ForceLinearImages.set(true);
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx));
EXPECT_TRUE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{4, 5, 6}};
@@ -1282,7 +1282,7 @@ TEST(ImageTest, givenImageWhenAskedForPtrOffsetForCpuMappingThenReturnCorrectVal
TEST(ImageTest, given1DArrayImageWhenAskedForPtrOffsetForMappingThenReturnCorrectValue) {
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dArrayDefaults>::create(&ctx));
MemObjOffsetArray origin = {{4, 5, 0}};
@@ -1298,7 +1298,7 @@ HWTEST_F(ImageTests, givenImageWhenAskedForPtrLengthForGpuMappingThenReturnCorre
GTEST_SKIP();
}
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjSizeArray region = {{4, 5, 6}};
@@ -1314,7 +1314,7 @@ TEST(ImageTest, givenImageWhenAskedForPtrLengthForCpuMappingThenReturnCorrectVal
DebugManagerStateRestore restore;
debugManager.flags.ForceLinearImages.set(true);
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx));
EXPECT_TRUE(image->mappingOnCpuAllowed());
MemObjSizeArray region = {{4, 5, 6}};
@@ -1336,7 +1336,7 @@ TEST(ImageTest, givenMipMapImage3DWhenAskedForPtrOffsetForGpuMappingThenReturnOf
imageDesc.image_depth = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image3dDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin{{1, 1, 1}};
@@ -1357,7 +1357,7 @@ TEST(ImageTest, givenMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThenRet
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image2dArrayDefaults>::create(&ctx, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin{{1, 1, 1}};
@@ -1378,7 +1378,7 @@ TEST(ImageTest, givenNonMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThen
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 1;
std::unique_ptr<Image> image(ImageHelper<Image2dArrayDefaults>::create(&ctx, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image2dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin{{1, 1, 1}};
@@ -1398,7 +1398,7 @@ TEST(ImageTest, givenMipMapImage1DArrayWhenAskedForPtrOffsetForGpuMappingThenRet
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(&ctx, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin{{1, 1, 0}};
@@ -1502,7 +1502,7 @@ HWTEST_F(ImageDirectSubmissionTest, givenImageCreatedWhenDestrucedThenVerifyTask
imageDesc.image_width = 1;
imageDesc.image_height = 1;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&ctx, &imageDesc));
std::unique_ptr<Image> image(ImageHelperUlt<Image1dDefaults>::create(&ctx, &imageDesc));
EXPECT_NE(nullptr, image);
image->getGraphicsAllocation(0u)->setAllocationType(AllocationType::image);
image->getGraphicsAllocation(mockClDevice.getRootDeviceIndex())->updateTaskCount(taskCountReady, mockClDevice.getDefaultEngine().osContext->getContextId());
@@ -1681,7 +1681,7 @@ HWTEST_F(ImageTransformTest, givenSurfaceStateWhenTransformImage3dTo2dArrayIsCal
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(&context));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
surfaceState.setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D);
@@ -1695,7 +1695,7 @@ HWTEST_F(ImageTransformTest, givenSurfaceStateWhenTransformImage2dArrayTo3dIsCal
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(&context));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
surfaceState.setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D);
@@ -1707,7 +1707,7 @@ HWTEST_F(ImageTransformTest, givenSurfaceStateWhenTransformImage2dArrayTo3dIsCal
HWTEST_F(ImageTransformTest, givenSurfaceBaseAddressAndUnifiedSurfaceWhenSetUnifiedAuxAddressCalledThenAddressIsSet) {
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image3dDefaults>::create(&context));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
GmmRequirements gmmRequirements{};
gmmRequirements.allowLargePages = true;
@@ -1731,7 +1731,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image1dHelper<>::create(&context));
std::unique_ptr<Image> image(Image1dHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1741,7 +1741,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
}
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image1dArrayHelper<>::create(&context));
std::unique_ptr<Image> image(Image1dArrayHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1751,7 +1751,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
}
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image1dBufferHelper<>::create(&context));
std::unique_ptr<Image> image(Image1dBufferHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1761,7 +1761,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
}
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1771,7 +1771,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
}
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image2dArrayHelper<>::create(&context));
std::unique_ptr<Image> image(Image2dArrayHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1781,7 +1781,7 @@ TEST(ImageTest, givenImageWhenFillRegionIsCalledThenProperRegionIsSet) {
}
{
size_t region[3] = {};
std::unique_ptr<Image> image(Image3dHelper<>::create(&context));
std::unique_ptr<Image> image(Image3dHelperUlt<>::create(&context));
image->fillImageRegion(region);
@@ -1802,7 +1802,7 @@ TEST(ImageTest, givenMultiDeviceEnvironmentWhenReleaseImageFromBufferThenMainBuf
cl_mem clBuffer = buffer;
imageDesc.mem_object = clBuffer;
auto image = Image2dHelper<>::create(&context, &imageDesc);
auto image = Image2dHelperUlt<>::create(&context, &imageDesc);
EXPECT_EQ(3u, buffer->getMultiGraphicsAllocation().getGraphicsAllocations().size());
EXPECT_EQ(3u, image->getMultiGraphicsAllocation().getGraphicsAllocations().size());

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -21,7 +21,7 @@ struct ImageTestsTgllAndLater : ClDeviceFixture, testing::Test {
void SetUp() override {
ClDeviceFixture::setUp();
context = std::make_unique<MockContext>(pClDevice);
srcImage = std::unique_ptr<Image>(Image3dHelper<>::create(context.get()));
srcImage = std::unique_ptr<Image>(Image3dHelperUlt<>::create(context.get()));
}
void TearDown() override {

32
opencl/test/unit_test/mem_obj/image_tests_xehp_and_later.cpp
View File

@@ -37,7 +37,7 @@ using XeHPAndLaterImageTests = ::testing::Test;
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterImageTests, WhenAppendingSurfaceStateParamsThenDoNothing) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(&context));
auto surfaceStateBefore = FamilyType::cmdInitRenderSurfaceState;
auto surfaceStateAfter = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
@@ -53,7 +53,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterImageTests, givenCompressionEnabledWhen
MockContext context;
auto mockGmmClient = static_cast<MockGmmClientContext *>(context.getDevice(0)->getRootDeviceEnvironment().getGmmClientContext());
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
auto image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(&context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(&context));
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
mockGmmClient->capturedFormat = GMM_FORMAT_INVALID;
@@ -175,7 +175,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenMcsAllocationWhenSetArgIsCalledWithUnifie
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto pClDevice = context.getDevice(0);
@@ -214,7 +214,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenMcsAllocationWhenSetAuxParamsForMultisamp
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto pClDevice = context.getDevice(0);
@@ -248,7 +248,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenImageWithUnifiedMcsWhenSetAuxParamsForMul
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto pClDevice = context.getDevice(0);
@@ -273,7 +273,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenImageWithoutMcsWhenSetAuxParamsForMultisa
MockContext context;
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto pClDevice = context.getDevice(0);
@@ -291,7 +291,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenImageWithoutMcsWithDepthFormatWhenSetAuxP
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
cl_image_format imgFormat = {CL_DEPTH, CL_FLOAT};
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc, &imgFormat));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc, &imgFormat));
auto pClDevice = context.getDevice(0);
@@ -311,7 +311,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenImageWithoutMcsWithNotDepthFormatWhenSetA
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
cl_image_format imgFormat = {CL_RGBA, CL_FLOAT};
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc, &imgFormat));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc, &imgFormat));
auto pClDevice = context.getDevice(0);
@@ -331,7 +331,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenImageWithoutMcsWithTypelessSurfaceStateFo
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
cl_image_format imgFormat = {CL_DEPTH, CL_FLOAT};
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc, &imgFormat));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc, &imgFormat));
auto pClDevice = context.getDevice(0);
@@ -354,7 +354,7 @@ HWTEST2_F(ImageClearColorFixture, givenImageForXeHPAndLaterWhenClearColorParamet
EXPECT_EQ(0u, surfaceState.getClearColorAddress());
EXPECT_EQ(0u, surfaceState.getClearColorAddressHigh());
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelper<Image2dDefaults>::create(&context)));
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelperUlt<Image2dDefaults>::create(&context)));
auto gmm = imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm();
gmm->gmmResourceInfo->getResourceFlags()->Gpu.IndirectClearColor = 1;
EncodeSurfaceState<FamilyType>::setClearColorParams(&surfaceState, gmm);
@@ -395,7 +395,7 @@ HWTEST2_F(ImageClearColorFixture, givenImageForXeHPAndLaterWhenCanonicalAddresFo
EXPECT_THROW(surfaceState.setClearColorAddressHigh(static_cast<uint32_t>(canonicalAddress >> 32)), std::exception);
surfaceState.setSurfaceBaseAddress(canonicalAddress);
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelper<Image2dDefaults>::create(&context)));
std::unique_ptr<ImageHw<FamilyType>> imageHw(static_cast<ImageHw<FamilyType> *>(ImageHelperUlt<Image2dDefaults>::create(&context)));
auto gmm = imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm();
gmm->gmmResourceInfo->getResourceFlags()->Gpu.IndirectClearColor = 1;
@@ -413,7 +413,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenMediaCompressionWhenAppendingNewAllocatio
auto hwInfo = defaultHwInfo.get();
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
imageHw->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo->getResourceFlags()->Info.MediaCompressed = true;
@@ -440,7 +440,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenCompressionWhenAppendingNewAllocationThen
auto hwInfo = defaultHwInfo.get();
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
surfaceState.setAuxiliarySurfaceMode(RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
@@ -476,7 +476,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenNoCompressionWhenProgramingImageSurfaceSt
MockContext context;
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
surfaceState.setMemoryCompressionEnable(true);
surfaceState.setAuxiliarySurfaceMode(RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
@@ -491,7 +491,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenNoCompressionWhenProgramingImageSurfaceSt
struct XeHPAndLaterImageHelperTests : ::testing::Test {
void SetUp() override {
context = std::make_unique<MockContext>();
image.reset(ImageHelper<Image2dDefaults>::create(context.get()));
image.reset(ImageHelperUlt<Image2dDefaults>::create(context.get()));
mockGmmResourceInfo = static_cast<MockGmmResourceInfo *>(image->getGraphicsAllocation(context->getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo.get());
gmmClientContext = static_cast<MockGmmClientContext *>(context->getDevice(0)->getGmmHelper()->getClientContext());
}
@@ -609,7 +609,7 @@ HWTEST2_F(XeHPAndLaterImageTests, givenMcsAllocationWhenAuxCapableIsNotSetThenPr
cl_image_desc imgDesc = Image2dDefaults::imageDesc;
imgDesc.num_samples = 8;
std::unique_ptr<Image> image(Image2dHelper<>::create(&context, &imgDesc));
std::unique_ptr<Image> image(Image2dHelperUlt<>::create(&context, &imgDesc));
auto pClDevice = context.getDevice(0);

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -26,7 +26,7 @@ class ImageHostPtrTransferTests : public testing::Test {
template <typename ImageTraits>
void createImageAndSetTestParams() {
image.reset(ImageHelper<ImageUseHostPtr<ImageTraits>>::create(context.get()));
image.reset(ImageHelperUlt<ImageUseHostPtr<ImageTraits>>::create(context.get()));
imgDesc = &image->getImageDesc();

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

@@ -143,8 +143,8 @@ TEST(MemObjHelper, givenParentMemObjAndHostPtrFlagsWhenValidatingMemoryPropertie
MemoryProperties memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(flags, flagsIntel, 0, pDevice);
MockContext context{deviceFactory.rootDevices[0]};
auto image = clUniquePtr(Image1dHelper<>::create(&context));
auto imageWithAccessFlagsUnrestricted = clUniquePtr(ImageHelper<Image1dWithAccessFlagsUnrestricted>::create(&context));
auto image = clUniquePtr(Image1dHelperUlt<>::create(&context));
auto imageWithAccessFlagsUnrestricted = clUniquePtr(ImageHelperUlt<Image1dWithAccessFlagsUnrestricted>::create(&context));
cl_mem_flags hostPtrFlags[] = {CL_MEM_USE_HOST_PTR, CL_MEM_ALLOC_HOST_PTR, CL_MEM_COPY_HOST_PTR};

2
opencl/test/unit_test/mem_obj/nv12_image_tests.cpp
View File

@@ -391,7 +391,7 @@ HWTEST_F(Nv12ImageTest, givenNv12ImageArrayAndImageArraySizeIsZeroWhenCallingSet
cl_image_format imageFormat = Image2dDefaults::imageFormat;
imageFormat.image_channel_order = CL_NV12_INTEL;
imageFormat.image_channel_data_type = CL_UNORM_INT8;
std::unique_ptr<Image> image{Image2dHelper<>::create(&context, &imageDesc, &imageFormat)};
std::unique_ptr<Image> image{Image2dHelperUlt<>::create(&context, &imageDesc, &imageFormat)};
image->setCubeFaceIndex(__GMM_NO_CUBE_MAP);
image->setImageArg(&surfaceState, false, 0, context.getDevice(0)->getRootDeviceIndex());

14
opencl/test/unit_test/memory_manager/migraton_controller_tests.cpp
View File

@@ -46,7 +46,7 @@ struct MigrationControllerTests : public ::testing::Test {
};
HWTEST2_F(MigrationControllerTests, givenAllocationWithUndefinedLocationWhenHandleMigrationThenNoMigrationIsPerformedAndProperLocationIsSet, MatchAny) {
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
EXPECT_EQ(MigrationSyncData::locationUndefined, pImage->getMultiGraphicsAllocation().getMigrationSyncData()->getCurrentLocation());
@@ -59,7 +59,7 @@ HWTEST2_F(MigrationControllerTests, givenAllocationWithUndefinedLocationWhenHand
}
HWTEST2_F(MigrationControllerTests, givenAllocationWithDefinedLocationWhenHandleMigrationToTheSameLocationThenDontMigrateMemory, MatchAny) {
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
pImage->getMultiGraphicsAllocation().getMigrationSyncData()->setCurrentLocation(1);
@@ -74,7 +74,7 @@ HWTEST2_F(MigrationControllerTests, givenAllocationWithDefinedLocationWhenHandle
HWTEST2_F(MigrationControllerTests, givenNotLockableImageAllocationWithDefinedLocationWhenHandleMigrationToDifferentLocationThenMigrateMemoryViaReadWriteImage, MatchAny) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(&context);
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
EXPECT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
auto srcAllocation = pImage->getMultiGraphicsAllocation().getGraphicsAllocation(0);
@@ -165,7 +165,7 @@ HWTEST2_F(MigrationControllerTests, givenMultiGraphicsAllocationUsedInOneCsrWhen
return new MockMigrationSyncData(size);
};
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
ASSERT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
@@ -191,7 +191,7 @@ HWTEST2_F(MigrationControllerTests, givenMultiGraphicsAllocationUsedInOneCsrWhen
return new MockMigrationSyncData(size);
};
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
ASSERT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
@@ -220,7 +220,7 @@ HWTEST2_F(MigrationControllerTests, givenMultiGraphicsAllocationUsedInOneCsrWhen
return new MockMigrationSyncData(size);
};
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
ASSERT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());
@@ -247,7 +247,7 @@ HWTEST2_F(MigrationControllerTests, whenHandleMigrationThenProperTagAddressAndTa
return new MockMigrationSyncData(size);
};
std::unique_ptr<Image> pImage(Image1dHelper<>::create(&context));
std::unique_ptr<Image> pImage(Image1dHelperUlt<>::create(&context));
ASSERT_TRUE(pImage->getMultiGraphicsAllocation().requiresMigrations());

2
opencl/test/unit_test/mt_tests/command_queue/ioq_task_tests_mt.cpp
View File

@@ -200,7 +200,7 @@ TEST_F(IOQTaskTestsMt, GivenMultipleThreadsWhenMappingBufferThenEventsAreComplet
}
TEST_F(IOQTaskTestsMt, GivenMultipleThreadsWhenMappingImageThenEventsAreCompleted) {
auto image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context));
auto image = std::unique_ptr<Image>(ImageHelperUlt<Image1dDefaults>::create(context));
auto userEvent = clCreateUserEvent(pContext, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);

4
opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -274,7 +274,7 @@ HWTEST_F(SamplerSetArgTest, GivenNewSamplerObjectWhensSetKernelArgIsCalledThenDe
}
HWTEST_F(SamplerSetArgTest, GivenIncorrentSamplerObjectWhenSetKernelArgSamplerIsCalledThenLeaveRefcountAsIs) {
auto notSamplerObj = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context));
auto notSamplerObj = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context));
auto pNotSampler = castToObject<Image>(notSamplerObj.get());
auto refCountBefore = pNotSampler->getRefInternalCount();

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -112,7 +112,7 @@ TEST(castToSamplerTest, GivenGenericPointerWhichHoldsSamplerObjectWhenCastToSamp
TEST(castToSamplerTest, GivenGenericPointerWhichDoestNotHoldSamplerObjectWhenCastToSamplerIsCalledThenCastWithAFailure) {
auto context = std::make_unique<MockContext>();
auto notSamplerObj = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context.get()));
auto notSamplerObj = std::unique_ptr<Image>(ImageHelperUlt<Image2dDefaults>::create(context.get()));
void *ptr = notSamplerObj.get();
auto notSampler = castToObject<Sampler>(ptr);