intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Check zeroCopy flag for r/w images/buffers

Browse Source 
Change-Id: I7047ae8458bdf3528d6014137522a37561d15ab6
This commit is contained in:
mplewka
2018-02-07 14:48:24 +01:00
parent cece633e93
commit 4db1e3af6a
19 changed files with 316 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/command_queue/enqueue_read_buffer.h
View File

@@ -46,7 +46,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBuffer(
cl_event *event) {
cl_int retVal = CL_SUCCESS;
auto isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(offset, 0, ptr, CL_COMMAND_READ_BUFFER);
bool isMemTransferNeeded = buffer->isMemObjZeroCopy() ? buffer->checkIfMemoryTransferIsRequired(offset, 0, ptr, CL_COMMAND_READ_BUFFER) : true;
if ((DebugManager.flags.DoCpuCopyOnReadBuffer.get() ||
buffer->isReadWriteOnCpuAllowed(blockingRead, numEventsInWaitList, ptr, size)) &&
context->getDevice(0)->getDeviceInfo().cpuCopyAllowed) {

11
runtime/command_queue/enqueue_read_buffer_rect.h
View File

@@ -49,10 +49,13 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBufferRect(
cl_event *event) {
MultiDispatchInfo dispatchInfo;
size_t bufferOffset;
size_t hostOffset;
computeOffsetsValueForRectCommands(&bufferOffset, &hostOffset, bufferOrigin, hostOrigin, region, bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch);
auto isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(bufferOffset, hostOffset, ptr, CL_COMMAND_READ_BUFFER_RECT);
auto isMemTransferNeeded = true;
if (buffer->isMemObjZeroCopy()) {
size_t bufferOffset;
size_t hostOffset;
computeOffsetsValueForRectCommands(&bufferOffset, &hostOffset, bufferOrigin, hostOrigin, region, bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch);
isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(bufferOffset, hostOffset, ptr, CL_COMMAND_READ_BUFFER_RECT);
}
if (!isMemTransferNeeded) {
NullSurface s;
Surface *surfaces[] = {&s};

10
runtime/command_queue/enqueue_read_image.h
View File

@@ -50,10 +50,12 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadImage(
cl_event *event) {
MultiDispatchInfo di;
size_t hostOffset;
Image::calculateHostPtrOffset(&hostOffset, origin, region, inputRowPitch, inputSlicePitch, srcImage->getImageDesc().image_type, srcImage->getSurfaceFormatInfo().ImageElementSizeInBytes);
auto isMemTransferNeeded = srcImage->checkIfMemoryTransferIsRequired(hostOffset, 0, ptr, CL_COMMAND_READ_IMAGE);
auto isMemTransferNeeded = true;
if (srcImage->isMemObjZeroCopy()) {
size_t hostOffset;
Image::calculateHostPtrOffset(&hostOffset, origin, region, inputRowPitch, inputSlicePitch, srcImage->getImageDesc().image_type, srcImage->getSurfaceFormatInfo().ImageElementSizeInBytes);
isMemTransferNeeded = srcImage->checkIfMemoryTransferIsRequired(hostOffset, 0, ptr, CL_COMMAND_READ_IMAGE);
}
if (!isMemTransferNeeded) {
NullSurface s;
Surface *surfaces[] = {&s};

2
runtime/command_queue/enqueue_write_buffer.h
View File

@@ -45,7 +45,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBuffer(
cl_event *event) {
cl_int retVal = CL_SUCCESS;
auto isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(offset, 0, ptr, CL_COMMAND_WRITE_BUFFER);
auto isMemTransferNeeded = buffer->isMemObjZeroCopy() ? buffer->checkIfMemoryTransferIsRequired(offset, 0, ptr, CL_COMMAND_READ_BUFFER) : true;
if ((DebugManager.flags.DoCpuCopyOnWriteBuffer.get() ||
buffer->isReadWriteOnCpuAllowed(blockingWrite, numEventsInWaitList, const_cast<void *>(ptr), size)) &&
context->getDevice(0)->getDeviceInfo().cpuCopyAllowed) {

11
runtime/command_queue/enqueue_write_buffer_rect.h
View File

@@ -48,10 +48,13 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBufferRect(
cl_event *event) {
MultiDispatchInfo dispatchInfo;
size_t bufferOffset;
size_t hostOffset;
computeOffsetsValueForRectCommands(&bufferOffset, &hostOffset, bufferOrigin, hostOrigin, region, bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch);
auto isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(bufferOffset, hostOffset, ptr, CL_COMMAND_WRITE_BUFFER_RECT);
auto isMemTransferNeeded = true;
if (buffer->isMemObjZeroCopy()) {
size_t bufferOffset;
size_t hostOffset;
computeOffsetsValueForRectCommands(&bufferOffset, &hostOffset, bufferOrigin, hostOrigin, region, bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch);
isMemTransferNeeded = buffer->checkIfMemoryTransferIsRequired(bufferOffset, hostOffset, ptr, CL_COMMAND_WRITE_BUFFER_RECT);
}
if (!isMemTransferNeeded) {
NullSurface s;
Surface *surfaces[] = {&s};

9
runtime/command_queue/enqueue_write_image.h
View File

@@ -48,9 +48,12 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteImage(
cl_event *event) {
MultiDispatchInfo di;
size_t hostOffset;
Image::calculateHostPtrOffset(&hostOffset, origin, region, inputRowPitch, inputSlicePitch, dstImage->getImageDesc().image_type, dstImage->getSurfaceFormatInfo().ImageElementSizeInBytes);
auto isMemTransferNeeded = dstImage->checkIfMemoryTransferIsRequired(hostOffset, 0, ptr, CL_COMMAND_WRITE_IMAGE);
auto isMemTransferNeeded = true;
if (dstImage->isMemObjZeroCopy()) {
size_t hostOffset;
Image::calculateHostPtrOffset(&hostOffset, origin, region, inputRowPitch, inputSlicePitch, dstImage->getImageDesc().image_type, dstImage->getSurfaceFormatInfo().ImageElementSizeInBytes);
isMemTransferNeeded = dstImage->checkIfMemoryTransferIsRequired(hostOffset, 0, ptr, CL_COMMAND_WRITE_IMAGE);
}
if (!isMemTransferNeeded) {
NullSurface s;
Surface *surfaces[] = {&s};

16
unit_tests/command_queue/buffer_operations_fixture.h
View File

@@ -40,11 +40,14 @@ struct EnqueueWriteBufferTypeTest : public CommandEnqueueFixture,
void SetUp() override {
CommandEnqueueFixture::SetUp();
BufferDefaults::context = new MockContext;
srcBuffer = BufferHelper<BufferUseHostPtr<>>::create();
zeroCopyBuffer.reset(BufferHelper<>::create());
srcBuffer.reset(BufferHelper<BufferUseHostPtr<>>::create());
}
void TearDown() override {
delete srcBuffer;
srcBuffer.reset(nullptr);
zeroCopyBuffer.reset(nullptr);
delete BufferDefaults::context;
CommandEnqueueFixture::TearDown();
}
@@ -54,7 +57,7 @@ struct EnqueueWriteBufferTypeTest : public CommandEnqueueFixture,
void enqueueWriteBuffer(cl_bool blocking = EnqueueWriteBufferTraits::blocking) {
auto retVal = EnqueueWriteBufferHelper<>::enqueueWriteBuffer(
pCmdQ,
srcBuffer,
srcBuffer.get(),
blocking);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -65,7 +68,7 @@ struct EnqueueWriteBufferTypeTest : public CommandEnqueueFixture,
void enqueueWriteBuffer(bool Blocking, void *InputData, int size) {
auto retVal = EnqueueWriteBufferHelper<>::enqueueWriteBuffer(
pCmdQ,
srcBuffer,
srcBuffer.get(),
Blocking,
0,
size,
@@ -73,6 +76,7 @@ struct EnqueueWriteBufferTypeTest : public CommandEnqueueFixture,
EXPECT_EQ(CL_SUCCESS, retVal);
}
Buffer *srcBuffer;
std::unique_ptr<Buffer> srcBuffer;
std::unique_ptr<Buffer> zeroCopyBuffer;
};
}
} // namespace OCLRT

2
unit_tests/command_queue/enqueue_api_tests_mt_with_asyncGPU.cpp
View File

@@ -62,7 +62,7 @@ HWTEST_F(AsyncGPUoperations, MapBufferAfterWriteBuffer) {
while (!ThreadStarted)
;
auto retPtr = EnqueueMapBufferHelper<>::enqueueMapBuffer(pCmdQ, srcBuffer);
auto retPtr = EnqueueMapBufferHelper<>::enqueueMapBuffer(pCmdQ, srcBuffer.get());
EXPECT_NE(nullptr, retPtr);
char *outputPtr = static_cast<char *>(retPtr);

13
unit_tests/command_queue/enqueue_read_buffer_fixture.h
View File

@@ -39,11 +39,13 @@ struct EnqueueReadBufferTypeTest : public CommandEnqueueFixture,
void SetUp() override {
CommandEnqueueFixture::SetUp();
BufferDefaults::context = new MockContext;
srcBuffer = BufferHelper<>::create();
srcBuffer.reset(BufferHelper<>::create());
nonZeroCopyBuffer.reset(BufferHelper<BufferUseHostPtr<>>::create());
}
void TearDown() override {
delete srcBuffer;
srcBuffer.reset(nullptr);
nonZeroCopyBuffer.reset(nullptr);
delete BufferDefaults::context;
CommandEnqueueFixture::TearDown();
}
@@ -53,13 +55,14 @@ struct EnqueueReadBufferTypeTest : public CommandEnqueueFixture,
void enqueueReadBuffer(cl_bool blocking = CL_TRUE) {
auto retVal = EnqueueReadBufferHelper<>::enqueueReadBuffer(
pCmdQ,
srcBuffer,
srcBuffer.get(),
blocking);
EXPECT_EQ(CL_SUCCESS, retVal);
parseCommands<FamilyType>(*pCmdQ);
}
Buffer *srcBuffer;
std::unique_ptr<Buffer> srcBuffer;
std::unique_ptr<Buffer> nonZeroCopyBuffer;
};
}
} // namespace OCLRT

20
unit_tests/command_queue/enqueue_read_buffer_rect_fixture.h
View File

@@ -45,22 +45,27 @@ struct EnqueueReadBufferRectTest : public CommandEnqueueFixture,
CommandEnqueueFixture::SetUp();
contextMemoryManager = context.getMemoryManager();
context.setMemoryManager(pCmdQ->getDevice().getMemoryManager());
BufferDefaults::context = new MockContext;
//For 3D
hostPtr = ::alignedMalloc(slicePitch * rowPitch, 4096);
auto retVal = CL_INVALID_VALUE;
buffer = Buffer::create(
buffer.reset(Buffer::create(
&context,
CL_MEM_READ_WRITE,
slicePitch * rowPitch,
nullptr,
retVal);
ASSERT_NE(nullptr, buffer);
retVal));
ASSERT_NE(nullptr, buffer.get());
nonZeroCopyBuffer.reset(BufferHelper<BufferUseHostPtr<>>::create());
}
void TearDown() override {
delete buffer;
nonZeroCopyBuffer.reset(nullptr);
buffer.reset(nullptr);
delete BufferDefaults::context;
::alignedFree(hostPtr);
context.setMemoryManager(contextMemoryManager);
@@ -78,7 +83,7 @@ struct EnqueueReadBufferRectTest : public CommandEnqueueFixture,
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
auto retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
blocking, //non-blocking
bufferOrigin,
hostOrigin,
@@ -97,11 +102,12 @@ struct EnqueueReadBufferRectTest : public CommandEnqueueFixture,
}
MockContext context;
Buffer *buffer;
std::unique_ptr<Buffer> buffer;
std::unique_ptr<Buffer> nonZeroCopyBuffer;
void *hostPtr;
MemoryManager *contextMemoryManager;
static const size_t rowPitch = 100;
static const size_t slicePitch = 100 * 100;
};
}
} // namespace OCLRT

43
unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp
View File

@@ -62,7 +62,7 @@ HWTEST_F(EnqueueReadBufferRectTest, nullHostPtr) {
retVal = clEnqueueReadBufferRect(
pCmdQ,
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -87,7 +87,7 @@ HWTEST_F(EnqueueReadBufferRectTest, returnSuccess) {
retVal = clEnqueueReadBufferRect(
pCmdQ,
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -187,7 +187,7 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_addsIndirectData) {
ASSERT_NE(nullptr, &builder);
BuiltinDispatchInfoBuilder::BuiltinOpParams dc;
dc.srcMemObj = buffer;
dc.srcMemObj = buffer.get();
dc.dstPtr = hostPtr;
dc.srcOffset = {0, 0, 0};
dc.dstOffset = {0, 0, 0};
@@ -410,7 +410,7 @@ HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndDstPtrEqualSrcPtrWithEve
size_t region[] = {50, 50, 1};
void *ptr = buffer->getCpuAddressForMemoryTransfer();
retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -457,7 +457,7 @@ HWTEST_F(EnqueueReadBufferRectTest, givenOutOfOrderQueueAndDstPtrEqualSrcPtrWith
size_t region[] = {50, 50, 1};
void *ptr = buffer->getCpuAddressForMemoryTransfer();
retVal = pCmdOOQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -489,7 +489,7 @@ HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndRowPitchEqualZeroAndDstP
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -514,7 +514,7 @@ HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndSlicePitchEqualZeroAndDs
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -541,7 +541,7 @@ HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndMemObjWithOffsetPointThe
size_t hostOffset = (bufferOrigin[2] - hostOrigin[2]) * slicePitch + (bufferOrigin[1] - hostOrigin[1]) * rowPitch + (bufferOrigin[0] - hostOrigin[0]);
auto hostStorage = ptrOffset(ptr, hostOffset);
retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -566,7 +566,32 @@ HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndMemObjWithOffsetPointDif
size_t hostOrigin[] = {10, 10, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueReadBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
region,
rowPitch,
slicePitch,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}
HWTEST_F(EnqueueReadBufferRectTest, givenInOrderQueueAndDstPtrEqualSrcPtrAndNonZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelShouldBeIncreased) {
cl_int retVal = CL_SUCCESS;
void *ptr = nonZeroCopyBuffer->getCpuAddressForMemoryTransfer();
size_t bufferOrigin[] = {0, 0, 0};
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueReadBufferRect(
nonZeroCopyBuffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,

62
unit_tests/command_queue/enqueue_read_buffer_tests.cpp
View File

@@ -52,7 +52,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, null_user_pointer) {
auto retVal = clEnqueueReadBuffer(
pCmdQ,
srcBuffer,
srcBuffer.get(),
false,
0,
sizeof(data),
@@ -157,7 +157,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsIndirectData) {
BuiltinDispatchInfoBuilder::BuiltinOpParams dc;
dc.dstPtr = EnqueueReadBufferTraits::hostPtr;
dc.srcMemObj = srcBuffer;
dc.srcMemObj = srcBuffer.get();
dc.srcOffset = {EnqueueReadBufferTraits::offset, 0, 0};
dc.size = {srcBuffer->getSize(), 0, 0};
builder.buildDispatchInfos(multiDispatchInfo, dc);
@@ -362,7 +362,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, blockingRequiresPipeControlAfterWalkerWithDC
HWTEST_F(EnqueueReadBufferTypeTest, givenAlignedPointerAndAlignedSizeWhenReadBufferIsCalledThenRecordedL3IndexIsL3ON) {
void *ptr = (void *)0x1040;
cl_int retVal = pCmdQ->enqueueReadBuffer(srcBuffer,
cl_int retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -379,7 +379,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenAlignedPointerAndAlignedSizeWhenReadBuf
HWTEST_F(EnqueueReadBufferTypeTest, givenNotAlignedPointerAndAlignedSizeWhenReadBufferIsCalledThenRecordedL3IndexIsL3Off) {
void *ptr = (void *)0x1039;
cl_int retVal = pCmdQ->enqueueReadBuffer(srcBuffer,
cl_int retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -395,7 +395,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenNotAlignedPointerAndAlignedSizeWhenRead
void *ptr2 = (void *)0x1040;
retVal = pCmdQ->enqueueReadBuffer(srcBuffer,
retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -408,14 +408,14 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenNotAlignedPointerAndAlignedSizeWhenRead
EXPECT_FALSE(csr.disableL3Cache);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenReadBufferIsExecutedThenTaskLevelNotIncreased) {
HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelNotIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(true);
cl_int retVal = CL_SUCCESS;
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdOOQ->enqueueReadBuffer(srcBuffer,
retVal = pCmdOOQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -427,14 +427,14 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtr
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenReadBufferIsExecutedThenTaskLevelNotIncreased) {
HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelNotIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(false);
cl_int retVal = CL_SUCCESS;
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdOOQ->enqueueReadBuffer(srcBuffer,
retVal = pCmdOOQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -446,13 +446,13 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPt
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenReadBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(true);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueReadBuffer(srcBuffer,
retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -464,13 +464,13 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesA
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenReadBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(false);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueReadBuffer(srcBuffer,
retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -481,4 +481,40 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopies
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndNonZeroCopyBufferWhenReadBufferIsExecutedThenTaskLevelShouldBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(false);
cl_int retVal = CL_SUCCESS;
void *ptr = nonZeroCopyBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueReadBuffer(nonZeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}
HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndNonZeroCopyWhenReadBufferIsExecutedThenTaskLevelShouldBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnReadBuffer.set(true);
cl_int retVal = CL_SUCCESS;
void *ptr = nonZeroCopyBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueReadBuffer(nonZeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}

26
unit_tests/command_queue/enqueue_read_image_tests.cpp
View File

@@ -561,4 +561,30 @@ HWTEST_F(EnqueueReadImageTest, GivenImage3DAndImageShareTheSameStorageWithHostPt
EXPECT_EQ(CL_COMMAND_READ_IMAGE, (const int)pEvent->getCommandType());
pEvent->release();
}
HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadReadImageIsCalledThenImageIsReaded) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
auto imageDesc = dstImage2->getImageDesc();
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 = 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);
}

23
unit_tests/command_queue/enqueue_write_buffer_rect_fixture.h
View File

@@ -27,6 +27,7 @@
#include "runtime/helpers/aligned_memory.h"
#include "unit_tests/command_queue/command_enqueue_fixture.h"
#include "unit_tests/fixtures/memory_management_fixture.h"
#include "unit_tests/fixtures/buffer_fixture.h"
#include "gen_cmd_parse.h"
#include "unit_tests/mocks/mock_context.h"
@@ -47,22 +48,28 @@ struct EnqueueWriteBufferRectTest : public CommandEnqueueFixture,
contextMemoryManager = context.getMemoryManager();
context.setMemoryManager(pCmdQ->getDevice().getMemoryManager());
BufferDefaults::context = new MockContext;
//For 3D
hostPtr = ::alignedMalloc(slicePitch * rowPitch, 4096);
auto retVal = CL_INVALID_VALUE;
buffer = Buffer::create(
buffer.reset(Buffer::create(
&context,
CL_MEM_READ_WRITE,
slicePitch * rowPitch,
nullptr,
retVal);
ASSERT_NE(nullptr, buffer);
retVal));
nonZeroCopyBuffer.reset(BufferHelper<BufferUseHostPtr<>>::create());
ASSERT_NE(nullptr, buffer.get());
}
void TearDown() override {
delete buffer;
buffer.reset(nullptr);
nonZeroCopyBuffer.reset(nullptr);
delete BufferDefaults::context;
::alignedFree(hostPtr);
context.setMemoryManager(contextMemoryManager);
@@ -80,7 +87,7 @@ struct EnqueueWriteBufferRectTest : public CommandEnqueueFixture,
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
auto retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
blocking,
bufferOrigin,
hostOrigin,
@@ -99,7 +106,9 @@ struct EnqueueWriteBufferRectTest : public CommandEnqueueFixture,
}
MockContext context;
Buffer *buffer;
std::unique_ptr<Buffer> buffer;
std::unique_ptr<Buffer> nonZeroCopyBuffer;
void *hostPtr;
MemoryManager *contextMemoryManager;
@@ -107,4 +116,4 @@ struct EnqueueWriteBufferRectTest : public CommandEnqueueFixture,
static const size_t rowPitch = 100;
static const size_t slicePitch = 100 * 100;
};
}
} // namespace OCLRT

45
unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp
View File

@@ -62,7 +62,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, returnSuccess) {
retVal = clEnqueueWriteBufferRect(
pCmdQ,
buffer,
buffer.get(),
CL_TRUE,
srcOrigin,
dstOrigin,
@@ -162,7 +162,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, 2D_addsIndirectData) {
BuiltinDispatchInfoBuilder::BuiltinOpParams dc;
dc.srcPtr = hostPtr;
dc.dstMemObj = buffer;
dc.dstMemObj = buffer.get();
dc.srcOffset = {0, 0, 0};
dc.dstOffset = {0, 0, 0};
dc.size = {50, 50, 1};
@@ -343,7 +343,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndDstPtrEqualSrcPtrWhenWr
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -369,7 +369,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenOutOfOrderQueueAndDstPtrEqualSrcPtrWhe
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdOOQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -407,7 +407,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndDstPtrEqualSrcPtrWithEv
size_t region[] = {50, 50, 1};
void *ptr = buffer->getCpuAddressForMemoryTransfer();
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -454,7 +454,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenOutOfOrderQueueAndDstPtrEqualSrcPtrWit
size_t region[] = {50, 50, 1};
void *ptr = buffer->getCpuAddressForMemoryTransfer();
retVal = pCmdOOQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -486,7 +486,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndRowPitchEqualZeroAndDst
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -511,7 +511,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndSlicePitchEqualZeroAndD
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -538,7 +538,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndMemObjWithOffsetPointTh
size_t hostOffset = (bufferOrigin[2] - hostOrigin[2]) * slicePitch + (bufferOrigin[1] - hostOrigin[1]) * rowPitch + (bufferOrigin[0] - hostOrigin[0]);
auto hostStorage = ptrOffset(ptr, hostOffset);
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
@@ -563,7 +563,32 @@ HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndMemObjWithOffsetPointDi
size_t hostOrigin[] = {10, 10, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueWriteBufferRect(
buffer,
buffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,
region,
rowPitch,
slicePitch,
rowPitch,
slicePitch,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}
HWTEST_F(EnqueueWriteBufferRectTest, givenInOrderQueueAndDstPtrEqualSrcPtrAndNonZeroCopyBufferWhenWriteBufferIsExecutedThenTaskLevelShouldBeIncreased) {
cl_int retVal = CL_SUCCESS;
void *ptr = nonZeroCopyBuffer->getCpuAddressForMemoryTransfer();
size_t bufferOrigin[] = {0, 0, 0};
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {50, 50, 1};
retVal = pCmdQ->enqueueWriteBufferRect(
nonZeroCopyBuffer.get(),
CL_FALSE,
bufferOrigin,
hostOrigin,

62
unit_tests/command_queue/enqueue_write_buffer_tests.cpp
View File

@@ -51,7 +51,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, null_user_pointer) {
auto retVal = clEnqueueWriteBuffer(
pCmdQ,
srcBuffer,
srcBuffer.get(),
false,
0,
sizeof(data),
@@ -152,7 +152,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, addsIndirectData) {
BuiltinDispatchInfoBuilder::BuiltinOpParams dc;
dc.srcPtr = EnqueueWriteBufferTraits::hostPtr;
dc.dstMemObj = srcBuffer;
dc.dstMemObj = srcBuffer.get();
dc.dstOffset = {EnqueueWriteBufferTraits::offset, 0, 0};
dc.size = {srcBuffer->getSize(), 0, 0};
builder.buildDispatchInfos(multiDispatchInfo, dc);
@@ -326,14 +326,14 @@ HWTEST_F(EnqueueWriteBufferTypeTest, MediaVFEState) {
// Generically validate this command
FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorCmd);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelNotIncreased) {
HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrAndZeroCopyBufferTrueWhenWriteBufferIsExecutedThenTaskLevelNotIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(true);
cl_int retVal = CL_SUCCESS;
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
void *ptr = zeroCopyBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdOOQ->enqueueWriteBuffer(srcBuffer,
retVal = pCmdOOQ->enqueueWriteBuffer(zeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -345,14 +345,14 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPt
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelNotIncreased) {
HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrZeroCopyBufferWhenWriteBufferIsExecutedThenTaskLevelNotIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(false);
cl_int retVal = CL_SUCCESS;
std::unique_ptr<CommandQueue> pCmdOOQ(createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE));
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdOOQ->enqueueWriteBuffer(srcBuffer,
retVal = pCmdOOQ->enqueueWriteBuffer(zeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -364,13 +364,13 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstP
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdOOQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrZeroCopyBufferEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(true);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
void *ptr = zeroCopyBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueWriteBuffer(srcBuffer,
retVal = pCmdQ->enqueueWriteBuffer(zeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -382,13 +382,13 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopies
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrZeroCopyBufferEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldNotBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(false);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
void *ptr = zeroCopyBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueWriteBuffer(srcBuffer,
retVal = pCmdQ->enqueueWriteBuffer(zeroCopyBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
@@ -399,4 +399,40 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopie
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 0u);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrZeroCopyBufferEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(false);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueWriteBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}
HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesAndDstPtrNonZeroCopyBufferEqualSrcPtrWhenWriteBufferIsExecutedThenTaskLevelShouldBeIncreased) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.DoCpuCopyOnWriteBuffer.set(true);
cl_int retVal = CL_SUCCESS;
void *ptr = srcBuffer->getCpuAddressForMemoryTransfer();
EXPECT_EQ(retVal, CL_SUCCESS);
retVal = pCmdQ->enqueueWriteBuffer(srcBuffer.get(),
CL_FALSE,
0,
MemoryConstants::cacheLineSize,
ptr,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(pCmdQ->taskLevel, 1u);
}

26
unit_tests/command_queue/enqueue_write_image_tests.cpp
View File

@@ -546,4 +546,30 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage3DAndImageShareTheSameStorageWithHostP
EXPECT_EQ(CL_COMMAND_WRITE_IMAGE, (const int)pEvent->getCommandType());
pEvent->release();
}
HWTEST_F(EnqueueWriteImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorageWithHostPtrWhenReadWriteImageIsCalledThenImageIsNotWrited) {
cl_int retVal = CL_SUCCESS;
std::unique_ptr<Image> dstImage2(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
auto imageDesc = dstImage2->getImageDesc();
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 = 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);
}

36
unit_tests/context/driver_diagnostics_enqueue_tests.cpp
View File

@@ -404,9 +404,9 @@ TEST_F(PerformanceHintEnqueueImageTest, GivenNonBlockingWriteImageSharesStorageW
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {1, 1, 1};
void *ptr = image->getCpuAddressForMemoryTransfer();
void *ptr = zeroCopyImage->getCpuAddressForMemoryTransfer();
pCmdQ->enqueueWriteImage(
image,
zeroCopyImage.get(),
CL_FALSE,
hostOrigin,
region,
@@ -417,7 +417,7 @@ TEST_F(PerformanceHintEnqueueImageTest, GivenNonBlockingWriteImageSharesStorageW
nullptr,
nullptr);
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_IMAGE_DOESNT_REQUIRES_COPY_DATA], static_cast<cl_mem>(image));
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_WRITE_IMAGE_DOESNT_REQUIRES_COPY_DATA], static_cast<cl_mem>(zeroCopyImage.get()));
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -426,9 +426,9 @@ TEST_F(PerformanceHintEnqueueImageTest, GivenNonBlockingReadImageSharesStorageWi
size_t hostOrigin[] = {0, 0, 0};
size_t region[] = {1, 1, 1};
void *ptr = image->getCpuAddressForMemoryTransfer();
void *ptr = zeroCopyImage->getCpuAddressForMemoryTransfer();
pCmdQ->enqueueReadImage(
image,
zeroCopyImage.get(),
CL_FALSE,
hostOrigin,
region,
@@ -439,7 +439,7 @@ TEST_F(PerformanceHintEnqueueImageTest, GivenNonBlockingReadImageSharesStorageWi
nullptr,
nullptr);
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_IMAGE_DOESNT_REQUIRES_COPY_DATA], static_cast<cl_mem>(image));
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_READ_IMAGE_DOESNT_REQUIRES_COPY_DATA], static_cast<cl_mem>(zeroCopyImage.get()));
EXPECT_TRUE(containsHint(expectedHint, userData));
}
@@ -471,19 +471,19 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueMapBufferIsCal
TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueMapImageIsCallingThenContextProvidesProperHint) {
Image *image;
bool zeroCopyImage;
bool isZeroCopyImage;
zeroCopyImage = GetParam();
isZeroCopyImage = GetParam();
size_t origin[] = {0, 0, 0};
size_t region[] = {1, 1, 1};
if (zeroCopyImage) {
if (isZeroCopyImage) {
image = ImageHelper<ImageReadOnly<Image1dDefaults>>::create(context);
} else {
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
}
EXPECT_EQ(zeroCopyImage, image->isMemObjZeroCopy());
EXPECT_EQ(isZeroCopyImage, image->isMemObjZeroCopy());
pCmdQ->enqueueMapImage(
image,
CL_FALSE,
@@ -498,10 +498,10 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueMapImageIsCall
retVal);
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_MAP_IMAGE_DOESNT_REQUIRE_COPY_DATA], static_cast<cl_mem>(image));
EXPECT_EQ(zeroCopyImage, containsHint(expectedHint, userData));
EXPECT_EQ(isZeroCopyImage, containsHint(expectedHint, userData));
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_MAP_IMAGE_REQUIRES_COPY_DATA], static_cast<cl_mem>(image));
EXPECT_EQ(!zeroCopyImage, containsHint(expectedHint, userData));
EXPECT_EQ(!isZeroCopyImage, containsHint(expectedHint, userData));
delete image;
}
@@ -535,29 +535,29 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueUnmapIsCalling
TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueUnmapIsCallingWithImageThenContextProvidesProperHint) {
Image *image;
bool zeroCopyImage;
bool isZeroCopyImage;
zeroCopyImage = GetParam();
isZeroCopyImage = GetParam();
size_t origin[] = {0, 0, 0};
size_t region[] = {1, 1, 1};
if (zeroCopyImage) {
if (isZeroCopyImage) {
image = ImageHelper<ImageReadOnly<Image1dDefaults>>::create(context);
} else {
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
}
EXPECT_EQ(zeroCopyImage, image->isMemObjZeroCopy());
EXPECT_EQ(isZeroCopyImage, image->isMemObjZeroCopy());
void *mapPtr = pCmdQ->enqueueMapImage(image, CL_FALSE, 0, origin, region, nullptr, nullptr, 0, nullptr, nullptr, retVal);
pCmdQ->enqueueUnmapMemObject(image, mapPtr, 0, nullptr, nullptr);
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_UNMAP_MEM_OBJ_REQUIRES_COPY_DATA], mapPtr, static_cast<cl_mem>(image));
EXPECT_EQ(!zeroCopyImage, containsHint(expectedHint, userData));
EXPECT_EQ(!isZeroCopyImage, containsHint(expectedHint, userData));
snprintf(expectedHint, DriverDiagnostics::maxHintStringSize, DriverDiagnostics::hintFormat[CL_ENQUEUE_UNMAP_MEM_OBJ_DOESNT_REQUIRE_COPY_DATA], mapPtr);
EXPECT_EQ(zeroCopyImage, containsHint(expectedHint, userData));
EXPECT_EQ(isZeroCopyImage, containsHint(expectedHint, userData));
delete image;
}

3
unit_tests/context/driver_diagnostics_tests.h
View File

@@ -203,15 +203,18 @@ struct PerformanceHintEnqueueImageTest : public PerformanceHintEnqueueTest {
PerformanceHintEnqueueTest::SetUp();
address = alignedMalloc(2 * MemoryConstants::cacheLineSize, MemoryConstants::cacheLineSize);
image = ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context);
zeroCopyImage.reset(ImageHelper<Image1dDefaults>::create(context));
}
void TearDown() override {
delete image;
zeroCopyImage.reset(nullptr);
alignedFree(address);
PerformanceHintEnqueueTest::TearDown();
}
void *address;
Image *image;
std::unique_ptr<Image> zeroCopyImage;
};
struct PerformanceHintEnqueueReadImageTest : public PerformanceHintEnqueueImageTest,