Skip to content

Commit aaf2f94

Browse files
HoppeMateuszCompute-Runtime-Automation
HoppeMateusz
authored and
Compute-Runtime-Automation
committed
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
1 parent 9ac3529 commit aaf2f94

10 files changed

+126
-387
lines changed

‎runtime/mem_obj/image.cpp

+3-1
Original file line numberDiff line numberDiff line change
@@ -250,7 +250,9 @@ Image *Image::create(Context *context,
250250
}
251251
} else {
252252
memory = memoryManager->allocateGraphicsMemoryForImage(imgInfo, gmm);
253-
zeroCopy = true;
253+
if (memory && MemoryPool::isSystemMemoryPool(memory->getMemoryPool())) {
254+
zeroCopy = true;
255+
}
254256
}
255257
}
256258
transferNeeded |= !!(flags & CL_MEM_COPY_HOST_PTR);

‎runtime/memory_manager/os_agnostic_memory_manager.cpp

+10-1
Original file line numberDiff line numberDiff line change
@@ -209,7 +209,16 @@ void OsAgnosticMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage) {
209209
}
210210
}
211211
GraphicsAllocation *OsAgnosticMemoryManager::allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) {
212-
auto alloc = allocateGraphicsMemory(imgInfo.size);
212+
GraphicsAllocation *alloc = nullptr;
213+
if (!GmmHelper::allowTiling(*imgInfo.imgDesc) && imgInfo.mipCount == 0) {
214+
alloc = allocateGraphicsMemory(imgInfo.size);
215+
} else {
216+
auto ptr = allocateSystemMemory(alignUp(imgInfo.size, MemoryConstants::pageSize), MemoryConstants::pageSize);
217+
if (ptr != nullptr) {
218+
alloc = new MemoryAllocation(true, ptr, reinterpret_cast<uint64_t>(ptr), imgInfo.size, counter, MemoryPool::SystemCpuInaccessible);
219+
counter++;
220+
}
221+
}
213222
if (alloc) {
214223
alloc->gmm = gmm;
215224
}

‎unit_tests/command_queue/enqueue_read_image_tests.cpp

+30-172
Original file line numberDiff line numberDiff line change
@@ -298,61 +298,6 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DAndImageShareTheSameStorageWithHostPt
298298
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
299299
}
300300

301-
HWTEST_F(EnqueueReadImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
302-
cl_int retVal = CL_SUCCESS;
303-
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
304-
auto imageDesc = dstImage2->getImageDesc();
305-
size_t origin[] = {0, 0, 0};
306-
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
307-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
308-
309-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
310-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
311-
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
312-
CL_FALSE,
313-
origin,
314-
region,
315-
rowPitch,
316-
slicePitch,
317-
ptr,
318-
0,
319-
nullptr,
320-
nullptr);
321-
322-
EXPECT_EQ(CL_SUCCESS, retVal);
323-
324-
EXPECT_EQ(CL_SUCCESS, retVal);
325-
EXPECT_EQ(pCmdQ->taskLevel, 0u);
326-
}
327-
328-
HWTEST_F(EnqueueReadImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
329-
cl_int retVal = CL_SUCCESS;
330-
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
331-
auto imageDesc = dstImage2->getImageDesc();
332-
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
333-
size_t origin[] = {0, 0, 0};
334-
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
335-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
336-
337-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
338-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
339-
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
340-
CL_FALSE,
341-
origin,
342-
region,
343-
rowPitch,
344-
slicePitch,
345-
ptr,
346-
0,
347-
nullptr,
348-
nullptr);
349-
350-
EXPECT_EQ(CL_SUCCESS, retVal);
351-
352-
EXPECT_EQ(CL_SUCCESS, retVal);
353-
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
354-
}
355-
356301
HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
357302
cl_int retVal = CL_SUCCESS;
358303
std::unique_ptr<Image> dstImage2(Image1dArrayHelper<>::create(context));
@@ -382,157 +327,70 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DArrayAndImageShareTheSameStorageWithH
382327
EXPECT_EQ(pCmdQ->taskLevel, 0u);
383328
}
384329

385-
HWTEST_F(EnqueueReadImageTest, GivenImage2DArrayAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsNotRead) {
330+
HWTEST_F(EnqueueReadImageTest, GivenSharedContextZeroCopy2DImageWhenEnqueueReadImageWithMappedPointerIsCalledThenImageIsNotRead) {
386331
cl_int retVal = CL_SUCCESS;
387-
std::unique_ptr<Image> dstImage2(Image2dArrayHelper<>::create(context));
388-
auto imageDesc = dstImage2->getImageDesc();
389-
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
390-
size_t origin[] = {0, 0, 0};
391-
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
392-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
393-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
394-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
395-
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
396-
CL_FALSE,
397-
origin,
398-
region,
399-
rowPitch,
400-
slicePitch,
401-
ptr,
402-
0,
403-
nullptr,
404-
nullptr);
332+
context->isSharedContext = true;
405333

406-
EXPECT_EQ(CL_SUCCESS, retVal);
334+
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
335+
EXPECT_TRUE(dstImage->isMemObjZeroCopy());
407336

408-
EXPECT_EQ(CL_SUCCESS, retVal);
409-
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
410-
}
411-
412-
HWTEST_F(EnqueueReadImageTest, GivenImage2DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadReadImageIsCalledThenImageIsNotRead) {
413-
cl_int retVal = CL_SUCCESS;
414-
std::unique_ptr<Image> dstImage2(Image2dHelper<>::create(context));
415-
auto imageDesc = dstImage2->getImageDesc();
337+
auto imageDesc = dstImage->getImageDesc();
416338
size_t origin[] = {0, 0, 0};
417339
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
418-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
340+
void *ptr = dstImage->getCpuAddressForMemoryTransfer();
419341

420-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
421-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
422-
uint32_t taskLevelCmdQ = 17;
423-
pCmdQ->taskLevel = taskLevelCmdQ;
424-
425-
uint32_t taskLevelEvent1 = 8;
426-
uint32_t taskLevelEvent2 = 19;
427-
Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
428-
Event event2(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
429-
430-
cl_event eventWaitList[] =
431-
{
432-
&event1,
433-
&event2};
434-
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]);
435-
cl_event event = nullptr;
436-
437-
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
342+
size_t rowPitch = dstImage->getHostPtrRowPitch();
343+
size_t slicePitch = dstImage->getHostPtrSlicePitch();
344+
retVal = pCmdQ->enqueueReadImage(dstImage.get(),
438345
CL_FALSE,
439346
origin,
440347
region,
441348
rowPitch,
442349
slicePitch,
443350
ptr,
444-
numEventsInWaitList,
445-
eventWaitList,
446-
&event);
351+
0,
352+
nullptr,
353+
nullptr);
447354

448355
EXPECT_EQ(CL_SUCCESS, retVal);
449356

450357
EXPECT_EQ(CL_SUCCESS, retVal);
451-
ASSERT_NE(nullptr, event);
452-
453-
auto pEvent = (Event *)event;
454-
EXPECT_EQ(19u, pEvent->taskLevel);
455-
EXPECT_EQ(19u, pCmdQ->taskLevel);
456-
EXPECT_EQ(CL_COMMAND_READ_IMAGE, (const int)pEvent->getCommandType());
457-
458-
pEvent->release();
358+
EXPECT_EQ(pCmdQ->taskLevel, 0u);
459359
}
460360

461-
HWTEST_F(EnqueueReadImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPtrAndEventsWhenReadReadImageIsCalledThenImageIsNotRead) {
361+
HWTEST_F(EnqueueReadImageTest, GivenImage1DThatIsZeroCopyWhenReadImageWithTheSamePointerAndOutputEventIsPassedThenEventHasCorrectCommandTypeSet) {
462362
cl_int retVal = CL_SUCCESS;
463-
std::unique_ptr<Image> dstImage2(Image3dHelper<>::create(context));
464-
auto imageDesc = dstImage2->getImageDesc();
465-
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
363+
std::unique_ptr<Image> dstImage(Image1dHelper<>::create(context));
364+
auto imageDesc = dstImage->getImageDesc();
466365
size_t origin[] = {0, 0, 0};
467-
size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_depth};
468-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
469-
470-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
471-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
472-
473-
uint32_t taskLevelCmdQ = 17;
474-
pCmdOOQ->taskLevel = taskLevelCmdQ;
475-
476-
uint32_t taskLevelEvent1 = 8;
477-
uint32_t taskLevelEvent2 = 19;
478-
Event event1(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent1, 4);
479-
Event event2(pCmdOOQ.get(), CL_COMMAND_NDRANGE_KERNEL, taskLevelEvent2, 10);
366+
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
367+
void *ptr = dstImage->getCpuAddressForMemoryTransfer();
368+
size_t rowPitch = dstImage->getHostPtrRowPitch();
369+
size_t slicePitch = dstImage->getHostPtrSlicePitch();
480370

481-
cl_event eventWaitList[] =
482-
{
483-
&event1,
484-
&event2};
485-
cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]);
371+
cl_uint numEventsInWaitList = 0;
486372
cl_event event = nullptr;
487373

488-
retVal = pCmdOOQ->enqueueReadImage(dstImage2.get(),
489-
CL_FALSE,
490-
origin,
491-
region,
492-
rowPitch,
493-
slicePitch,
494-
ptr,
495-
numEventsInWaitList,
496-
eventWaitList,
497-
&event);
498-
499-
EXPECT_EQ(CL_SUCCESS, retVal);
500-
501-
EXPECT_EQ(CL_SUCCESS, retVal);
502-
ASSERT_NE(nullptr, event);
503-
504-
auto pEvent = (Event *)event;
505-
EXPECT_EQ(19u, pEvent->taskLevel);
506-
EXPECT_EQ(19u, pCmdOOQ->taskLevel);
507-
EXPECT_EQ(CL_COMMAND_READ_IMAGE, (const int)pEvent->getCommandType());
508-
509-
pEvent->release();
510-
}
511-
HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsRead) {
512-
cl_int retVal = CL_SUCCESS;
513-
std::unique_ptr<Image> dstImage2(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
514-
auto imageDesc = dstImage2->getImageDesc();
515-
size_t origin[] = {0, 0, 0};
516-
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 1};
517-
void *ptr = dstImage2->getCpuAddressForMemoryTransfer();
518-
519-
size_t rowPitch = dstImage2->getHostPtrRowPitch();
520-
size_t slicePitch = dstImage2->getHostPtrSlicePitch();
521-
retVal = pCmdQ->enqueueReadImage(dstImage2.get(),
374+
retVal = pCmdQ->enqueueReadImage(dstImage.get(),
522375
CL_FALSE,
523376
origin,
524377
region,
525378
rowPitch,
526379
slicePitch,
527380
ptr,
528-
0,
381+
numEventsInWaitList,
529382
nullptr,
530-
nullptr);
383+
&event);
531384

532385
EXPECT_EQ(CL_SUCCESS, retVal);
533386

534387
EXPECT_EQ(CL_SUCCESS, retVal);
535-
EXPECT_EQ(pCmdQ->taskLevel, 2u);
388+
ASSERT_NE(nullptr, event);
389+
390+
auto pEvent = static_cast<Event *>(event);
391+
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_READ_IMAGE), pEvent->getCommandType());
392+
393+
pEvent->release();
536394
}
537395

538396
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {

0 commit comments

Comments
 (0)