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

Skip transfer when CL_MAP_INVALIDATE_REGION is specified

Browse Source 
Resolves: NEO-5490
Signed-off-by: Maciej Dziuban <maciej.dziuban@intel.com>
This commit is contained in:
Maciej Dziuban
2021-10-13 14:29:02 +00:00
committed by Compute-Runtime-Automation
parent 44112f8d94
commit 75b7adbe95
4 changed files with 106 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
opencl/source/command_queue/command_queue.cpp
View File

@@ -433,21 +433,25 @@ void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperti
return nullptr; return nullptr;
} }
if (transferProperties.memObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) { if (transferProperties.mapFlags == CL_MAP_WRITE_INVALIDATE_REGION) {
auto buffer = castToObject<Buffer>(transferProperties.memObj); errcodeRet = enqueueMarkerWithWaitList(eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
errcodeRet = enqueueReadBuffer(buffer, transferProperties.blocking, transferProperties.offset[0], transferProperties.size[0],
returnPtr, transferProperties.memObj->getMapAllocation(getDevice().getRootDeviceIndex()), eventsRequest.numEventsInWaitList,
eventsRequest.eventWaitList, eventsRequest.outEvent);
} else { } else {
auto image = castToObjectOrAbort<Image>(transferProperties.memObj); if (transferProperties.memObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) {
size_t readOrigin[4] = {transferProperties.offset[0], transferProperties.offset[1], transferProperties.offset[2], 0}; auto buffer = castToObject<Buffer>(transferProperties.memObj);
auto mipIdx = getMipLevelOriginIdx(image->peekClMemObjType()); errcodeRet = enqueueReadBuffer(buffer, transferProperties.blocking, transferProperties.offset[0], transferProperties.size[0],
UNRECOVERABLE_IF(mipIdx >= 4); returnPtr, transferProperties.memObj->getMapAllocation(getDevice().getRootDeviceIndex()), eventsRequest.numEventsInWaitList,
readOrigin[mipIdx] = transferProperties.mipLevel; eventsRequest.eventWaitList, eventsRequest.outEvent);
errcodeRet = enqueueReadImage(image, transferProperties.blocking, readOrigin, &transferProperties.size[0], } else {
image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(), auto image = castToObjectOrAbort<Image>(transferProperties.memObj);
returnPtr, transferProperties.memObj->getMapAllocation(getDevice().getRootDeviceIndex()), eventsRequest.numEventsInWaitList, size_t readOrigin[4] = {transferProperties.offset[0], transferProperties.offset[1], transferProperties.offset[2], 0};
eventsRequest.eventWaitList, eventsRequest.outEvent); auto mipIdx = getMipLevelOriginIdx(image->peekClMemObjType());
UNRECOVERABLE_IF(mipIdx >= 4);
readOrigin[mipIdx] = transferProperties.mipLevel;
errcodeRet = enqueueReadImage(image, transferProperties.blocking, readOrigin, &transferProperties.size[0],
image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(),
returnPtr, transferProperties.memObj->getMapAllocation(getDevice().getRootDeviceIndex()), eventsRequest.numEventsInWaitList,
eventsRequest.eventWaitList, eventsRequest.outEvent);
}
} }
if (errcodeRet != CL_SUCCESS) { if (errcodeRet != CL_SUCCESS) {

8
opencl/source/command_queue/cpu_data_transfer_handler.cpp
View File

@@ -107,13 +107,17 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
switch (transferProperties.cmdType) { switch (transferProperties.cmdType) {
case CL_COMMAND_MAP_BUFFER: case CL_COMMAND_MAP_BUFFER:
if (!transferProperties.memObj->isMemObjZeroCopy()) { if (!transferProperties.memObj->isMemObjZeroCopy()) {
transferProperties.memObj->transferDataToHostPtr(transferProperties.size, transferProperties.offset); if (transferProperties.mapFlags != CL_MAP_WRITE_INVALIDATE_REGION) {
transferProperties.memObj->transferDataToHostPtr(transferProperties.size, transferProperties.offset);
}
eventCompleted = true; eventCompleted = true;
} }
break; break;
case CL_COMMAND_MAP_IMAGE: case CL_COMMAND_MAP_IMAGE:
if (!transferProperties.memObj->isMemObjZeroCopy()) { if (!transferProperties.memObj->isMemObjZeroCopy()) {
transferProperties.memObj->transferDataToHostPtr(transferProperties.size, transferProperties.offset); if (transferProperties.mapFlags != CL_MAP_WRITE_INVALIDATE_REGION) {
transferProperties.memObj->transferDataToHostPtr(transferProperties.size, transferProperties.offset);
}
eventCompleted = true; eventCompleted = true;
} }
break; break;

36
opencl/test/unit_test/command_queue/multiple_map_buffer_tests.cpp
View File

@@ -165,6 +165,25 @@ HWTEST_F(MultipleMapBufferTest, givenReadOnlyMapWhenUnmappedOnGpuThenEnqueueMark
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u); EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
} }
HWTEST_F(MultipleMapBufferTest, givenWriteInvalidateMapWhenMappedOnGpuThenCallEnqueueMarker) {
auto buffer = createMockBuffer<FamilyType>(true);
auto cmdQ = createMockCmdQ<FamilyType>();
EXPECT_FALSE(buffer->mappingOnCpuAllowed());
size_t offset = 1;
size_t size = 3;
void *mappedPtr = clEnqueueMapBuffer(cmdQ.get(), buffer.get(), CL_FALSE, CL_MAP_WRITE_INVALIDATE_REGION, offset, size, 0, nullptr, nullptr, nullptr);
EXPECT_NE(nullptr, mappedPtr);
EXPECT_EQ(1u, buffer->mapOperationsHandler.size());
EXPECT_EQ(cmdQ->readBufferCalled, 0u);
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
retVal = clEnqueueUnmapMemObject(cmdQ.get(), buffer.get(), mappedPtr, 0, nullptr, nullptr);
EXPECT_EQ(0u, buffer->mapOperationsHandler.size());
EXPECT_EQ(cmdQ->writeBufferCalled, 1u);
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
}
HWTEST_F(MultipleMapBufferTest, givenNotMappedPtrWhenUnmapedOnGpuThenReturnError) { HWTEST_F(MultipleMapBufferTest, givenNotMappedPtrWhenUnmapedOnGpuThenReturnError) {
auto buffer = createMockBuffer<FamilyType>(true); auto buffer = createMockBuffer<FamilyType>(true);
auto cmdQ = createMockCmdQ<FamilyType>(); auto cmdQ = createMockCmdQ<FamilyType>();
@@ -245,6 +264,23 @@ HWTEST_F(MultipleMapBufferTest, givenUnblockedQueueWhenReadOnlyMappedOnCpuThenDo
EXPECT_EQ(0u, buffer->transferFromHostPtrCalled); EXPECT_EQ(0u, buffer->transferFromHostPtrCalled);
} }
HWTEST_F(MultipleMapBufferTest, givenUnblockedQueueWhenWriteInvalidateMappedOnCpuThenDontMakeCpuCopy) {
auto buffer = createMockBuffer<FamilyType>(false);
auto cmdQ = createMockCmdQ<FamilyType>();
EXPECT_TRUE(buffer->mappingOnCpuAllowed());
size_t offset = 1;
size_t size = 3;
void *mappedPtr = clEnqueueMapBuffer(cmdQ.get(), buffer.get(), CL_FALSE, CL_MAP_WRITE_INVALIDATE_REGION, offset, size, 0, nullptr, nullptr, &retVal);
EXPECT_NE(nullptr, mappedPtr);
EXPECT_EQ(1u, buffer->mapOperationsHandler.size());
EXPECT_EQ(0u, buffer->transferToHostPtrCalled);
retVal = clEnqueueUnmapMemObject(cmdQ.get(), buffer.get(), mappedPtr, 0, nullptr, nullptr);
EXPECT_EQ(0u, buffer->mapOperationsHandler.size());
EXPECT_EQ(1u, buffer->transferFromHostPtrCalled);
}
HWTEST_F(MultipleMapBufferTest, givenBlockedQueueWhenMappedOnCpuThenAddMappedPtrAndRemoveOnUnmap) { HWTEST_F(MultipleMapBufferTest, givenBlockedQueueWhenMappedOnCpuThenAddMappedPtrAndRemoveOnUnmap) {
auto buffer = createMockBuffer<FamilyType>(false); auto buffer = createMockBuffer<FamilyType>(false);
auto cmdQ = createMockCmdQ<FamilyType>(); auto cmdQ = createMockCmdQ<FamilyType>();

47
opencl/test/unit_test/command_queue/multiple_map_image_tests.cpp
View File

@@ -192,6 +192,30 @@ HWTEST_F(MultipleMapImageTest, givenReadOnlyMapWhenUnmappedOnGpuThenEnqueueMarke
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u); EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
} }
HWTEST_F(MultipleMapImageTest, givenWriteInvalidateMapWhenMappedOnGpuThenEnqueueMarker) {
if (!UnitTestHelper<FamilyType>::tiledImagesSupported) {
GTEST_SKIP();
}
auto image = createMockImage<Image3dDefaults, FamilyType>();
auto cmdQ = createMockCmdQ<FamilyType>();
EXPECT_FALSE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{1, 2, 1}};
MemObjSizeArray region = {{3, 4, 1}};
void *mappedPtr = clEnqueueMapImage(cmdQ.get(), image.get(), CL_TRUE, CL_MAP_WRITE_INVALIDATE_REGION, &origin[0], &region[0], nullptr, nullptr, 0, nullptr, nullptr, &retVal);
EXPECT_NE(nullptr, mappedPtr);
EXPECT_EQ(1u, image->mapOperationsHandler.size());
EXPECT_EQ(cmdQ->readImageCalled, 0u);
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
retVal = clEnqueueUnmapMemObject(cmdQ.get(), image.get(), mappedPtr, 0, nullptr, nullptr);
EXPECT_EQ(0u, image->mapOperationsHandler.size());
EXPECT_EQ(cmdQ->writeImageCalled, 1u);
EXPECT_EQ(cmdQ->enqueueMarkerCalled, 1u);
EXPECT_EQ(cmdQ->enqueueRegion, region);
EXPECT_EQ(cmdQ->enqueueOrigin, origin);
}
HWTEST_F(MultipleMapImageTest, givenNotMappedPtrWhenUnmapedThenReturnError) { HWTEST_F(MultipleMapImageTest, givenNotMappedPtrWhenUnmapedThenReturnError) {
auto image = createMockImage<Image2dDefaults, FamilyType>(); auto image = createMockImage<Image2dDefaults, FamilyType>();
auto cmdQ = createMockCmdQ<FamilyType>(); auto cmdQ = createMockCmdQ<FamilyType>();
@@ -262,7 +286,7 @@ HWTEST_F(MultipleMapImageTest, givenUnblockedQueueWhenMappedOnCpuThenAddMappedPt
EXPECT_EQ(image->copyOrigin, origin); EXPECT_EQ(image->copyOrigin, origin);
} }
HWTEST_F(MultipleMapImageTest, givenUnblockedQueueWhenReadOnlyMappedOnCpuThenDontMakeCpuCopy) { HWTEST_F(MultipleMapImageTest, givenUnblockedQueueWhenReadOnlyUnmappedOnCpuThenDontMakeCpuCopy) {
auto image = createMockImage<Image1dDefaults, FamilyType>(); auto image = createMockImage<Image1dDefaults, FamilyType>();
auto cmdQ = createMockCmdQ<FamilyType>(); auto cmdQ = createMockCmdQ<FamilyType>();
image->isZeroCopy = false; image->isZeroCopy = false;
@@ -283,6 +307,27 @@ HWTEST_F(MultipleMapImageTest, givenUnblockedQueueWhenReadOnlyMappedOnCpuThenDon
EXPECT_EQ(0u, image->transferFromHostPtrCalled); EXPECT_EQ(0u, image->transferFromHostPtrCalled);
} }
HWTEST_F(MultipleMapImageTest, givenUnblockedQueueWhenWriteInvalidateMappedOnCpuThenDontMakeCpuCopy) {
auto image = createMockImage<Image1dDefaults, FamilyType>();
auto cmdQ = createMockCmdQ<FamilyType>();
image->isZeroCopy = false;
EXPECT_TRUE(image->mappingOnCpuAllowed());
MemObjOffsetArray origin = {{1, 0, 0}};
MemObjSizeArray region = {{3, 1, 1}};
void *mappedPtr = clEnqueueMapImage(cmdQ.get(), image.get(), CL_TRUE, CL_MAP_WRITE_INVALIDATE_REGION, &origin[0], &region[0], nullptr, nullptr, 0, nullptr, nullptr, &retVal);
EXPECT_NE(nullptr, mappedPtr);
EXPECT_EQ(1u, image->mapOperationsHandler.size());
EXPECT_EQ(0u, image->transferToHostPtrCalled);
retVal = clEnqueueUnmapMemObject(cmdQ.get(), image.get(), mappedPtr, 0, nullptr, nullptr);
EXPECT_EQ(0u, image->mapOperationsHandler.size());
EXPECT_EQ(1u, image->transferFromHostPtrCalled);
EXPECT_EQ(image->copyRegion, region);
EXPECT_EQ(image->copyOrigin, origin);
}
HWTEST_F(MultipleMapImageTest, givenBlockedQueueWhenMappedOnCpuThenAddMappedPtrAndRemoveOnUnmap) { HWTEST_F(MultipleMapImageTest, givenBlockedQueueWhenMappedOnCpuThenAddMappedPtrAndRemoveOnUnmap) {
auto image = createMockImage<Image1dDefaults, FamilyType>(); auto image = createMockImage<Image1dDefaults, FamilyType>();
auto cmdQ = createMockCmdQ<FamilyType>(); auto cmdQ = createMockCmdQ<FamilyType>();