intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 15:53:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Map/unmap enqueue fixes [3/n]: Map params inconsistency

Browse Source 
- Introducing MapInfo struct which will be used as container for multiple
  map operations
- Unified mapped offset and size for Buffers and Images
- Fixed incorrect map params for CPU and GPU path
- Missing API level checks


Change-Id: Ib4077c9e2c0c333b131ffd5ccbc4a1404920eb5b
This commit is contained in:
Dunajski, Bartosz
2018-02-13 13:20:34 +01:00
committed by sys_ocldev
parent a95e7c67a3
commit e0ca78ccea
15 changed files with 320 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
unit_tests/mem_obj/image_release_mapped_ptr_tests.cpp
View File

@@ -70,8 +70,10 @@ class ImageUnmapTest : public ::testing::Test {
HWTEST_F(ImageUnmapTest, givenImageWhenUnmapMemObjIsCalledThenEnqueueNonBlockingMapImage) {
std::unique_ptr<MyMockCommandQueue<FamilyType>> commandQueue(new MyMockCommandQueue<FamilyType>(&context));
void *ptr = alignedMalloc(MemoryConstants::cacheLineSize, MemoryConstants::cacheLineSize);
image->setAllocatedMappedPtr(ptr);
image->setMappedPtr(ptr);
size_t origin[3] = {0, 0, 0};
size_t region[3] = {1, 1, 1};
image->setAllocatedMapPtr(ptr);
image->setMapInfo(ptr, region, origin);
commandQueue->enqueueUnmapMemObject(image.get(), ptr, 0, nullptr, nullptr);
EXPECT_EQ(ptr, commandQueue->passedPtr);
EXPECT_EQ((cl_bool)CL_FALSE, commandQueue->passedBlockingWrite);
@@ -119,10 +121,10 @@ TEST_F(ImageUnmapTest, givenImageWhenEnqueueMapImageIsCalledTwiceThenAllocatedMe
std::unique_ptr<MockDevice> device(DeviceHelper<>::create());
std::unique_ptr<CommandQueue> commandQueue(CommandQueue::create(&context, device.get(), nullptr, retVal));
commandQueue->enqueueMapImage(image.get(), CL_FALSE, 0, origin, region, nullptr, nullptr, 0, nullptr, nullptr, retVal);
EXPECT_NE(nullptr, image->getAllocatedMappedPtr());
void *ptr = image->getAllocatedMappedPtr();
EXPECT_NE(nullptr, image->getAllocatedMapPtr());
void *ptr = image->getAllocatedMapPtr();
EXPECT_EQ(alignUp(ptr, MemoryConstants::pageSize), ptr);
commandQueue->enqueueMapImage(image.get(), CL_FALSE, 0, origin, region, nullptr, nullptr, 0, nullptr, nullptr, retVal);
EXPECT_EQ(ptr, image->getAllocatedMappedPtr());
EXPECT_EQ(ptr, image->getAllocatedMapPtr());
commandQueue->enqueueUnmapMemObject(image.get(), ptr, 0, nullptr, nullptr);
}

14
unit_tests/mem_obj/image_tests.cpp
View File

@@ -991,3 +991,17 @@ TEST_F(ImageCompressionTests, givenNonTiledImageWhenCreatingAllocationThenDontPr
EXPECT_TRUE(myMemoryManager->mockMethodCalled);
EXPECT_FALSE(myMemoryManager->capturedImgInfo.preferRenderCompression);
}
TEST(ImageTest, givenImageWhenAskedForPtrOffsetThenReturnCorrectValue) {
MockContext ctx;
std::unique_ptr<Image> image(ImageHelper<Image3dDefaults>::create(&ctx));
size_t origin[3] = {4, 5, 6};
size_t rowPitch = 7;
size_t slicePitch = 8;
auto retOffset = image->calculateOffset(rowPitch, slicePitch, origin);
size_t expectedOffset = image->getSurfaceFormatInfo().ImageElementSizeInBytes * origin[0] + rowPitch * origin[1] + slicePitch * origin[2];
EXPECT_EQ(expectedOffset, retOffset);
}

8
unit_tests/mem_obj/mem_obj_destruction_tests.cpp
View File

@@ -161,7 +161,7 @@ HWTEST_P(MemObjAsyncDestructionTest, givenUsedMemObjWithAsyncDestructionsEnabled
if (hasAllocatedMappedPtr) {
auto allocatedPtr = alignedMalloc(size, MemoryConstants::pageSize);
memObj->setAllocatedMappedPtr(allocatedPtr);
memObj->setAllocatedMapPtr(allocatedPtr);
}
auto mockCsr = new ::testing::NiceMock<MyCsr<FamilyType>>(device->getHardwareInfo());
@@ -189,13 +189,15 @@ HWTEST_P(MemObjAsyncDestructionTest, givenUsedMemObjWithAsyncDestructionsEnabled
if (!hasAllocatedMappedPtr) {
delete memObj;
allocation = memoryManager->allocateGraphicsMemory(size, MemoryConstants::pageSize);
size_t origin[3] = {0, 0, 0};
size_t region[3] = {1, 1, 1};
memObj = new MemObj(&context, CL_MEM_OBJECT_BUFFER,
CL_MEM_READ_WRITE,
size,
storage, nullptr, allocation, true, false, false);
memObj->setMappedPtr(storage);
memObj->setMapInfo(storage, region, origin);
} else {
memObj->setAllocatedMappedPtr(storage);
memObj->setAllocatedMapPtr(storage);
}
makeMemObjUsed();

48
unit_tests/mem_obj/mem_obj_tests.cpp
View File

@@ -22,6 +22,7 @@
#include "runtime/mem_obj/mem_obj.h"
#include "runtime/device/device.h"
#include "runtime/helpers/properties_helper.h"
#include "unit_tests/mocks/mock_context.h"
#include "unit_tests/mocks/mock_deferred_deleter.h"
#include "unit_tests/mocks/mock_graphics_allocation.h"
@@ -59,8 +60,12 @@ TEST(MemObj, GivenMemObjWhenInititalizedFromHostPtrThenInitializeFields) {
EXPECT_EQ(size, memObj.getSize());
EXPECT_EQ(static_cast<cl_mem_flags>(CL_MEM_USE_HOST_PTR), memObj.getFlags());
EXPECT_EQ(nullptr, memObj.getMappedPtr());
EXPECT_EQ(0u, memObj.getMappedSize());
EXPECT_EQ(0u, memObj.getMappedOffset());
EXPECT_EQ(0u, memObj.getMappedSize()[0]);
EXPECT_EQ(0u, memObj.getMappedSize()[1]);
EXPECT_EQ(0u, memObj.getMappedSize()[2]);
EXPECT_EQ(0u, memObj.getMappedOffset()[0]);
EXPECT_EQ(0u, memObj.getMappedOffset()[1]);
EXPECT_EQ(0u, memObj.getMappedOffset()[2]);
}
TEST(MemObj, givenMemObjectWhenAskedForTransferToHostPtrThenDoNothing) {
@@ -104,12 +109,33 @@ TEST(MemObj, givenMemObjWhenAllocatedMappedPtrIsSetThenGetMappedPtrIsDifferentTh
MemObj memObj(&context, CL_MEM_OBJECT_BUFFER, CL_MEM_USE_HOST_PTR,
1, nullptr, nullptr, nullptr, true, false, false);
EXPECT_EQ(nullptr, memObj.getAllocatedMappedPtr());
EXPECT_EQ(nullptr, memObj.getAllocatedMapPtr());
EXPECT_EQ(nullptr, memObj.getMappedPtr());
memObj.setAllocatedMappedPtr(mockPtr);
EXPECT_EQ(mockPtr, memObj.getAllocatedMappedPtr());
memObj.setAllocatedMapPtr(mockPtr);
EXPECT_EQ(mockPtr, memObj.getAllocatedMapPtr());
EXPECT_NE(mockPtr, memObj.getMappedPtr());
memObj.setAllocatedMappedPtr(nullptr);
memObj.setAllocatedMapPtr(nullptr);
}
TEST(MemObj, givenHostPtrAndUseHostPtrFlagWhenAskingForBaseMapPtrThenReturnHostPtr) {
uint8_t hostPtr = 0;
MockContext context;
MemObj memObj(&context, CL_MEM_OBJECT_BUFFER, CL_MEM_USE_HOST_PTR,
1, nullptr, &hostPtr, nullptr, true, false, false);
EXPECT_EQ(&hostPtr, memObj.getBasePtrForMap());
}
TEST(MemObj, givenHostPtrWithoutUseHostPtrFlagWhenAskingForBaseMapPtrThenReturnAllocatedPtr) {
uint8_t hostPtr = 0;
MockContext context;
MemObj memObj(&context, CL_MEM_OBJECT_BUFFER, CL_MEM_COPY_HOST_PTR,
1, nullptr, &hostPtr, nullptr, true, false, false);
EXPECT_NE(&hostPtr, memObj.getBasePtrForMap());
EXPECT_EQ(memObj.getAllocatedMapPtr(), memObj.getBasePtrForMap());
}
TEST(MemObj, givenMemObjWhenReleaseAllocatedPtrIsCalledTwiceThenItDoesntCrash) {
@@ -120,11 +146,11 @@ TEST(MemObj, givenMemObjWhenReleaseAllocatedPtrIsCalledTwiceThenItDoesntCrash) {
MemObj memObj(&context, CL_MEM_OBJECT_BUFFER, CL_MEM_USE_HOST_PTR,
1, nullptr, nullptr, nullptr, true, false, false);
memObj.setAllocatedMappedPtr(allocatedPtr);
memObj.releaseAllocatedMappedPtr();
EXPECT_EQ(nullptr, memObj.getAllocatedMappedPtr());
memObj.releaseAllocatedMappedPtr();
EXPECT_EQ(nullptr, memObj.getAllocatedMappedPtr());
memObj.setAllocatedMapPtr(allocatedPtr);
memObj.releaseAllocatedMapPtr();
EXPECT_EQ(nullptr, memObj.getAllocatedMapPtr());
memObj.releaseAllocatedMapPtr();
EXPECT_EQ(nullptr, memObj.getAllocatedMapPtr());
}
TEST(MemObj, givenNotReadyGraphicsAllocationWhenMemObjDestroysAllocationAsyncThenAllocationIsAddedToMemoryManagerAllocationList) {