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

Unify mipmap layout accross platforms

Browse Source 
- revert "Fix reported row/slicePitch for mip-maps"
- calculate mipmap offset without gmm

Change-Id: Id4802ef9624ad330e0d0f871dfa4d4fc35a7ba33
This commit is contained in:
Woloszyn, Wojciech
2018-09-04 06:25:29 -07:00
committed by sys_ocldev
parent 1b7738e0cf
commit f624ec757b
14 changed files with 126 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
runtime/command_queue/command_queue.cpp
View File

@@ -362,7 +362,7 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
UNRECOVERABLE_IF(mipIdx >= 4);
writeOrigin[mipIdx] = unmapInfo.mipLevel;
retVal = enqueueWriteImage(image, CL_FALSE, writeOrigin, &unmapInfo.size[0],
image->getHostPtrRowPitchForMap(unmapInfo.mipLevel), image->getHostPtrSlicePitchForMap(unmapInfo.mipLevel), mappedPtr,
image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(), mappedPtr,
eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
bool mustCallFinish = true;
if (!(image->getFlags() & CL_MEM_USE_HOST_PTR)) {
@@ -409,7 +409,7 @@ void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperti
UNRECOVERABLE_IF(mipIdx >= 4);
readOrigin[mipIdx] = transferProperties.mipLevel;
errcodeRet = enqueueReadImage(image, transferProperties.blocking, readOrigin, &transferProperties.size[0],
image->getHostPtrRowPitchForMap(transferProperties.mipLevel), image->getHostPtrSlicePitchForMap(transferProperties.mipLevel), returnPtr, eventsRequest.numEventsInWaitList,
image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(), returnPtr, eventsRequest.numEventsInWaitList,
eventsRequest.eventWaitList, eventsRequest.outEvent);
}
@@ -465,7 +465,6 @@ void *CommandQueue::enqueueMapImage(Image *image, cl_bool blockingMap,
const_cast<size_t *>(origin), const_cast<size_t *>(region), nullptr);
EventsRequest eventsRequest(numEventsInWaitList, eventWaitList, event);
auto returnPtr = enqueueMapMemObject(transferProperties, eventsRequest, errcodeRet);
if (image->isMemObjZeroCopy() && image->mappingOnCpuAllowed()) {
GetInfoHelper::set(imageSlicePitch, image->getImageDesc().image_slice_pitch);
if (image->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
@@ -478,14 +477,13 @@ void *CommandQueue::enqueueMapImage(Image *image, cl_bool blockingMap,
GetInfoHelper::set(imageRowPitch, image->getImageDesc().image_row_pitch);
}
} else {
GetInfoHelper::set(imageSlicePitch, image->getHostPtrSlicePitchForMap(transferProperties.mipLevel));
GetInfoHelper::set(imageRowPitch, image->getHostPtrRowPitchForMap(transferProperties.mipLevel));
GetInfoHelper::set(imageSlicePitch, image->getHostPtrSlicePitch());
GetInfoHelper::set(imageRowPitch, image->getHostPtrRowPitch());
}
if (Image::hasSlices(image->peekClMemObjType()) == false) {
GetInfoHelper::set(imageSlicePitch, static_cast<size_t>(0));
}
return returnPtr;
return enqueueMapMemObject(transferProperties, eventsRequest, errcodeRet);
}
cl_int CommandQueue::enqueueUnmapMemObject(MemObj *memObj, void *mappedPtr, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) {

20
runtime/gen8/image_gen8.cpp
View File

@@ -21,25 +21,5 @@ void ImageHw<GfxFamily>::setMediaSurfaceRotation(void *) {}
template <typename GfxFamily>
void ImageHw<GfxFamily>::setSurfaceMemoryObjectControlStateIndexToMocsTable(void *, uint32_t) {}
template <>
size_t ImageHw<BDWFamily>::getHostPtrRowPitchForMap(uint32_t mipLevel) {
if (getImageDesc().num_mip_levels <= 1) {
return getHostPtrRowPitch();
}
size_t mipWidth = (getImageDesc().image_width >> mipLevel) > 0 ? (getImageDesc().image_width >> mipLevel) : 1;
return mipWidth * getSurfaceFormatInfo().ImageElementSizeInBytes;
}
template <>
size_t ImageHw<BDWFamily>::getHostPtrSlicePitchForMap(uint32_t mipLevel) {
if (getImageDesc().num_mip_levels <= 1) {
return getHostPtrSlicePitch();
}
size_t mipHeight = (getImageDesc().image_height >> mipLevel) > 0 ? (getImageDesc().image_height >> mipLevel) : 1;
size_t rowPitch = getHostPtrRowPitchForMap(mipLevel);
return rowPitch * mipHeight;
}
#include "runtime/mem_obj/image_factory_init.inl"
} // namespace OCLRT

53
runtime/helpers/mipmap.cpp
View File

@@ -11,6 +11,7 @@
#include "runtime/gmm_helper/resource_info.h"
#include "runtime/mem_obj/image.h"
#include <algorithm>
#include <cstdint>
#include <limits>
@@ -65,33 +66,33 @@ uint32_t getMipOffset(Image *image, const size_t *origin) {
return 0;
}
UNRECOVERABLE_IF(origin == nullptr);
auto bytesPerPixel = image->getSurfaceFormatInfo().ImageElementSizeInBytes;
size_t offset{};
auto imageType = image->getImageDesc().image_type;
GMM_REQ_OFFSET_INFO GMMReqInfo = {};
GMMReqInfo.ReqLock = 1;
GMMReqInfo.MipLevel = findMipLevel(imageType, origin);
switch (imageType) {
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
GMMReqInfo.ArrayIndex = static_cast<uint32_t>(origin[1]);
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
GMMReqInfo.ArrayIndex = static_cast<uint32_t>(origin[2]);
break;
case CL_MEM_OBJECT_IMAGE3D:
GMMReqInfo.Slice = static_cast<uint32_t>(origin[2]);
break;
default:
break;
auto lod = findMipLevel(imageType, origin);
auto baseWidth = image->getImageDesc().image_width;
auto baseHeight = image->getImageDesc().image_height;
if (lod) {
size_t mipHeight = baseHeight;
size_t mipWidth = baseWidth;
bool translate = false;
if (lod >= 2) {
translate = true;
mipWidth += std::max<size_t>(baseWidth >> 2, 1);
}
for (size_t currentLod = 3; currentLod <= lod; currentLod++) {
mipHeight += std::max<size_t>(baseHeight >> currentLod, 1);
mipWidth += std::max<size_t>(baseWidth >> currentLod, 1);
}
if (imageType == CL_MEM_OBJECT_IMAGE1D) {
offset = mipWidth;
} else {
offset = baseWidth * mipHeight;
if (translate) {
offset += std::max<size_t>(baseWidth >> 1, 1);
}
}
}
auto graphicsAlloc = image->getGraphicsAllocation();
UNRECOVERABLE_IF(graphicsAlloc == nullptr);
UNRECOVERABLE_IF(graphicsAlloc->gmm == nullptr);
auto gmmResourceInfo = graphicsAlloc->gmm->gmmResourceInfo.get();
UNRECOVERABLE_IF(gmmResourceInfo == nullptr);
gmmResourceInfo->getOffset(GMMReqInfo);
return GMMReqInfo.Lock.Offset;
return static_cast<uint32_t>(bytesPerPixel * offset);
}
} // namespace OCLRT

9
runtime/mem_obj/image.cpp
View File

@@ -1204,19 +1204,14 @@ size_t Image::calculateOffsetForMapping(const MemObjOffsetArray &origin) const {
switch (imageDesc.image_type) {
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
if (imageDesc.num_mip_levels <= 1) {
offset += slicePitch * origin[1];
}
offset += slicePitch * origin[1];
break;
case CL_MEM_OBJECT_IMAGE2D:
offset += rowPitch * origin[1];
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
case CL_MEM_OBJECT_IMAGE3D:
offset += rowPitch * origin[1];
if (imageDesc.num_mip_levels <= 1) {
offset += slicePitch * origin[2];
}
offset += rowPitch * origin[1] + slicePitch * origin[2];
break;
default:
break;

5
runtime/mem_obj/image.h
View File

@@ -170,9 +170,6 @@ class Image : public MemObj {
virtual void transformImage2dArrayTo3d(void *memory) = 0;
virtual void transformImage3dTo2dArray(void *memory) = 0;
virtual size_t getHostPtrRowPitchForMap(uint32_t mipLevel) = 0;
virtual size_t getHostPtrSlicePitchForMap(uint32_t mipLevel) = 0;
const bool isTiledImage;
bool hasSameDescriptor(const cl_image_desc &imageDesc) const;
@@ -259,8 +256,6 @@ class ImageHw : public Image {
}
}
size_t getHostPtrRowPitchForMap(uint32_t mipLevel) override;
size_t getHostPtrSlicePitchForMap(uint32_t mipLevel) 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);

10
runtime/mem_obj/image.inl
View File

@@ -260,14 +260,4 @@ void ImageHw<GfxFamily>::transformImage3dTo2dArray(void *memory) {
surfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D);
surfaceState->setSurfaceArray(true);
}
template <typename GfxFamily>
size_t ImageHw<GfxFamily>::getHostPtrRowPitchForMap(uint32_t mipLevel) {
return getHostPtrRowPitch();
}
template <typename GfxFamily>
size_t ImageHw<GfxFamily>::getHostPtrSlicePitchForMap(uint32_t mipLevel) {
return getHostPtrSlicePitch();
}
} // namespace OCLRT

12
unit_tests/command_queue/enqueue_map_image_tests.cpp
View File

@@ -103,7 +103,7 @@ TEST_F(EnqueueMapImageTest, givenAllocatedMapPtrAndMapWithDifferentOriginIsCalle
typedef EnqueueMapImageParamsTest MipMapMapImageParamsTest;
TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrAndMapWithDifferentMipMapsIsCalledThenReturnDifferentPointers) {
TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrWhenMapsWithDifferentMipMapsAreCalledThenReturnDifferentPointers) {
auto image_type = (cl_mem_object_type)GetParam();
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
@@ -115,6 +115,7 @@ TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrAndMapWithDifferentMipMapsI
const size_t origin1[4] = {0, 0, 0, 0};
size_t origin2[4] = {0, 0, 0, 0};
std::unique_ptr<Image> image;
size_t mapOffset = 16u;
switch (image_type) {
case CL_MEM_OBJECT_IMAGE1D:
origin2[1] = 1;
@@ -159,7 +160,6 @@ TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrAndMapWithDifferentMipMapsI
EXPECT_NE(nullptr, image->getAllocatedMapPtr());
}
size_t mapOffset = 16u;
EXPECT_EQ(ptr2, ptrOffset(ptr1, mapOffset));
}
@@ -850,7 +850,7 @@ TEST_F(EnqueueMapImageTest, givenNonZeroCopyImageWhenMappedOnGpuThenReturnHostRo
EXPECT_EQ(image->getHostPtrSlicePitch(), retImageSlicePitch);
}
TEST_F(EnqueueMapImageTest, givenMipMapImageWhenMappedThenReturnHostRowAndSlicePitchForMap) {
TEST_F(EnqueueMapImageTest, givenMipMapImageWhenMappedThenReturnHostRowAndSlicePitch) {
const size_t origin[4] = {0, 0, 0, 1};
const size_t region[3] = {1, 1, 1};
size_t retImageRowPitch = 0;
@@ -872,8 +872,8 @@ TEST_F(EnqueueMapImageTest, givenMipMapImageWhenMappedThenReturnHostRowAndSliceP
0, nullptr, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(image->getHostPtrRowPitchForMap(static_cast<uint32_t>(origin[3])), retImageRowPitch);
EXPECT_EQ(image->getHostPtrSlicePitchForMap(static_cast<uint32_t>(origin[3])), retImageSlicePitch);
EXPECT_EQ(image->getHostPtrRowPitch(), retImageRowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), retImageSlicePitch);
}
TEST_F(EnqueueMapImageTest, givenImage1DArrayWhenEnqueueMapImageIsCalledThenReturnRowAndSlicePitchAreEqual) {
@@ -895,8 +895,6 @@ TEST_F(EnqueueMapImageTest, givenImage1DArrayWhenEnqueueMapImageIsCalledThenRetu
void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
size_t getHostPtrRowPitchForMap(uint32_t mipLevel) override { return getHostPtrRowPitch(); }
size_t getHostPtrSlicePitchForMap(uint32_t mipLevel) override { return getHostPtrSlicePitch(); }
};
const size_t origin[3] = {0, 0, 0};

32
unit_tests/gen10/image_tests_gen10.cpp
View File

@@ -28,38 +28,6 @@ GEN10TEST_F(gen10ImageTests, appendSurfaceStateParamsDoesNothing) {
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
}
GEN10TEST_F(gen10ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledWithMipLevelZeroThenReturnHostPtrRowPitchAndSlicePitch) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(0u);
auto slicePitch = image->getHostPtrSlicePitchForMap(0u);
EXPECT_EQ(image->getHostPtrRowPitch(), rowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), slicePitch);
}
GEN10TEST_F(gen10ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledWithMipLevelNonZeroThenReturnHostPtrRowPitchAndSlicePitch) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(1u);
auto slicePitch = image->getHostPtrSlicePitchForMap(1u);
EXPECT_EQ(image->getHostPtrRowPitch(), rowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), slicePitch);
}
GEN10TEST_F(gen10ImageTests, givenImageForGen10WhenClearColorParametersAreSetThenSurfaceStateIsNotModified) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
MockContext context;

79
unit_tests/gen8/image_tests_gen8.cpp
View File

@@ -27,82 +27,3 @@ GEN8TEST_F(gen8ImageTests, appendSurfaceStateParamsDoesNothing) {
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
}
GEN8TEST_F(gen8ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledOnMipMappedImageWithMipLevelZeroThenReturnWidthTimesBytesPerPixelAndRowPitchTimesHeight) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_depth = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(0u);
auto slicePitch = image->getHostPtrSlicePitchForMap(0u);
EXPECT_EQ(4 * imageDesc.image_width, rowPitch);
EXPECT_EQ(imageDesc.image_height * rowPitch, slicePitch);
}
GEN8TEST_F(gen8ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledOnMipMappedImageWithMipLevelNonZeroThenReturnScaledWidthTimesBytesPerPixelAndRowPitchTimesScaledHeight) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_depth = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(1u);
auto slicePitch = image->getHostPtrSlicePitchForMap(1u);
EXPECT_EQ(4 * (imageDesc.image_width >> 1), rowPitch);
EXPECT_EQ((imageDesc.image_height >> 1) * rowPitch, slicePitch);
}
GEN8TEST_F(gen8ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledOnMipMappedImageWithMipLevelNonZeroThenReturnScaledWidthTimesBytesPerPixelAndRowPitchTimesScaledHeightCannotBeZero) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_depth = 5;
imageDesc.num_mip_levels = 5;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(4u);
auto slicePitch = image->getHostPtrSlicePitchForMap(4u);
EXPECT_EQ(4u, rowPitch);
EXPECT_EQ(rowPitch, slicePitch);
}
GEN8TEST_F(gen8ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledOnNonMipMappedImageThenReturnRowPitchAndSlicePitch) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_depth = 5;
imageDesc.num_mip_levels = 0;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(0u);
auto slicePitch = image->getHostPtrSlicePitchForMap(0u);
EXPECT_EQ(image->getHostPtrRowPitch(), rowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), slicePitch);
}
GEN8TEST_F(gen8ImageTests, givenImageForGen8WhenClearColorParametersAreSetThenSurfaceStateIsNotModified) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(&context));
auto surfaceStateBefore = RENDER_SURFACE_STATE::sInit();
auto surfaceStateAfter = RENDER_SURFACE_STATE::sInit();
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
imageHw->setClearColorParams(&surfaceStateAfter, imageHw->getGraphicsAllocation()->gmm);
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
}

47
unit_tests/gen9/image_tests_gen9.cpp
View File

@@ -27,50 +27,3 @@ GEN9TEST_F(gen9ImageTests, appendSurfaceStateParamsDoesNothing) {
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
}
GEN9TEST_F(gen9ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledWithMipLevelZeroThenReturnHostPtrRowPitchAndSlicePitch) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(0u);
auto slicePitch = image->getHostPtrSlicePitchForMap(0u);
EXPECT_EQ(image->getHostPtrRowPitch(), rowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), slicePitch);
}
GEN9TEST_F(gen9ImageTests, WhenGetHostPtrRowOrSlicePitchForMapIsCalledWithMipLevelNonZeroThenReturnHostPtrRowPitchAndSlicePitch) {
MockContext context;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 2;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&context, &imageDesc));
auto rowPitch = image->getHostPtrRowPitchForMap(1u);
auto slicePitch = image->getHostPtrSlicePitchForMap(1u);
EXPECT_EQ(image->getHostPtrRowPitch(), rowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), slicePitch);
}
GEN9TEST_F(gen9ImageTests, givenImageForGen9WhenClearColorParametersAreSetThenSurfaceStateIsNotModified) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
MockContext context;
auto image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(&context));
auto surfaceStateBefore = RENDER_SURFACE_STATE::sInit();
auto surfaceStateAfter = RENDER_SURFACE_STATE::sInit();
auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
imageHw->setClearColorParams(&surfaceStateAfter, imageHw->getGraphicsAllocation()->gmm);
EXPECT_EQ(0, memcmp(&surfaceStateBefore, &surfaceStateAfter, sizeof(RENDER_SURFACE_STATE)));
}

124
unit_tests/helpers/mipmap_tests.cpp
View File

@@ -72,40 +72,10 @@ TEST(MipmapHelper, givenBufferWhenIsMipMappedIsCalledThenFalseIsReturned) {
EXPECT_FALSE(OCLRT::isMipMapped(&buffer));
}
struct MockMipMapGmmResourceInfo : GmmResourceInfo {
using GmmResourceInfo::GmmResourceInfo;
GMM_STATUS getOffset(GMM_REQ_OFFSET_INFO &reqOffsetInfo) override {
receivedMipLevel = reqOffsetInfo.MipLevel;
receivedArrayIndex = reqOffsetInfo.ArrayIndex;
receivedSlice = reqOffsetInfo.Slice;
receivedLockFlagVal = reqOffsetInfo.ReqLock;
reqOffsetInfo.Lock.Offset = getExpectedReturnOffset();
return GMM_SUCCESS;
}
uint32_t receivedLockFlagVal = false;
uint32_t receivedMipLevel = 0U;
uint32_t receivedArrayIndex = 0U;
uint32_t receivedSlice = 0U;
static constexpr uint32_t getExpectedReturnOffset() {
return 13;
}
};
struct MockImage : MockImageBase {
std::unique_ptr<Gmm> mockGmm;
MockImage() : MockImageBase() {
mockGmm.reset(new Gmm(nullptr, 0, false));
graphicsAllocation->gmm = mockGmm.get();
mockGmm->gmmResourceInfo.reset(new MockMipMapGmmResourceInfo());
}
MockMipMapGmmResourceInfo *getResourceInfo() {
return static_cast<MockMipMapGmmResourceInfo *>(mockGmm->gmmResourceInfo.get());
surfaceFormatInfo.ImageElementSizeInBytes = 4u;
}
};
@@ -132,50 +102,68 @@ TEST(MipmapHelper, givenImageWithoutMipLevelsWhenGetMipOffsetIsCalledThenZeroIsR
EXPECT_EQ(0U, offset);
}
struct MipOffsetTestExpVal {
uint32_t expectedSlice = 0;
uint32_t expectedArrayIndex = 0;
static MipOffsetTestExpVal ExpectSlice(size_t expectedSlice) {
MipOffsetTestExpVal ret = {};
ret.expectedSlice = static_cast<uint32_t>(expectedSlice);
return ret;
}
static MipOffsetTestExpVal ExpectArrayIndex(size_t expectedArrayIndex) {
MipOffsetTestExpVal ret = {};
ret.expectedArrayIndex = static_cast<uint32_t>(expectedArrayIndex);
return ret;
}
static MipOffsetTestExpVal ExpectNoSliceOrArrayIndex() {
return MipOffsetTestExpVal{};
}
};
typedef ::testing::TestWithParam<std::pair<uint32_t, MipOffsetTestExpVal>> MipOffsetTest;
using myTuple = std::tuple<std::array<size_t, 4>, uint32_t, uint32_t>;
using MipOffsetTest = ::testing::TestWithParam<myTuple>;
TEST_P(MipOffsetTest, givenImageWithMipLevelsWhenGetMipOffsetIsCalledThenProperOffsetIsReturned) {
auto pair = GetParam();
std::array<size_t, 4> origin;
uint32_t expectedOffset;
cl_mem_object_type imageType;
std::tie(origin, expectedOffset, imageType) = GetParam();
MockImage image;
image.imageDesc.num_mip_levels = 16;
image.imageDesc.image_type = pair.first;
image.imageDesc.image_type = imageType;
image.imageDesc.image_width = 11;
image.imageDesc.image_height = 13;
image.imageDesc.image_depth = 17;
auto offset = getMipOffset(&image, testOrigin);
auto offset = getMipOffset(&image, origin.data());
EXPECT_EQ(MockMipMapGmmResourceInfo::getExpectedReturnOffset(), offset);
EXPECT_EQ(1U, image.getResourceInfo()->receivedLockFlagVal);
EXPECT_EQ(findMipLevel(image.imageDesc.image_type, testOrigin), image.getResourceInfo()->receivedMipLevel);
EXPECT_EQ(pair.second.expectedSlice, image.getResourceInfo()->receivedSlice);
EXPECT_EQ(pair.second.expectedArrayIndex, image.getResourceInfo()->receivedArrayIndex);
EXPECT_EQ(expectedOffset, offset);
}
INSTANTIATE_TEST_CASE_P(MipmapOffset,
constexpr myTuple testOrigins[]{myTuple({{2, 3, 5, 7}},
812u, CL_MEM_OBJECT_IMAGE3D),
myTuple({{2, 3, 5, 2}},
592u, CL_MEM_OBJECT_IMAGE3D),
myTuple({{2, 3, 5, 1}},
572u, CL_MEM_OBJECT_IMAGE3D),
myTuple({{2, 3, 5, 0}},
0u, CL_MEM_OBJECT_IMAGE3D),
myTuple({{2, 3, 5, 7}},
812u, CL_MEM_OBJECT_IMAGE2D_ARRAY),
myTuple({{2, 3, 5, 2}},
592u, CL_MEM_OBJECT_IMAGE2D_ARRAY),
myTuple({{2, 3, 5, 1}},
572u, CL_MEM_OBJECT_IMAGE2D_ARRAY),
myTuple({{2, 3, 5, 0}},
0u, CL_MEM_OBJECT_IMAGE2D_ARRAY),
myTuple({{2, 3, 5, 0}},
724u, CL_MEM_OBJECT_IMAGE2D),
myTuple({{2, 3, 2, 0}},
592u, CL_MEM_OBJECT_IMAGE2D),
myTuple({{2, 3, 1, 0}},
572u, CL_MEM_OBJECT_IMAGE2D),
myTuple({{2, 3, 0, 0}},
0u, CL_MEM_OBJECT_IMAGE2D),
myTuple({{2, 3, 5, 0}},
724u, CL_MEM_OBJECT_IMAGE1D_ARRAY),
myTuple({{2, 3, 2, 0}},
592u, CL_MEM_OBJECT_IMAGE1D_ARRAY),
myTuple({{2, 3, 1, 0}},
572u, CL_MEM_OBJECT_IMAGE1D_ARRAY),
myTuple({{2, 3, 0, 0}},
0u, CL_MEM_OBJECT_IMAGE1D_ARRAY),
myTuple({{2, 3, 0, 0}},
56u, CL_MEM_OBJECT_IMAGE1D),
myTuple({{2, 2, 0, 0}},
52u, CL_MEM_OBJECT_IMAGE1D),
myTuple({{2, 1, 0, 0}},
44u, CL_MEM_OBJECT_IMAGE1D),
myTuple({{2, 0, 0, 0}},
0u, CL_MEM_OBJECT_IMAGE1D)};
INSTANTIATE_TEST_CASE_P(MipMapOffset,
MipOffsetTest,
::testing::Values(std::make_pair(CL_MEM_OBJECT_IMAGE1D, MipOffsetTestExpVal::ExpectNoSliceOrArrayIndex()),
std::make_pair(CL_MEM_OBJECT_IMAGE1D_ARRAY, MipOffsetTestExpVal::ExpectArrayIndex(testOrigin[1])),
std::make_pair(CL_MEM_OBJECT_IMAGE2D, MipOffsetTestExpVal::ExpectNoSliceOrArrayIndex()),
std::make_pair(CL_MEM_OBJECT_IMAGE2D_ARRAY, MipOffsetTestExpVal::ExpectArrayIndex(testOrigin[2])),
std::make_pair(CL_MEM_OBJECT_IMAGE3D, MipOffsetTestExpVal::ExpectSlice(testOrigin[2]))));
::testing::ValuesIn(testOrigins));

41
unit_tests/mem_obj/image_tests.cpp
View File

@@ -1030,7 +1030,7 @@ TEST(ImageTest, givenImageWhenAskedForPtrLengthForCpuMappingThenReturnCorrectVal
EXPECT_EQ(expectedLength, retLength);
}
TEST(ImageTest, givenMipMapImage3DWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithoutSlicePitch) {
TEST(ImageTest, givenMipMapImage3DWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithSlicePitch) {
MockContext ctx;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D;
@@ -1042,16 +1042,16 @@ TEST(ImageTest, givenMipMapImage3DWhenAskedForPtrOffsetForGpuMappingThenReturnOf
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{}};
MemObjOffsetArray origin{{1, 1, 1}};
auto retOffset = image->calculateOffsetForMapping(origin);
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0] +
image->getHostPtrRowPitch() * origin[1];
image->getHostPtrRowPitch() * origin[1] + image->getHostPtrSlicePitch() * origin[2];
EXPECT_EQ(expectedOffset, retOffset);
}
TEST(ImageTest, givenMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithoutSlicePitch) {
TEST(ImageTest, givenMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithSlicePitch) {
MockContext ctx;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY;
@@ -1063,16 +1063,37 @@ TEST(ImageTest, givenMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThenRet
std::unique_ptr<Image> image(ImageHelper<Image2dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{}};
MemObjOffsetArray origin{{1, 1, 1}};
auto retOffset = image->calculateOffsetForMapping(origin);
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0] +
image->getHostPtrRowPitch() * origin[1];
image->getHostPtrRowPitch() * origin[1] + image->getHostPtrSlicePitch() * origin[2];
EXPECT_EQ(expectedOffset, retOffset);
}
TEST(ImageTest, givenMipMapImage1DArrayWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithoutSlicePitch) {
TEST(ImageTest, givenNonMipMapImage2DArrayWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithSlicePitch) {
MockContext ctx;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY;
imageDesc.image_width = 5;
imageDesc.image_height = 5;
imageDesc.image_array_size = 5;
imageDesc.num_mip_levels = 1;
std::unique_ptr<Image> image(ImageHelper<Image2dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin{{1, 1, 1}};
auto retOffset = image->calculateOffsetForMapping(origin);
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0] +
image->getHostPtrRowPitch() * origin[1] + image->getHostPtrSlicePitch() * origin[2];
EXPECT_EQ(expectedOffset, retOffset);
}
TEST(ImageTest, givenMipMapImage1DArrayWhenAskedForPtrOffsetForGpuMappingThenReturnOffsetWithSlicePitch) {
MockContext ctx;
cl_image_desc imageDesc{};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D_ARRAY;
@@ -1083,10 +1104,10 @@ TEST(ImageTest, givenMipMapImage1DArrayWhenAskedForPtrOffsetForGpuMappingThenRet
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(&ctx, &imageDesc));
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{}};
MemObjOffsetArray origin{{1, 1, 0}};
auto retOffset = image->calculateOffsetForMapping(origin);
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0];
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0] + image->getHostPtrSlicePitch() * origin[1];
EXPECT_EQ(expectedOffset, retOffset);
}
@@ -1095,7 +1116,7 @@ typedef ::testing::TestWithParam<uint32_t> MipLevelCoordinateTest;
TEST_P(MipLevelCoordinateTest, givenMipmappedImageWhenValidateRegionAndOriginIsCalledThenAdditionalOriginCoordinateIsAnalyzed) {
size_t origin[4]{};
size_t region[3] = {1, 1, 1};
size_t region[3]{1, 1, 1};
cl_image_desc desc = {};
desc.image_type = GetParam();
desc.num_mip_levels = 2;

2
unit_tests/mem_obj/image_validate_tests.cpp
View File

@@ -779,8 +779,6 @@ struct NullImage : public Image {
void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
size_t getHostPtrRowPitchForMap(uint32_t mipLevel) override { return getHostPtrRowPitch(); }
size_t getHostPtrSlicePitchForMap(uint32_t mipLevel) override { return getHostPtrSlicePitch(); }
};
TEST_P(ValidParentImageFormatTest, givenParentChannelOrderWhenTestWithAllChannelOrdersThenReturnTrueForValidChannelOrder) {

2
unit_tests/mocks/mock_image.h
View File

@@ -32,6 +32,4 @@ struct MockImageBase : public OCLRT::Image {
void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override {}
void transformImage2dArrayTo3d(void *memory) override {}
void transformImage3dTo2dArray(void *memory) override {}
size_t getHostPtrRowPitchForMap(uint32_t mipLevel) override { return getHostPtrRowPitch(); };
size_t getHostPtrSlicePitchForMap(uint32_t mipLevel) override { return getHostPtrSlicePitch(); };
};