From 0ad81024b7ac33ffcd01ae2b5c7fb32fcf061353 Mon Sep 17 00:00:00 2001 From: "Woloszyn, Wojciech" Date: Mon, 12 Mar 2018 16:32:08 +0100 Subject: [PATCH] Implement cl_khr_mipmap_image [1/n] - Add mipmap image handling for clEnqueueReadImage, clEnqueueWriteImage - Fix mipmap image handling for clCreateImage Change-Id: I42938a330b55c7e69a16c26dce3ab5d66f8a8938 --- runtime/built_ins/built_ins.cpp | 4 +- runtime/built_ins/built_ins.h | 3 + runtime/command_queue/enqueue_read_image.h | 4 + runtime/command_queue/enqueue_write_image.h | 5 ++ runtime/helpers/CMakeLists.txt | 1 + runtime/helpers/mipmap.h | 50 +++++++++++ runtime/helpers/surface_formats.h | 1 + runtime/kernel/kernel.cpp | 16 +++- runtime/kernel/kernel.h | 5 ++ runtime/mem_obj/image.cpp | 4 +- runtime/mem_obj/image.h | 8 +- runtime/mem_obj/image.inl | 5 +- .../windows/wddm_memory_manager.cpp | 2 +- .../api/cl_enqueue_fill_image_tests.cpp | 12 +-- .../enqueue_read_image_fixture.h | 6 +- .../enqueue_read_image_tests.cpp | 87 ++++++++++++++++++ .../enqueue_write_image_fixture.h | 6 +- .../enqueue_write_image_tests.cpp | 88 +++++++++++++++++++ unit_tests/helpers/CMakeLists.txt | 1 + unit_tests/helpers/mipmap_tests.cpp | 40 +++++++++ unit_tests/mem_obj/image_set_arg_tests.cpp | 25 +++--- unit_tests/mem_obj/nv12_image_tests.cpp | 4 +- .../linux/drm_memory_manager_tests.cpp | 12 +-- .../windows/wddm_memory_manager_tests.cpp | 12 +-- 24 files changed, 356 insertions(+), 45 deletions(-) create mode 100644 runtime/helpers/mipmap.h create mode 100644 unit_tests/helpers/mipmap_tests.cpp diff --git a/runtime/built_ins/built_ins.cpp b/runtime/built_ins/built_ins.cpp index 602ae623f3..fa921b6536 100644 --- a/runtime/built_ins/built_ins.cpp +++ b/runtime/built_ins/built_ins.cpp @@ -539,7 +539,7 @@ class BuiltInOp : public BuiltinDisp } // Set-up destination image - kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed); + kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed, operationParams.dstMipLevel); // Set-up srcOffset kernelNoSplit3DBuilder.setArg(2, static_cast(operationParams.srcOffset.x)); @@ -618,7 +618,7 @@ class BuiltInOp : public BuiltinDisp kernelNoSplit3DBuilder.setKernel(kernelBytes[bytesExponent]); // Set-up source image - kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed); + kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed, operationParams.srcMipLevel); // Set-up destination host ptr / buffer if (operationParams.dstPtr) { diff --git a/runtime/built_ins/built_ins.h b/runtime/built_ins/built_ins.h index 411ad9b2de..a97c82d3f5 100644 --- a/runtime/built_ins/built_ins.h +++ b/runtime/built_ins/built_ins.h @@ -249,6 +249,8 @@ class BuiltinDispatchInfoBuilder { size_t dstRowPitch = 0; size_t srcSlicePitch = 0; size_t dstSlicePitch = 0; + uint32_t srcMipLevel = 0; + uint32_t dstMipLevel = 0; }; BuiltinDispatchInfoBuilder(BuiltIns &kernelLib) : kernelsLib(kernelLib) {} @@ -259,6 +261,7 @@ class BuiltinDispatchInfoBuilder { virtual bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const { return false; } + virtual bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, Kernel *kernel, const uint32_t dim, const Vec3 &gws, const Vec3 &elws, const Vec3 &offset) const { return false; diff --git a/runtime/command_queue/enqueue_read_image.h b/runtime/command_queue/enqueue_read_image.h index 93d696f76d..d52b031327 100644 --- a/runtime/command_queue/enqueue_read_image.h +++ b/runtime/command_queue/enqueue_read_image.h @@ -29,6 +29,7 @@ #include "runtime/helpers/cache_policy.h" #include "runtime/helpers/kernel_commands.h" #include "runtime/helpers/basic_math.h" +#include "runtime/helpers/mipmap.h" #include "runtime/mem_obj/image.h" #include "runtime/memory_manager/surface.h" #include @@ -108,6 +109,9 @@ cl_int CommandQueueHw::enqueueReadImage( dc.size = region; dc.srcRowPitch = inputRowPitch; dc.srcSlicePitch = inputSlicePitch; + if (srcImage->getImageDesc().num_mip_levels > 0) { + dc.srcMipLevel = findMipLevel(srcImage->getImageDesc().image_type, origin); + } builder.buildDispatchInfos(di, dc); enqueueHandler( diff --git a/runtime/command_queue/enqueue_write_image.h b/runtime/command_queue/enqueue_write_image.h index 9b8e0c5fbb..48fc480879 100644 --- a/runtime/command_queue/enqueue_write_image.h +++ b/runtime/command_queue/enqueue_write_image.h @@ -28,6 +28,7 @@ #include "runtime/helpers/surface_formats.h" #include "runtime/helpers/kernel_commands.h" #include "runtime/helpers/basic_math.h" +#include "runtime/helpers/mipmap.h" #include "runtime/mem_obj/image.h" #include #include @@ -105,6 +106,10 @@ cl_int CommandQueueHw::enqueueWriteImage( dc.size = region; dc.dstRowPitch = inputRowPitch; dc.dstSlicePitch = inputSlicePitch; + if (dstImage->getImageDesc().num_mip_levels > 0) { + dc.dstMipLevel = findMipLevel(dstImage->getImageDesc().image_type, origin); + } + builder.buildDispatchInfos(di, dc); enqueueHandler( diff --git a/runtime/helpers/CMakeLists.txt b/runtime/helpers/CMakeLists.txt index 02c1994db0..832798e1b8 100644 --- a/runtime/helpers/CMakeLists.txt +++ b/runtime/helpers/CMakeLists.txt @@ -53,6 +53,7 @@ set(RUNTIME_SRCS_HELPERS_BASE ${CMAKE_CURRENT_SOURCE_DIR}/hw_info.h ${CMAKE_CURRENT_SOURCE_DIR}/kernel_commands.h ${CMAKE_CURRENT_SOURCE_DIR}/kernel_commands.inl + ${CMAKE_CURRENT_SOURCE_DIR}/mipmap.h ${CMAKE_CURRENT_SOURCE_DIR}/options.cpp ${CMAKE_CURRENT_SOURCE_DIR}/options.h ${CMAKE_CURRENT_SOURCE_DIR}/per_thread_data.cpp diff --git a/runtime/helpers/mipmap.h b/runtime/helpers/mipmap.h new file mode 100644 index 0000000000..e5aa11b604 --- /dev/null +++ b/runtime/helpers/mipmap.h @@ -0,0 +1,50 @@ +/* +* Copyright (c) 2018, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +*/ + +#pragma once +#include +#include "CL/cl.h" + +namespace OCLRT { + +inline uint32_t findMipLevel(cl_mem_object_type imageType, const size_t *origin) { + size_t mipLevel = 0; + switch (imageType) { + case CL_MEM_OBJECT_IMAGE1D: + mipLevel = origin[1]; + break; + case CL_MEM_OBJECT_IMAGE1D_ARRAY: + case CL_MEM_OBJECT_IMAGE2D: + mipLevel = origin[2]; + break; + case CL_MEM_OBJECT_IMAGE2D_ARRAY: + case CL_MEM_OBJECT_IMAGE3D: + mipLevel = origin[3]; + break; + default: + mipLevel = 0; + } + + return static_cast(mipLevel); +} + +} // namespace OCLRT diff --git a/runtime/helpers/surface_formats.h b/runtime/helpers/surface_formats.h index 125e787db9..65d315f327 100644 --- a/runtime/helpers/surface_formats.h +++ b/runtime/helpers/surface_formats.h @@ -225,6 +225,7 @@ struct ImageInfo { uint32_t yOffsetForUVPlane; GMM_YUV_PLANE_ENUM plane; int mipLevel; + uint32_t mipCount; bool preferRenderCompression; }; diff --git a/runtime/kernel/kernel.cpp b/runtime/kernel/kernel.cpp index 5dc6b248f8..7adf50fcef 100644 --- a/runtime/kernel/kernel.cpp +++ b/runtime/kernel/kernel.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Intel Corporation + * Copyright (c) 2018, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -785,6 +785,10 @@ cl_int Kernel::setArg(uint32_t argIndex, cl_mem argVal) { return setArg(argIndex, sizeof(argVal), &argVal); } +cl_int Kernel::setArg(uint32_t argIndex, cl_mem argVal, uint32_t mipLevel) { + return setArgImageWithMipLevel(argIndex, sizeof(argVal), &argVal, mipLevel); +} + void *Kernel::patchBufferOffset(const KernelArgInfo &argInfo, void *svmPtr, GraphicsAllocation *svmAlloc) { if (isInvalidOffset(argInfo.offsetBufferOffset)) { return svmPtr; @@ -1164,6 +1168,12 @@ cl_int Kernel::setArgPipe(uint32_t argIndex, cl_int Kernel::setArgImage(uint32_t argIndex, size_t argSize, const void *argVal) { + return setArgImageWithMipLevel(argIndex, argSize, argVal, 0u); +} + +cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex, + size_t argSize, + const void *argVal, uint32_t mipLevel) { auto retVal = CL_INVALID_ARG_VALUE; patchBufferOffset(kernelInfo.kernelArgInfo[argIndex], nullptr, nullptr); @@ -1187,10 +1197,8 @@ cl_int Kernel::setArgImage(uint32_t argIndex, if (kernelArgInfo.isMediaImage) { DEBUG_BREAK_IF(!kernelInfo.isVmeWorkload); pImage->setMediaImageArg(const_cast(surfaceState)); - } else if (kernelArgInfo.isMediaBlockImage) { - pImage->setImageArg(const_cast(surfaceState), true); } else { - pImage->setImageArg(const_cast(surfaceState), false); + pImage->setImageArg(const_cast(surfaceState), kernelArgInfo.isMediaBlockImage, mipLevel); } auto crossThreadData = reinterpret_cast(getCrossThreadData()); diff --git a/runtime/kernel/kernel.h b/runtime/kernel/kernel.h index ad2954f355..b184efd2ec 100644 --- a/runtime/kernel/kernel.h +++ b/runtime/kernel/kernel.h @@ -229,6 +229,7 @@ class Kernel : public BaseObject<_cl_kernel> { // Helpers cl_int setArg(uint32_t argIndex, uint32_t argValue); cl_int setArg(uint32_t argIndex, cl_mem argValue); + cl_int setArg(uint32_t argIndex, cl_mem argValue, uint32_t mipLevel); // Handlers void setKernelArgHandler(uint32_t argIndex, KernelArgHandler handler); @@ -251,6 +252,10 @@ class Kernel : public BaseObject<_cl_kernel> { size_t argSize, const void *argVal); + cl_int setArgImageWithMipLevel(uint32_t argIndex, + size_t argSize, + const void *argVal, uint32_t mipLevel); + cl_int setArgLocal(uint32_t argIndex, size_t argSize, const void *argVal); diff --git a/runtime/mem_obj/image.cpp b/runtime/mem_obj/image.cpp index 0d66819c1a..c7b821c036 100644 --- a/runtime/mem_obj/image.cpp +++ b/runtime/mem_obj/image.cpp @@ -144,7 +144,7 @@ Image *Image::create(Context *context, imgInfo.imgDesc = &imageDescriptor; imgInfo.surfaceFormat = surfaceFormat; - imgInfo.mipLevel = imageDesc->num_mip_levels; + imgInfo.mipCount = imageDesc->num_mip_levels; Gmm *gmm = nullptr; if (imageDesc->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY || imageDesc->image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY) { @@ -325,7 +325,7 @@ Image *Image::create(Context *context, image->setImageSlicePitch(imgInfo.slicePitch); image->setQPitch(imgInfo.qPitch); image->setSurfaceOffsets(imgInfo.offset, imgInfo.xOffset, imgInfo.yOffset, imgInfo.yOffsetForUVPlane); - image->setMipLevel(imgInfo.mipLevel); + image->setMipCount(imgInfo.mipCount); if (parentImage) { image->setMediaPlaneType(static_cast(imageDesc->image_depth)); image->setParentSharingHandler(parentImage->getSharingHandler()); diff --git a/runtime/mem_obj/image.h b/runtime/mem_obj/image.h index 5626ab58a3..917c121a80 100644 --- a/runtime/mem_obj/image.h +++ b/runtime/mem_obj/image.h @@ -124,7 +124,7 @@ class Image : public MemObj { void *paramValue, size_t *paramValueSizeRet); - virtual void setImageArg(void *memory, bool isMediaBlockImage) = 0; + virtual void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel) = 0; virtual void setMediaImageArg(void *memory) = 0; virtual void setMediaSurfaceRotation(void *memory) = 0; virtual void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) = 0; @@ -166,6 +166,9 @@ class Image : public MemObj { int peekMipLevel() { return mipLevel; } void setMipLevel(int mipLevelNew) { this->mipLevel = mipLevelNew; } + uint32_t peekMipCount() { return mipCount; } + void setMipCount(uint32_t mipCountNew) { this->mipCount = mipCountNew; } + static const SurfaceFormatInfo *getSurfaceFormatFromTable(cl_mem_flags flags, const cl_image_format *imageFormat); static bool validateRegionAndOrigin(const size_t *origin, const size_t *region, const cl_mem_object_type &imgType); @@ -209,6 +212,7 @@ class Image : public MemObj { cl_uint mediaPlaneType; SurfaceOffsets surfaceOffsets; int mipLevel = 0; + uint32_t mipCount = 0; static bool isValidSingleChannelFormat(const cl_image_format *imageFormat); static bool isValidIntensityFormat(const cl_image_format *imageFormat); @@ -254,7 +258,7 @@ class ImageHw : public Image { } } - void setImageArg(void *memory, bool setAsMediaBlockImage) override; + void setImageArg(void *memory, bool setAsMediaBlockImage, uint32_t mipLevel) override; void setAuxParamsForMultisamples(RENDER_SURFACE_STATE *surfaceState); void setAuxParamsForCCS(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm); void setMediaImageArg(void *memory) override; diff --git a/runtime/mem_obj/image.inl b/runtime/mem_obj/image.inl index 1bb3e82aa5..7833071167 100644 --- a/runtime/mem_obj/image.inl +++ b/runtime/mem_obj/image.inl @@ -39,7 +39,7 @@ union SURFACE_STATE_BUFFER_LENGTH { }; template -void ImageHw::setImageArg(void *memory, bool setAsMediaBlockImage) { +void ImageHw::setImageArg(void *memory, bool setAsMediaBlockImage, uint32_t mipLevel) { using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT; auto surfaceState = reinterpret_cast(memory); auto gmm = getGraphicsAllocation()->gmm; @@ -109,7 +109,8 @@ void ImageHw::setImageArg(void *memory, bool setAsMediaBlockImage) { surfaceState->setSurfaceBaseAddress(getGraphicsAllocation()->getGpuAddress() + this->surfaceOffsets.offset); surfaceState->setRenderTargetViewExtent(renderTargetViewExtent); surfaceState->setMinimumArrayElement(minimumArrayElement); - surfaceState->setSurfaceMinLod(this->mipLevel); + surfaceState->setSurfaceMinLod(this->mipLevel + mipLevel); + surfaceState->setMipCountLod(this->mipCount - 1); // SurfaceQpitch is in rows but must be a multiple of VALIGN surfaceState->setSurfaceQpitch(qPitch); diff --git a/runtime/os_interface/windows/wddm_memory_manager.cpp b/runtime/os_interface/windows/wddm_memory_manager.cpp index af5536f951..b5583e7ba1 100644 --- a/runtime/os_interface/windows/wddm_memory_manager.cpp +++ b/runtime/os_interface/windows/wddm_memory_manager.cpp @@ -66,7 +66,7 @@ void APIENTRY WddmMemoryManager::trimCallback(_Inout_ D3DKMT_TRIMNOTIFICATION *t } GraphicsAllocation *WddmMemoryManager::allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) { - if (!Gmm::allowTiling(*imgInfo.imgDesc) && imgInfo.mipLevel == 0) { + if (!Gmm::allowTiling(*imgInfo.imgDesc) && imgInfo.mipCount == 0) { delete gmm; return allocateGraphicsMemory(imgInfo.size, MemoryConstants::preferredAlignment); } diff --git a/unit_tests/api/cl_enqueue_fill_image_tests.cpp b/unit_tests/api/cl_enqueue_fill_image_tests.cpp index 7dc34e48cd..32b6e751a8 100644 --- a/unit_tests/api/cl_enqueue_fill_image_tests.cpp +++ b/unit_tests/api/cl_enqueue_fill_image_tests.cpp @@ -34,8 +34,8 @@ namespace ULT { TEST_F(clEnqueueFillImageTests, nullCommandQueueReturnsError) { auto image = std::unique_ptr(Image2dHelper>::create(pContext)); uint32_t fill_color[4] = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd}; - size_t origin[4] = {0, 0, 0, 0}; - size_t region[4] = {2, 2, 1, 0}; + size_t origin[3] = {0, 0, 0}; + size_t region[3] = {2, 2, 1}; retVal = clEnqueueFillImage( nullptr, @@ -52,8 +52,8 @@ TEST_F(clEnqueueFillImageTests, nullCommandQueueReturnsError) { TEST_F(clEnqueueFillImageTests, nullImageReturnsError) { uint32_t fill_color[4] = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd}; - size_t origin[4] = {0, 0, 0, 0}; - size_t region[4] = {2, 2, 1, 0}; + size_t origin[3] = {0, 0, 0}; + size_t region[3] = {2, 2, 1}; retVal = clEnqueueFillImage( pCommandQueue, @@ -70,8 +70,8 @@ TEST_F(clEnqueueFillImageTests, nullImageReturnsError) { TEST_F(clEnqueueFillImageTests, nullFillColorReturnsError) { auto image = std::unique_ptr(Image2dHelper>::create(pContext)); - size_t origin[4] = {0, 0, 0, 0}; - size_t region[4] = {2, 2, 1, 0}; + size_t origin[3] = {0, 0, 0}; + size_t region[3] = {2, 2, 1}; retVal = clEnqueueFillImage( pCommandQueue, diff --git a/unit_tests/command_queue/enqueue_read_image_fixture.h b/unit_tests/command_queue/enqueue_read_image_fixture.h index d8aa610535..7a937cd347 100644 --- a/unit_tests/command_queue/enqueue_read_image_fixture.h +++ b/unit_tests/command_queue/enqueue_read_image_fixture.h @@ -69,4 +69,8 @@ struct EnqueueReadImageTest : public CommandEnqueueFixture, Image *srcImage; MockContext *context; }; -} + +struct EnqueueReadImageMipMapTest : public EnqueueReadImageTest, + public ::testing::WithParamInterface { +}; +} // namespace OCLRT diff --git a/unit_tests/command_queue/enqueue_read_image_tests.cpp b/unit_tests/command_queue/enqueue_read_image_tests.cpp index de27e16640..3ca737e95d 100644 --- a/unit_tests/command_queue/enqueue_read_image_tests.cpp +++ b/unit_tests/command_queue/enqueue_read_image_tests.cpp @@ -23,6 +23,7 @@ #include "runtime/gen_common/reg_configs.h" #include "unit_tests/command_queue/enqueue_read_image_fixture.h" #include "test.h" +#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h" using namespace OCLRT; @@ -589,6 +590,92 @@ HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorag EXPECT_EQ(pCmdQ->taskLevel, 2u); } +typedef EnqueueReadImageMipMapTest MipMapReadImageTest; + +HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) { + auto image_type = (cl_mem_object_type)GetParam(); + auto &origBuilder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyImage3dToBuffer, + pCmdQ->getContext(), + pCmdQ->getDevice()); + + // substitute original builder with mock builder + auto oldBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyImage3dToBuffer, + pCmdQ->getContext(), + pCmdQ->getDevice(), + std::unique_ptr(new MockBuiltinDispatchInfoBuilder(BuiltIns::getInstance(), &origBuilder))); + + cl_int retVal = CL_SUCCESS; + cl_image_desc imageDesc = {}; + uint32_t expectedMipLevel = 3; + imageDesc.image_type = image_type; + imageDesc.num_mip_levels = 10; + imageDesc.image_width = 4; + imageDesc.image_height = 1; + imageDesc.image_depth = 1; + size_t origin[] = {0, 0, 0, 0}; + size_t region[] = {imageDesc.image_width, 1, 1}; + std::unique_ptr image; + switch (image_type) { + case CL_MEM_OBJECT_IMAGE1D: + origin[1] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE1D_ARRAY: + imageDesc.image_array_size = 2; + origin[2] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE2D: + origin[2] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE2D_ARRAY: + imageDesc.image_array_size = 2; + origin[3] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE3D: + origin[3] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + } + EXPECT_NE(nullptr, image.get()); + + std::unique_ptr ptr = std::unique_ptr(new uint32_t[3]); + retVal = pCmdQ->enqueueReadImage(image.get(), + CL_FALSE, + origin, + region, + 0, + 0, + ptr.get(), + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + auto &mockBuilder = static_cast(BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer, + pCmdQ->getContext(), + pCmdQ->getDevice())); + auto params = mockBuilder.getBuiltinOpParams(); + + EXPECT_EQ(expectedMipLevel, params->srcMipLevel); + + // restore original builder and retrieve mock builder + auto newBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyImage3dToBuffer, + pCmdQ->getContext(), + pCmdQ->getDevice(), + std::move(oldBuilder)); + EXPECT_NE(nullptr, newBuilder); +} + +INSTANTIATE_TEST_CASE_P(MipMapReadImageTest_GivenImageWithMipLevelNonZeroWhenWriteImageIsCalledThenProperMipLevelIsSet, + MipMapReadImageTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D)); + using NegativeFailAllocationTest = Test; HWTEST_F(NegativeFailAllocationTest, givenEnqueueWriteImageWhenHostPtrAllocationCreationFailsThenReturnOutOfResource) { diff --git a/unit_tests/command_queue/enqueue_write_image_fixture.h b/unit_tests/command_queue/enqueue_write_image_fixture.h index f8ad120aef..c861c42877 100644 --- a/unit_tests/command_queue/enqueue_write_image_fixture.h +++ b/unit_tests/command_queue/enqueue_write_image_fixture.h @@ -69,4 +69,8 @@ struct EnqueueWriteImageTest : public CommandEnqueueFixture, Image *dstImage; MockContext *context; }; -} + +struct EnqueueWriteImageMipMapTest : public EnqueueWriteImageTest, + public ::testing::WithParamInterface { +}; +} // namespace OCLRT diff --git a/unit_tests/command_queue/enqueue_write_image_tests.cpp b/unit_tests/command_queue/enqueue_write_image_tests.cpp index 525b3b64d6..0e5e2be08f 100644 --- a/unit_tests/command_queue/enqueue_write_image_tests.cpp +++ b/unit_tests/command_queue/enqueue_write_image_tests.cpp @@ -24,6 +24,7 @@ #include "runtime/memory_manager/memory_manager.h" #include "test.h" #include "runtime/gen_common/reg_configs.h" +#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h" using namespace OCLRT; @@ -547,6 +548,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage3DAndImageShareTheSameStorageWithHostP pEvent->release(); } + HWTEST_F(EnqueueWriteImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsWritten) { cl_int retVal = CL_SUCCESS; std::unique_ptr dstImage2(ImageHelper>::create(context)); @@ -574,6 +576,92 @@ HWTEST_F(EnqueueWriteImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStora EXPECT_EQ(pCmdQ->taskLevel, 2u); } +typedef EnqueueWriteImageMipMapTest MipMapWriteImageTest; + +HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) { + auto image_type = (cl_mem_object_type)GetParam(); + auto &origBuilder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyBufferToImage3d, + pCmdQ->getContext(), + pCmdQ->getDevice()); + + // substitute original builder with mock builder + auto oldBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyBufferToImage3d, + pCmdQ->getContext(), + pCmdQ->getDevice(), + std::unique_ptr(new MockBuiltinDispatchInfoBuilder(BuiltIns::getInstance(), &origBuilder))); + + cl_int retVal = CL_SUCCESS; + cl_image_desc imageDesc = {}; + uint32_t expectedMipLevel = 3; + imageDesc.image_type = image_type; + imageDesc.num_mip_levels = 10; + imageDesc.image_width = 4; + imageDesc.image_height = 1; + imageDesc.image_depth = 1; + size_t origin[] = {0, 0, 0, 0}; + size_t region[] = {imageDesc.image_width, 1, 1}; + std::unique_ptr image; + switch (image_type) { + case CL_MEM_OBJECT_IMAGE1D: + origin[1] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE1D_ARRAY: + imageDesc.image_array_size = 2; + origin[2] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE2D: + origin[2] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE2D_ARRAY: + imageDesc.image_array_size = 2; + origin[3] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + case CL_MEM_OBJECT_IMAGE3D: + origin[3] = expectedMipLevel; + image = std::unique_ptr(ImageHelper::create(context, &imageDesc)); + break; + } + EXPECT_NE(nullptr, image.get()); + + std::unique_ptr ptr = std::unique_ptr(new uint32_t[3]); + retVal = pCmdQ->enqueueWriteImage(image.get(), + CL_FALSE, + origin, + region, + 0, + 0, + ptr.get(), + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); + + auto &mockBuilder = static_cast(BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d, + pCmdQ->getContext(), + pCmdQ->getDevice())); + auto params = mockBuilder.getBuiltinOpParams(); + + EXPECT_EQ(expectedMipLevel, params->dstMipLevel); + + // restore original builder and retrieve mock builder + auto newBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder( + EBuiltInOps::CopyBufferToImage3d, + pCmdQ->getContext(), + pCmdQ->getDevice(), + std::move(oldBuilder)); + EXPECT_NE(nullptr, newBuilder); +} + +INSTANTIATE_TEST_CASE_P(MipMapWriteImageTest_GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet, + MipMapWriteImageTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D)); + using NegativeFailAllocationTest = Test; HWTEST_F(NegativeFailAllocationTest, givenEnqueueReadImageWhenHostPtrAllocationCreationFailsThenReturnOutOfResource) { diff --git a/unit_tests/helpers/CMakeLists.txt b/unit_tests/helpers/CMakeLists.txt index d16f256e1f..9dd494c5b0 100644 --- a/unit_tests/helpers/CMakeLists.txt +++ b/unit_tests/helpers/CMakeLists.txt @@ -42,6 +42,7 @@ set(IGDRCL_SRCS_tests_helpers ${CMAKE_CURRENT_SOURCE_DIR}/kernel_binary_helper.h ${CMAKE_CURRENT_SOURCE_DIR}/kernel_commands_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/memory_management_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/mipmap_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/per_thread_data_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/ptr_math_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/queue_helpers_tests.cpp diff --git a/unit_tests/helpers/mipmap_tests.cpp b/unit_tests/helpers/mipmap_tests.cpp new file mode 100644 index 0000000000..13725152d2 --- /dev/null +++ b/unit_tests/helpers/mipmap_tests.cpp @@ -0,0 +1,40 @@ +/* +* Copyright (c) 2018, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "CL/cl.h" +#include "runtime/helpers/mipmap.h" +#include "gtest/gtest.h" + +using namespace OCLRT; + +typedef ::testing::TestWithParam> mipLevels; + +const size_t expectedOrigin[] = {1, 2, 3, 4}; + +TEST_P(mipLevels, givenImageTypeReturnProperMipLevel) { + auto pair = GetParam(); + EXPECT_EQ(pair.first, findMipLevel(pair.second, expectedOrigin)); +} + +INSTANTIATE_TEST_CASE_P(PatternType, + mipLevels, + ::testing::Values(std::make_pair(expectedOrigin[1], CL_MEM_OBJECT_IMAGE1D), std::make_pair(expectedOrigin[2], CL_MEM_OBJECT_IMAGE1D_ARRAY), std::make_pair(expectedOrigin[2], CL_MEM_OBJECT_IMAGE2D), std::make_pair(expectedOrigin[3], CL_MEM_OBJECT_IMAGE2D_ARRAY), std::make_pair(expectedOrigin[3], CL_MEM_OBJECT_IMAGE3D), std::make_pair(0u, 0u))); diff --git a/unit_tests/mem_obj/image_set_arg_tests.cpp b/unit_tests/mem_obj/image_set_arg_tests.cpp index 9dece18ec7..00c7b98eb1 100644 --- a/unit_tests/mem_obj/image_set_arg_tests.cpp +++ b/unit_tests/mem_obj/image_set_arg_tests.cpp @@ -136,7 +136,7 @@ HWTEST_F(ImageSetArgTest, setKernelArgImage) { ptrOffset(pKernel->getSurfaceStateHeap(), pKernelInfo->kernelArgInfo[0].offsetHeap)); - srcImage->setImageArg(const_cast(surfaceState), false); + srcImage->setImageArg(const_cast(surfaceState), false, 0); void *surfaceAddress = reinterpret_cast(surfaceState->getSurfaceBaseAddress()); EXPECT_EQ(srcImage->getCpuAddress(), surfaceAddress); @@ -151,7 +151,7 @@ HWTEST_F(ImageSetArgTest, setKernelArgImageUsingMediaBlockImage) { RENDER_SURFACE_STATE surfaceState; - srcImage->setImageArg(&surfaceState, true); + srcImage->setImageArg(&surfaceState, true, 0); auto computedWidth = surfaceState.getWidth(); auto expectedWidth = (srcImage->getImageDesc().image_width * srcImage->getSurfaceFormatInfo().ImageElementSizeInBytes) / sizeof(uint32_t); @@ -164,7 +164,7 @@ HWTEST_F(ImageSetArgTest, setKernelArgImageUsingNormalImage) { RENDER_SURFACE_STATE surfaceState; - srcImage->setImageArg(&surfaceState, true); + srcImage->setImageArg(&surfaceState, true, 0); auto computedWidth = surfaceState.getWidth(); @@ -183,7 +183,7 @@ HWTEST_F(ImageSetArgTest, givenCubeMapIndexWhenSetKernelArgImageIsCalledThenModi ptrOffset(pKernel->getSurfaceStateHeap(), pKernelInfo->kernelArgInfo[0].offsetHeap)); - src2dImage->setImageArg(const_cast(surfaceState), false); + src2dImage->setImageArg(const_cast(surfaceState), false, 0); auto renderTargetViewExtent = surfaceState->getRenderTargetViewExtent(); auto minimumArrayElement = surfaceState->getMinimumArrayElement(); @@ -206,7 +206,7 @@ HWTEST_F(ImageSetArgTest, givenNonCubeMapIndexWhenSetKernelArgImageIsCalledThenD pKernelInfo->kernelArgInfo[0].offsetHeap)); EXPECT_EQ(srcImage->getCubeFaceIndex(), __GMM_NO_CUBE_MAP); - srcImage->setImageArg(const_cast(surfaceState), false); + srcImage->setImageArg(const_cast(surfaceState), false, 0); auto renderTargetViewExtent = surfaceState->getRenderTargetViewExtent(); auto minimumArrayElement = surfaceState->getMinimumArrayElement(); @@ -237,7 +237,7 @@ HWTEST_F(ImageSetArgTest, givenOffsetedBufferWhenSetKernelArgImageIscalledThenFu auto graphicsAllocation = srcImage->getGraphicsAllocation(); graphicsAllocation->gpuBaseAddress = 12345u; - srcImage->setImageArg(const_cast(surfaceState), false); + srcImage->setImageArg(const_cast(surfaceState), false, 0); void *surfaceAddress = reinterpret_cast(surfaceState->getSurfaceBaseAddress()); EXPECT_EQ(srcImage->getCpuAddress(), surfaceAddress); @@ -292,11 +292,15 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage) { } } -HWTEST_F(ImageSetArgTest, givenImage2DWithMipmapsWhenSetKernelArgIsCalledThenMipLevelIsSet) { +HWTEST_F(ImageSetArgTest, givenImage2DWithMipMapsWhenSetKernelArgIsCalledThenMipLevelAndMipCounttIsSet) { typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE; cl_mem memObj = srcImage; - int mipLevel = 1; + int mipLevel = 2; + uint32_t mipCount = 3; srcImage->setMipLevel(mipLevel); + srcImage->setMipCount(mipCount); + EXPECT_EQ(mipLevel, srcImage->peekMipLevel()); + EXPECT_EQ(3u, srcImage->peekMipCount()); retVal = clSetKernelArg( pKernel, @@ -309,6 +313,7 @@ HWTEST_F(ImageSetArgTest, givenImage2DWithMipmapsWhenSetKernelArgIsCalledThenMip ptrOffset(pKernel->getSurfaceStateHeap(), pKernelInfo->kernelArgInfo[0].offsetHeap)); EXPECT_EQ((uint32_t)mipLevel, surfaceState->getSurfaceMinLod()); + EXPECT_EQ((uint32_t)mipCount, surfaceState->getMipCountLod() + 1); } HWTEST_F(ImageSetArgTest, clSetKernelArgImage2Darray) { @@ -694,7 +699,7 @@ HWTEST_F(ImageSetArgTest, givenRenderCompressedResourceWhenSettingImgArgThenSetC EXPECT_CALL(*mockGmmResInfo, getAuxQPitch()).Times(1).WillRepeatedly(Return(expectedAuxQPitch)); EXPECT_CALL(*mockGmmResInfo, getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_CCS)).Times(1).WillRepeatedly(Return(expectedAuxSurfaceOffset)); - srcImage->setImageArg(&surfaceState, false); + srcImage->setImageArg(&surfaceState, false, 0); EXPECT_TRUE(surfaceState.getAuxiliarySurfaceMode() == (typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE)5); EXPECT_EQ(expectedRenderAuxPitchTiles, surfaceState.getAuxiliarySurfacePitch()); @@ -715,7 +720,7 @@ HWTEST_F(ImageSetArgTest, givenNonRenderCompressedResourceWhenSettingImgArgThenD EXPECT_CALL(*mockGmmResInfo, getAuxQPitch()).Times(0); EXPECT_CALL(*mockGmmResInfo, getUnifiedAuxSurfaceOffset(_)).Times(0); - srcImage->setImageArg(&surfaceState, false); + srcImage->setImageArg(&surfaceState, false, 0); EXPECT_TRUE(surfaceState.getAuxiliarySurfaceMode() == AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE); EXPECT_EQ(1u, surfaceState.getAuxiliarySurfacePitch()); diff --git a/unit_tests/mem_obj/nv12_image_tests.cpp b/unit_tests/mem_obj/nv12_image_tests.cpp index dd8c91711b..cc254c9d7a 100644 --- a/unit_tests/mem_obj/nv12_image_tests.cpp +++ b/unit_tests/mem_obj/nv12_image_tests.cpp @@ -419,7 +419,7 @@ HWTEST_F(Nv12ImageTest, setImageArg) { SurfaceOffsets surfaceOffsets; image->getSurfaceOffsets(surfaceOffsets); - image->setImageArg(&surfaceState, false); + image->setImageArg(&surfaceState, false, 0); EXPECT_EQ(surfaceOffsets.xOffset, surfaceState.getXOffset()); EXPECT_EQ(surfaceOffsets.yOffset, surfaceState.getYOffset()); @@ -460,7 +460,7 @@ HWTEST_F(Nv12ImageTest, setImageArgUVPlaneImageSetsOffsetedSurfaceBaseAddressAnd SurfaceOffsets surfaceOffsets; imageUVPlane->getSurfaceOffsets(surfaceOffsets); - imageUVPlane->setImageArg(&surfaceState, false); + imageUVPlane->setImageArg(&surfaceState, false, 0); EXPECT_EQ(imageUVPlane->getGraphicsAllocation()->getGpuAddress() + surfaceOffsets.offset, surfaceState.getSurfaceBaseAddress()); diff --git a/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp b/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp index 2bd6b4b175..6920adb007 100644 --- a/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp +++ b/unit_tests/os_interface/linux/drm_memory_manager_tests.cpp @@ -1181,7 +1181,7 @@ TEST_F(DrmMemoryManagerTest, GivenMemoryManagerWhenAllocateGraphicsMemoryForImag EXPECT_EQ(1, munmapMockCallCount); } -TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipLevelZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { +TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipCountZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { mock->ioctl_expected.gemCreate = 1; mock->ioctl_expected.gemSetTiling = 1; mock->ioctl_expected.gemWait = 1; @@ -1226,7 +1226,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipLevelZero EXPECT_EQ(1u, this->mock->setTilingHandle); } -TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipLevelNonZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { +TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipCountNonZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { mock->ioctl_expected.gemCreate = 1; mock->ioctl_expected.gemSetTiling = 1; mock->ioctl_expected.gemWait = 1; @@ -1253,7 +1253,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageWithMipLevelNonZ std::unique_ptr dstImage(Image::create(&context, flags, surfaceFormat, &imageDesc, nullptr, retVal)); EXPECT_EQ(CL_SUCCESS, retVal); ASSERT_NE(nullptr, dstImage); - EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipLevel()); + EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipCount()); auto imageGraphicsAllocation = dstImage->getGraphicsAllocation(); ASSERT_NE(nullptr, imageGraphicsAllocation); EXPECT_TRUE(imageGraphicsAllocation->gmm->resourceParams.Usage == @@ -1351,7 +1351,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenTiledImageIsBeingCreatedFr EXPECT_EQ(1u, this->mock->setTilingHandle); } -TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipLevelZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { +TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipCountZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { mock->ioctl_expected.gemUserptr = 1; mock->ioctl_expected.gemWait = 1; mock->ioctl_expected.gemClose = 1; @@ -1396,7 +1396,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipLevelZer EXPECT_EQ(Sharing::nonSharedResource, imageGraphicsAllocation->peekSharedHandle()); } -TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipLevelNonZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { +TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipCountNonZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { mock->ioctl_expected.gemUserptr = 1; mock->ioctl_expected.gemWait = 1; mock->ioctl_expected.gemClose = 1; @@ -1423,7 +1423,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenNonTiledImgWithMipLevelNon std::unique_ptr dstImage(Image::create(&context, flags, surfaceFormat, &imageDesc, data, retVal)); EXPECT_EQ(CL_SUCCESS, retVal); ASSERT_NE(nullptr, dstImage); - EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipLevel()); + EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipCount()); auto imageGraphicsAllocation = dstImage->getGraphicsAllocation(); ASSERT_NE(nullptr, imageGraphicsAllocation); EXPECT_TRUE(imageGraphicsAllocation->gmm->resourceParams.Usage == diff --git a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp index cb12528974..920e22c5d7 100644 --- a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp +++ b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp @@ -253,7 +253,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenCreateFromSharedHandle EXPECT_EQ(nullptr, gpuAllocation); } -HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipLevelZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { +HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipCountZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { SetUpMm(); MockContext context; context.setMemoryManager(memoryManager); @@ -281,7 +281,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipLevel EXPECT_EQ(GMM_RESOURCE_USAGE_TYPE::GMM_RESOURCE_USAGE_OCL_IMAGE, imageGraphicsAllocation->gmm->resourceParams.Usage); } -HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipLevelNonZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { +HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipCountNonZeroIsBeingCreatedThenallocateGraphicsMemoryForImageIsUsed) { SetUpMm(); MockContext context; context.setMemoryManager(memoryManager); @@ -304,7 +304,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageWithMipLevel std::unique_ptr dstImage(Image::create(&context, flags, surfaceFormat, &imageDesc, nullptr, retVal)); EXPECT_EQ(CL_SUCCESS, retVal); ASSERT_NE(nullptr, dstImage); - EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipLevel()); + EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipCount()); auto imageGraphicsAllocation = dstImage->getGraphicsAllocation(); ASSERT_NE(nullptr, imageGraphicsAllocation); @@ -341,7 +341,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenTiledImageIsBeingCreat EXPECT_EQ(GMM_RESOURCE_USAGE_TYPE::GMM_RESOURCE_USAGE_OCL_IMAGE, imageGraphicsAllocation->gmm->resourceParams.Usage); } -HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipLevelZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { +HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipCountZeroisBeingCreatedThenAllocateGraphicsMemoryIsUsed) { SetUpMm(); MockContext context; context.setMemoryManager(memoryManager); @@ -370,7 +370,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipLeve EXPECT_EQ(GMM_RESOURCE_USAGE_TYPE::GMM_RESOURCE_USAGE_OCL_BUFFER, imageGraphicsAllocation->gmm->resourceParams.Usage); } -HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipLevelNonZeroisBeingCreatedThenAllocateGraphicsMemoryForImageIsUsed) { +HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipCountNonZeroisBeingCreatedThenAllocateGraphicsMemoryForImageIsUsed) { SetUpMm(); MockContext context; context.setMemoryManager(memoryManager); @@ -392,7 +392,7 @@ HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenNonTiledImgWithMipLeve std::unique_ptr dstImage(Image::create(&context, flags, surfaceFormat, &imageDesc, nullptr, retVal)); EXPECT_EQ(CL_SUCCESS, retVal); ASSERT_NE(nullptr, dstImage); - EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipLevel()); + EXPECT_EQ(static_cast(imageDesc.num_mip_levels), dstImage->peekMipCount()); auto imageGraphicsAllocation = dstImage->getGraphicsAllocation(); ASSERT_NE(nullptr, imageGraphicsAllocation);