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

Fix zeroCopy property for images 

- zeroCopy means no need for data transfer when cpu transfer is
chosen during map/unmap operations
- tests cleanup

Change-Id: Id312267e51d593781c6fe536b6e96f42f32e5c02
This commit is contained in:
Hoppe, Mateusz 2018-08-22 10:00:40 +02:00 committed by sys_ocldev
parent 9ac3529c6b
commit aaf2f94887
10 changed files with 145 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
runtime/mem_obj/image.cpp
View File

@ -250,7 +250,9 @@ Image *Image::create(Context *context,
} }
} else { } else {
memory = memoryManager->allocateGraphicsMemoryForImage(imgInfo, gmm); memory = memoryManager->allocateGraphicsMemoryForImage(imgInfo, gmm);
zeroCopy = true; if (memory && MemoryPool::isSystemMemoryPool(memory->getMemoryPool())) {
zeroCopy = true;
}
} }
} }
transferNeeded |= !!(flags & CL_MEM_COPY_HOST_PTR); transferNeeded |= !!(flags & CL_MEM_COPY_HOST_PTR);

11
runtime/memory_manager/os_agnostic_memory_manager.cpp
View File

@ -209,7 +209,16 @@ void OsAgnosticMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {
} }
} }
GraphicsAllocation *OsAgnosticMemoryManager::allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) { GraphicsAllocation *OsAgnosticMemoryManager::allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) {
auto alloc = allocateGraphicsMemory(imgInfo.size); GraphicsAllocation *alloc = nullptr;
if (!GmmHelper::allowTiling(*imgInfo.imgDesc) && imgInfo.mipCount == 0) {
alloc = allocateGraphicsMemory(imgInfo.size);
} else {
auto ptr = allocateSystemMemory(alignUp(imgInfo.size, MemoryConstants::pageSize), MemoryConstants::pageSize);
if (ptr != nullptr) {
alloc = new MemoryAllocation(true, ptr, reinterpret_cast<uint64_t>(ptr), imgInfo.size, counter, MemoryPool::SystemCpuInaccessible);
counter++;
}
}
if (alloc) { if (alloc) {
alloc->gmm = gmm; alloc->gmm = gmm;
} }

232
unit_tests/command_queue/enqueue_read_image_tests.cpp
View File

@ -298,61 +298,6 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DAndImageShareTheSameStorageWithHostPt
EXPECT_EQ(pCmdOOQ->taskLevel, 0u); EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
} }
HWTEST_F(EnqueueReadImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) { HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS; cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context)); std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
@ -382,143 +327,21 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithH
EXPECT_EQ(pCmdQ->taskLevel, 0u); EXPECT_EQ(pCmdQ->taskLevel, 0u);
} }
HWTEST_F(EnqueueReadImageTest, GivenImage2DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) { HWTEST_F(EnqueueReadImageTest, GivenSharedContextZeroCopy2DImageWhenEnqueueReadImageWithMappedPointerIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS; cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dArrayHelper<>::create(context)); context->isSharedContext = true;
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal); std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
EXPECT_TRUE(dstImage->isMemObjZeroCopy());
EXPECT_EQ(CL_SUCCESS, retVal); auto imageDesc = dstImage->getImageDesc();
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0}; size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1}; size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer(); void *ptr = dstImage->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch(); size_t rowPitch = dstImage->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch(); size_t slicePitch = dstImage->getHostPtrSlicePitch();
uint32_t taskLevelCmdQ = 17; retVal = pCmdQ->enqueueReadImage(dstImage.get(),
pCmdQ->taskLevel = taskLevelCmdQ;
uint32_t taskLevelEvent1 = 8;
uint32_t taskLevelEvent2 = 19;
Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
Event event2(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
cl_event eventWaitList[] =
{
&event1,
&event2};
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]);
cl_event event = nullptr;
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
numEventsInWaitList,
eventWaitList,
&event);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, event);
auto pEvent = (Event *)event;
EXPECT_EQ(19u, pEvent->taskLevel);
EXPECT_EQ(19u, pCmdQ->taskLevel);
EXPECT_EQ(CL_COMMAND_READ_IMAGE, (const int)pEvent->getCommandType());
pEvent->release();
}
HWTEST_F(EnqueueReadImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadReadImageIsCalledThenImageIsNotRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
uint32_t taskLevelCmdQ = 17;
pCmdOOQ->taskLevel = taskLevelCmdQ;
uint32_t taskLevelEvent1 = 8;
uint32_t taskLevelEvent2 = 19;
Event event1(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
Event event2(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
cl_event eventWaitList[] =
{
&event1,
&event2};
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]);
cl_event event = nullptr;
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
numEventsInWaitList,
eventWaitList,
&event);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, event);
auto pEvent = (Event *)event;
EXPECT_EQ(19u, pEvent->taskLevel);
EXPECT_EQ(19u, pCmdOOQ->taskLevel);
EXPECT_EQ(CL_COMMAND_READ_IMAGE, (const int)pEvent->getCommandType());
pEvent->release();
}
HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsRead) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
CL_FALSE, CL_FALSE,
origin, origin,
region, region,
@ -532,7 +355,42 @@ HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorag
EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 2u); EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadImageTest, GivenImage1DThatIsZeroCopyWhenReadImageWithTheSamePointerAndOutputEventIsPassedThenEventHasCorrectCommandTypeSet) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage(Image1dHelper<>::create(context));
auto imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage->getHostPtrRowPitch();
size_t slicePitch = dstImage->getHostPtrSlicePitch();
cl_uint numEventsInWaitList = 0;
cl_event event = nullptr;
retVal = pCmdQ->enqueueReadImage(dstImage.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
numEventsInWaitList,
nullptr,
&event);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, event);
auto pEvent = static_cast<Event *>(event);
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_READ_IMAGE), pEvent->getCommandType());
pEvent->release();
} }
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) { HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {

219
unit_tests/command_queue/enqueue_write_image_tests.cpp
View File

@ -281,61 +281,6 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DAndImageShareTheSameStorageWithHostP
EXPECT_EQ(pCmdOOQ->taskLevel, 0u); EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
} }
HWTEST_F(EnqueueWriteImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdQ->enqueueWriteImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdOOQ->enqueueWriteImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) { HWTEST_F(EnqueueWriteImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS; cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context)); std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
@ -365,59 +310,51 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DArrayAndImageShareTheSameStorageWith
EXPECT_EQ(pCmdQ->taskLevel, 0u); EXPECT_EQ(pCmdQ->taskLevel, 0u);
} }
HWTEST_F(EnqueueWriteImageTest, GivenImage2DArrayAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWritten) { HWTEST_F(EnqueueWriteImageTest, GivenSharedContextZeroCopy2DImageWhenEnqueueWriteImageWithMappedPointerIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS; cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dArrayHelper<>::create(context)); context->isSharedContext = true;
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdOOQ->enqueueWriteImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal); std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
EXPECT_TRUE(dstImage->isMemObjZeroCopy());
EXPECT_EQ(CL_SUCCESS, retVal); auto imageDesc = dstImage->getImageDesc();
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0}; size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1}; size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer(); void *ptr = dstImage->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch(); size_t rowPitch = dstImage->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch(); size_t slicePitch = dstImage->getHostPtrSlicePitch();
uint32_t taskLevelCmdQ = 17; retVal = pCmdQ->enqueueReadImage(dstImage.get(),
pCmdQ->taskLevel = taskLevelCmdQ; CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
uint32_t taskLevelEvent1 = 8; EXPECT_EQ(CL_SUCCESS, retVal);
uint32_t taskLevelEvent2 = 19;
Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
Event event2(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
cl_event eventWaitList[] = EXPECT_EQ(CL_SUCCESS, retVal);
{ EXPECT_EQ(pCmdQ->taskLevel, 0u);
&event1, }
&event2};
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]); HWTEST_F(EnqueueWriteImageTest, GivenImage1DThatIsZeroCopyWhenWriteImageWithTheSamePointerAndOutputEventIsPassedThenEventHasCorrectCommandTypeSet) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> srcImage(Image1dHelper<>::create(context));
auto imageDesc = srcImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = srcImage->getCpuAddressForMemoryTransfer();
size_t rowPitch = srcImage->getHostPtrRowPitch();
size_t slicePitch = srcImage->getHostPtrSlicePitch();
cl_uint numEventsInWaitList = 0;
cl_event event = nullptr; cl_event event = nullptr;
retVal = pCmdQ->enqueueWriteImage(dstImage2.get(), retVal = pCmdQ->enqueueWriteImage(srcImage.get(),
CL_FALSE, CL_FALSE,
origin, origin,
region, region,
@ -425,7 +362,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage2DAndImageShareTheSameStorageWithHostP
slicePitch, slicePitch,
ptr, ptr,
numEventsInWaitList, numEventsInWaitList,
eventWaitList, nullptr,
&event); &event);
EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(CL_SUCCESS, retVal);
@ -433,92 +370,12 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage2DAndImageShareTheSameStorageWithHostP
EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, event); ASSERT_NE(nullptr, event);
auto pEvent = (Event *)event; auto pEvent = static_cast<Event *>(event);
EXPECT_EQ(19u, pEvent->taskLevel); EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_WRITE_IMAGE), pEvent->getCommandType());
EXPECT_EQ(19u, pCmdQ->taskLevel);
EXPECT_EQ(CL_COMMAND_WRITE_IMAGE, (const int)pEvent->getCommandType());
pEvent->release(); pEvent->release();
} }
HWTEST_F(EnqueueWriteImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadWriteImageIsCalledThenImageIsNotWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
auto imageDesc = dstImage2->getImageDesc();
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
uint32_t taskLevelCmdQ = 17;
pCmdOOQ->taskLevel = taskLevelCmdQ;
uint32_t taskLevelEvent1 = 8;
uint32_t taskLevelEvent2 = 19;
Event event1(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
Event event2(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
cl_event eventWaitList[] =
{
&event1,
&event2};
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]);
cl_event event = nullptr;
retVal = pCmdOOQ->enqueueWriteImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
numEventsInWaitList,
eventWaitList,
&event);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, event);
auto pEvent = (Event *)event;
EXPECT_EQ(19u, pEvent->taskLevel);
EXPECT_EQ(19u, pCmdOOQ->taskLevel);
EXPECT_EQ(CL_COMMAND_WRITE_IMAGE, (const int)pEvent->getCommandType());
pEvent->release();
}
HWTEST_F(EnqueueWriteImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsWritten) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage2->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
size_t rowPitch = dstImage2->getHostPtrRowPitch();
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
retVal = pCmdQ->enqueueWriteImage(dstImage2.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 2u);
}
typedef EnqueueWriteImageMipMapTest MipMapWriteImageTest; typedef EnqueueWriteImageMipMapTest MipMapWriteImageTest;
HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) { HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) {

7
unit_tests/command_stream/aub_command_stream_receiver_tests.cpp
View File

@ -1699,18 +1699,20 @@ class OsAgnosticMemoryManagerForImagesWithNoHostPtr : public OsAgnosticMemoryMan
return imageAllocation; return imageAllocation;
}; };
void freeGraphicsMemoryImpl(GraphicsAllocation *imageAllocation) override { void freeGraphicsMemoryImpl(GraphicsAllocation *imageAllocation) override {
imageAllocation->setCpuPtrAndGpuAddress(lockResourceParam.retCpuPtr, imageAllocation->getGpuAddress()); imageAllocation->setCpuPtrAndGpuAddress(cpuPtr, imageAllocation->getGpuAddress());
OsAgnosticMemoryManager::freeGraphicsMemoryImpl(imageAllocation); OsAgnosticMemoryManager::freeGraphicsMemoryImpl(imageAllocation);
}; };
void *lockResource(GraphicsAllocation *imageAllocation) override { void *lockResource(GraphicsAllocation *imageAllocation) override {
lockResourceParam.wasCalled = true; lockResourceParam.wasCalled = true;
lockResourceParam.inImageAllocation = imageAllocation; lockResourceParam.inImageAllocation = imageAllocation;
lockResourceParam.retCpuPtr = cpuPtr; lockCpuPtr = alignedMalloc(imageAllocation->getUnderlyingBufferSize(), MemoryConstants::pageSize);
lockResourceParam.retCpuPtr = lockCpuPtr;
return lockResourceParam.retCpuPtr; return lockResourceParam.retCpuPtr;
}; };
void unlockResource(GraphicsAllocation *imageAllocation) override { void unlockResource(GraphicsAllocation *imageAllocation) override {
unlockResourceParam.wasCalled = true; unlockResourceParam.wasCalled = true;
unlockResourceParam.inImageAllocation = imageAllocation; unlockResourceParam.inImageAllocation = imageAllocation;
alignedFree(lockCpuPtr);
}; };
struct LockResourceParam { struct LockResourceParam {
@ -1725,6 +1727,7 @@ class OsAgnosticMemoryManagerForImagesWithNoHostPtr : public OsAgnosticMemoryMan
protected: protected:
void *cpuPtr = nullptr; void *cpuPtr = nullptr;
void *lockCpuPtr = nullptr;
}; };
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnImageWithNoHostPtrThenResourceShouldBeLockedToGetCpuAddress) { HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnImageWithNoHostPtrThenResourceShouldBeLockedToGetCpuAddress) {

7
unit_tests/mem_obj/image2d_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017, Intel Corporation * Copyright (c) 2017 - 2018, Intel Corporation
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -103,10 +103,7 @@ HWTEST_P(CreateImage2DType, validTypes) {
} }
EXPECT_EQ(image->getCubeFaceIndex(), static_cast<uint32_t>(__GMM_NO_CUBE_MAP)); EXPECT_EQ(image->getCubeFaceIndex(), static_cast<uint32_t>(__GMM_NO_CUBE_MAP));
EXPECT_FALSE(image->isMemObjZeroCopy());
ASSERT_EQ(true, image->isMemObjZeroCopy());
auto address = image->getCpuAddress();
EXPECT_NE(nullptr, address);
typedef typename FamilyType::RENDER_SURFACE_STATE SURFACE_STATE; typedef typename FamilyType::RENDER_SURFACE_STATE SURFACE_STATE;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image); auto imageHw = static_cast<ImageHw<FamilyType> *>(image);

7
unit_tests/mem_obj/image3d_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017, Intel Corporation * Copyright (c) 2017 - 2018, Intel Corporation
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -89,10 +89,7 @@ HWTEST_F(CreateImage3DTest, validTypes) {
EXPECT_NE(0u, imgDesc.image_row_pitch); EXPECT_NE(0u, imgDesc.image_row_pitch);
EXPECT_EQ(image->getCubeFaceIndex(), static_cast<uint32_t>(__GMM_NO_CUBE_MAP)); EXPECT_EQ(image->getCubeFaceIndex(), static_cast<uint32_t>(__GMM_NO_CUBE_MAP));
EXPECT_FALSE(image->isMemObjZeroCopy());
ASSERT_EQ(true, image->isMemObjZeroCopy());
auto address = image->getCpuAddress();
EXPECT_NE(nullptr, address);
typedef typename FamilyType::RENDER_SURFACE_STATE SURFACE_STATE; typedef typename FamilyType::RENDER_SURFACE_STATE SURFACE_STATE;
auto imageHw = static_cast<ImageHw<FamilyType> *>(image); auto imageHw = static_cast<ImageHw<FamilyType> *>(image);

26
unit_tests/mem_obj/image_array_size_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017, Intel Corporation * Copyright (c) 2017 - 2018, Intel Corporation
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -96,9 +96,15 @@ HWTEST_P(CreateImageArraySize, arrayTypes) {
ASSERT_EQ(CL_SUCCESS, retVal); ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, image); ASSERT_NE(nullptr, image);
ASSERT_EQ(true, image->isMemObjZeroCopy());
auto address = image->getCpuAddress(); if (types == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
EXPECT_NE(nullptr, address); EXPECT_TRUE(image->isMemObjZeroCopy());
auto address = image->getCpuAddress();
EXPECT_NE(nullptr, address);
} else if (types == CL_MEM_OBJECT_IMAGE2D_ARRAY) {
EXPECT_FALSE(image->isMemObjZeroCopy());
}
ASSERT_EQ(10u, image->getImageDesc().image_array_size); ASSERT_EQ(10u, image->getImageDesc().image_array_size);
delete image; delete image;
@ -129,9 +135,13 @@ HWTEST_P(CreateImageNonArraySize, NonArrayTypes) {
ASSERT_EQ(CL_SUCCESS, retVal); ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, image); ASSERT_NE(nullptr, image);
ASSERT_EQ(true, image->isMemObjZeroCopy()); if (types == CL_MEM_OBJECT_IMAGE2D || types == CL_MEM_OBJECT_IMAGE3D) {
auto address = image->getCpuAddress(); EXPECT_FALSE(image->isMemObjZeroCopy());
EXPECT_NE(nullptr, address); } else {
EXPECT_TRUE(image->isMemObjZeroCopy());
auto address = image->getCpuAddress();
EXPECT_NE(nullptr, address);
}
ASSERT_EQ(0u, image->getImageDesc().image_array_size); ASSERT_EQ(0u, image->getImageDesc().image_array_size);
delete image; delete image;
@ -257,4 +267,4 @@ static cl_mem_object_type AllImageTypesWithBadOne[] = {
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
ImageArraySizeTest_Create, ImageArraySizeTest_Create,
CreateImageOffset, CreateImageOffset,
testing::ValuesIn(AllImageTypesWithBadOne)); testing::ValuesIn(AllImageTypesWithBadOne));

17
unit_tests/mem_obj/image_tests.cpp
View File

@ -352,6 +352,7 @@ TEST(TestCreateImage, UseSharedContextToCreateImage) {
EXPECT_EQ((width + 1) * elementSize, image->getHostPtrRowPitch()); EXPECT_EQ((width + 1) * elementSize, image->getHostPtrRowPitch());
EXPECT_EQ(0u, image->getHostPtrSlicePitch()); EXPECT_EQ(0u, image->getHostPtrSlicePitch());
EXPECT_TRUE(image->isMemObjZeroCopy());
delete image; delete image;
@ -424,9 +425,6 @@ TEST_P(CreateImageNoHostPtr, validFlags) {
ASSERT_EQ(CL_SUCCESS, retVal); ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, image); ASSERT_NE(nullptr, image);
ASSERT_EQ(true, image->isMemObjZeroCopy());
auto address = image->getCpuAddress();
EXPECT_NE(nullptr, address);
delete image; delete image;
} }
@ -535,7 +533,7 @@ TEST_P(CreateImageHostPtr, getAddress) {
image = createImage(retVal); image = createImage(retVal);
ASSERT_NE(nullptr, image); ASSERT_NE(nullptr, image);
auto address = image->getCpuAddress(); auto address = image->getBasePtrForMap();
EXPECT_NE(nullptr, address); EXPECT_NE(nullptr, address);
if (!(flags & CL_MEM_USE_HOST_PTR)) { if (!(flags & CL_MEM_USE_HOST_PTR)) {
@ -557,18 +555,13 @@ TEST_P(CreateImageHostPtr, getAddress) {
bool copyRequired = (alignedRequiredSize > alignedPtrSize) | (requiredRowPitch != rowPitch) | (slicePitch != requiredSlicePitch); bool copyRequired = (alignedRequiredSize > alignedPtrSize) | (requiredRowPitch != rowPitch) | (slicePitch != requiredSlicePitch);
EXPECT_EQ(pHostPtr, address);
EXPECT_EQ(pHostPtr, image->getHostPtr());
if (copyRequired) { if (copyRequired) {
// Buffer should use host ptr
EXPECT_NE(pHostPtr, address);
EXPECT_EQ(pHostPtr, image->getHostPtr());
EXPECT_FALSE(image->isMemObjZeroCopy()); EXPECT_FALSE(image->isMemObjZeroCopy());
} else {
// Buffer should use host ptr
EXPECT_EQ(pHostPtr, address);
EXPECT_TRUE(image->isMemObjZeroCopy());
} }
} else { } else {
// Buffer should have a different ptr
EXPECT_NE(pHostPtr, address); EXPECT_NE(pHostPtr, address);
} }

21
unit_tests/mem_obj/image_transfer_tests.cpp
View File

@ -21,6 +21,7 @@
*/ */
#include "unit_tests/fixtures/image_fixture.h" #include "unit_tests/fixtures/image_fixture.h"
#include "unit_tests/helpers/debug_manager_state_restore.h"
#include "unit_tests/mocks/mock_device.h" #include "unit_tests/mocks/mock_device.h"
#include "unit_tests/mocks/mock_context.h" #include "unit_tests/mocks/mock_context.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -72,7 +73,10 @@ class ImageHostPtrTransferTests : public testing::Test {
size_t hostPtrSlicePitch, hostPtrRowPitch, imageSlicePitch, imageRowPitch, pixelSize; size_t hostPtrSlicePitch, hostPtrRowPitch, imageSlicePitch, imageRowPitch, pixelSize;
}; };
TEST_F(ImageHostPtrTransferTests, given3dImageWhenTransferToHostPtrCalledThenCopyRequestedRegionAndOriginOnly) { TEST_F(ImageHostPtrTransferTests, given3dImageWithoutTilingWhenTransferToHostPtrCalledThenCopyRequestedRegionAndOriginOnly) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceLinearImages.set(true);
createImageAndSetTestParams<Image3dDefaults>(); createImageAndSetTestParams<Image3dDefaults>();
EXPECT_NE(hostPtrSlicePitch, imageSlicePitch); EXPECT_NE(hostPtrSlicePitch, imageSlicePitch);
EXPECT_NE(hostPtrRowPitch, imageRowPitch); EXPECT_NE(hostPtrRowPitch, imageRowPitch);
@ -93,7 +97,10 @@ TEST_F(ImageHostPtrTransferTests, given3dImageWhenTransferToHostPtrCalledThenCop
EXPECT_TRUE(memcmp(image->getHostPtr(), expectedHostPtr.get(), hostPtrSlicePitch * imgDesc->image_depth) == 0); EXPECT_TRUE(memcmp(image->getHostPtr(), expectedHostPtr.get(), hostPtrSlicePitch * imgDesc->image_depth) == 0);
} }
TEST_F(ImageHostPtrTransferTests, given3dImageWhenTransferFromHostPtrCalledThenCopyRequestedRegionAndOriginOnly) { TEST_F(ImageHostPtrTransferTests, given3dImageWithoutTilingWhenTransferFromHostPtrCalledThenCopyRequestedRegionAndOriginOnly) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceLinearImages.set(true);
createImageAndSetTestParams<Image3dDefaults>(); createImageAndSetTestParams<Image3dDefaults>();
EXPECT_NE(hostPtrSlicePitch, imageSlicePitch); EXPECT_NE(hostPtrSlicePitch, imageSlicePitch);
EXPECT_NE(hostPtrRowPitch, imageRowPitch); EXPECT_NE(hostPtrRowPitch, imageRowPitch);
@ -114,7 +121,10 @@ TEST_F(ImageHostPtrTransferTests, given3dImageWhenTransferFromHostPtrCalledThenC
EXPECT_TRUE(memcmp(image->getCpuAddress(), expectedImageData.get(), imageSlicePitch * imgDesc->image_depth) == 0); EXPECT_TRUE(memcmp(image->getCpuAddress(), expectedImageData.get(), imageSlicePitch * imgDesc->image_depth) == 0);
} }
TEST_F(ImageHostPtrTransferTests, given2dArrayImageWhenTransferToHostPtrCalledThenCopyRequestedRegionAndOriginOnly) { TEST_F(ImageHostPtrTransferTests, given2dArrayImageWithoutTilingWhenTransferToHostPtrCalledThenCopyRequestedRegionAndOriginOnly) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceLinearImages.set(true);
createImageAndSetTestParams<Image2dArrayDefaults>(); createImageAndSetTestParams<Image2dArrayDefaults>();
EXPECT_NE(hostPtrSlicePitch, imageSlicePitch); EXPECT_NE(hostPtrSlicePitch, imageSlicePitch);
EXPECT_NE(hostPtrRowPitch, imageRowPitch); EXPECT_NE(hostPtrRowPitch, imageRowPitch);
@ -135,7 +145,10 @@ TEST_F(ImageHostPtrTransferTests, given2dArrayImageWhenTransferToHostPtrCalledTh
EXPECT_TRUE(memcmp(image->getHostPtr(), expectedHostPtr.get(), hostPtrSlicePitch * imgDesc->image_array_size) == 0); EXPECT_TRUE(memcmp(image->getHostPtr(), expectedHostPtr.get(), hostPtrSlicePitch * imgDesc->image_array_size) == 0);
} }
TEST_F(ImageHostPtrTransferTests, given2dArrayImageWhenTransferFromHostPtrCalledThenCopyRequestedRegionAndOriginOnly) { TEST_F(ImageHostPtrTransferTests, given2dArrayImageWithoutTilingWhenTransferFromHostPtrCalledThenCopyRequestedRegionAndOriginOnly) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceLinearImages.set(true);
createImageAndSetTestParams<Image2dArrayDefaults>(); createImageAndSetTestParams<Image2dArrayDefaults>();
EXPECT_NE(hostPtrSlicePitch, imageSlicePitch); EXPECT_NE(hostPtrSlicePitch, imageSlicePitch);
EXPECT_NE(hostPtrRowPitch, imageRowPitch); EXPECT_NE(hostPtrRowPitch, imageRowPitch);