Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add dedicated map allocation

Browse Source 
Related-To: NEO-2917

Change-Id: Ieeca40f5faf29433a5c464d2c3ca3b8910695a9b
Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2019-04-08 14:49:35 +02:00
committed by sys_ocldev
parent 91a64c8518
commit e201725dd5
45 changed files with 287 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/api/api.cpp
View File

@ -1872,6 +1872,7 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue,
offset,
cb,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
event);
@ -2001,6 +2002,7 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue,
offset,
cb,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
event);

15
runtime/command_queue/command_queue.cpp
View File

@ -324,7 +324,7 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
if (!unmapInfo.readOnly) {
if (memObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) {
auto buffer = castToObject<Buffer>(memObj);
retVal = enqueueWriteBuffer(buffer, CL_TRUE, unmapInfo.offset[0], unmapInfo.size[0], mappedPtr,
retVal = enqueueWriteBuffer(buffer, CL_TRUE, unmapInfo.offset[0], unmapInfo.size[0], mappedPtr, memObj->getMapAllocation(),
eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
} else {
auto image = castToObjectOrAbort<Image>(memObj);
@ -360,8 +360,12 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
}
void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperties, EventsRequest &eventsRequest, cl_int &errcodeRet) {
void *returnPtr = ptrOffset(transferProperties.memObj->getBasePtrForMap(),
transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset) + transferProperties.mipPtrOffset);
void *basePtr = transferProperties.memObj->getBasePtrForMap();
size_t mapPtrOffset = transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset) + transferProperties.mipPtrOffset;
if (transferProperties.memObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) {
mapPtrOffset += transferProperties.memObj->getOffset();
}
void *returnPtr = ptrOffset(basePtr, mapPtrOffset);
if (!transferProperties.memObj->addMappedPtr(returnPtr, transferProperties.memObj->calculateMappedPtrLength(transferProperties.size),
transferProperties.mapFlags, transferProperties.size, transferProperties.offset, transferProperties.mipLevel)) {
@ -371,8 +375,9 @@ void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperti
if (transferProperties.memObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) {
auto buffer = castToObject<Buffer>(transferProperties.memObj);
errcodeRet = enqueueReadBuffer(buffer, transferProperties.blocking, transferProperties.offset[0], transferProperties.size[0], returnPtr,
eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
errcodeRet = enqueueReadBuffer(buffer, transferProperties.blocking, transferProperties.offset[0], transferProperties.size[0],
returnPtr, transferProperties.memObj->getMapAllocation(), eventsRequest.numEventsInWaitList,
eventsRequest.eventWaitList, eventsRequest.outEvent);
} else {
auto image = castToObjectOrAbort<Image>(transferProperties.memObj);
size_t readOrigin[4] = {transferProperties.offset[0], transferProperties.offset[1], transferProperties.offset[2], 0};

2
runtime/command_queue/command_queue.h
View File

@ -207,6 +207,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
virtual cl_int enqueueReadBuffer(Buffer *buffer, cl_bool blockingRead,
size_t offset, size_t size, void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) {
@ -224,6 +225,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
virtual cl_int enqueueWriteBuffer(Buffer *buffer, cl_bool blockingWrite,
size_t offset, size_t cb, const void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) {

2
runtime/command_queue/command_queue_hw.h
View File

@ -197,6 +197,7 @@ class CommandQueueHw : public CommandQueue {
size_t offset,
size_t size,
void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) override;
@ -231,6 +232,7 @@ class CommandQueueHw : public CommandQueue {
size_t offset,
size_t cb,
const void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) override;

25
runtime/command_queue/enqueue_read_buffer.h
View File

@ -28,6 +28,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBuffer(
size_t offset,
size_t size,
void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) {
@ -84,21 +85,29 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBuffer(
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
this->getContext(), this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
void *dstPtr = ptr;
MemObjSurface bufferSurf(buffer);
HostPtrSurface hostPtrSurf(dstPtr, size);
Surface *surfaces[] = {&bufferSurf, &hostPtrSurf};
GeneralSurface mapSurface;
Surface *surfaces[] = {&bufferSurf, nullptr};
if (size != 0) {
bool status = getCommandStreamReceiver().createAllocationForHostSurface(hostPtrSurf, true);
if (!status) {
return CL_OUT_OF_RESOURCES;
if (mapAllocation) {
surfaces[1] = &mapSurface;
mapSurface.setGraphicsAllocation(mapAllocation);
//get offset between base cpu ptr of map allocation and dst ptr
size_t dstOffset = ptrDiff(dstPtr, mapAllocation->getUnderlyingBuffer());
dstPtr = reinterpret_cast<void *>(mapAllocation->getGpuAddress() + dstOffset);
} else {
surfaces[1] = &hostPtrSurf;
if (size != 0) {
bool status = getCommandStreamReceiver().createAllocationForHostSurface(hostPtrSurf, true);
if (!status) {
return CL_OUT_OF_RESOURCES;
}
dstPtr = reinterpret_cast<void *>(hostPtrSurf.getAllocation()->getGpuAddress());
}
dstPtr = reinterpret_cast<void *>(hostPtrSurf.getAllocation()->getGpuAddress());
}
void *alignedDstPtr = alignDown(dstPtr, 4);
size_t dstPtrOffset = ptrDiff(dstPtr, alignedDstPtr);

24
runtime/command_queue/enqueue_write_buffer.h
View File

@ -27,6 +27,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBuffer(
size_t offset,
size_t size,
const void *ptr,
GraphicsAllocation *mapAllocation,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
cl_event *event) {
@ -89,16 +90,25 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBuffer(
HostPtrSurface hostPtrSurf(srcPtr, size, true);
MemObjSurface bufferSurf(buffer);
Surface *surfaces[] = {&bufferSurf, &hostPtrSurf};
GeneralSurface mapSurface;
Surface *surfaces[] = {&bufferSurf, nullptr};
if (size != 0) {
bool status = getCommandStreamReceiver().createAllocationForHostSurface(hostPtrSurf, false);
if (!status) {
return CL_OUT_OF_RESOURCES;
if (mapAllocation) {
surfaces[1] = &mapSurface;
mapSurface.setGraphicsAllocation(mapAllocation);
//get offset between base cpu ptr of map allocation and dst ptr
size_t srcOffset = ptrDiff(srcPtr, mapAllocation->getUnderlyingBuffer());
srcPtr = reinterpret_cast<void *>(mapAllocation->getGpuAddress() + srcOffset);
} else {
surfaces[1] = &hostPtrSurf;
if (size != 0) {
bool status = getCommandStreamReceiver().createAllocationForHostSurface(hostPtrSurf, false);
if (!status) {
return CL_OUT_OF_RESOURCES;
}
srcPtr = reinterpret_cast<void *>(hostPtrSurf.getAllocation()->getGpuAddress());
}
srcPtr = reinterpret_cast<void *>(hostPtrSurf.getAllocation()->getGpuAddress());
}
void *alignedSrcPtr = alignDown(srcPtr, 4);
size_t srcPtrOffset = ptrDiff(srcPtr, alignedSrcPtr);

2
runtime/helpers/properties_helper.cpp
View File

@ -15,7 +15,7 @@
namespace NEO {
TransferProperties::TransferProperties(MemObj *memObj, cl_command_type cmdType, cl_map_flags mapFlags, bool blocking,
size_t *offsetPtr, size_t *sizePtr, void *ptr, bool doTransferOnCpu)
: memObj(memObj), cmdType(cmdType), mapFlags(mapFlags), blocking(blocking), ptr(ptr) {
: memObj(memObj), ptr(ptr), cmdType(cmdType), mapFlags(mapFlags), blocking(blocking), doTransferOnCpu(doTransferOnCpu) {
// no size or offset passed for unmap operation
if (cmdType != CL_COMMAND_UNMAP_MEM_OBJECT) {

19
runtime/helpers/properties_helper.h
View File

@ -49,32 +49,33 @@ struct TransferProperties {
TransferProperties(MemObj *memObj, cl_command_type cmdType, cl_map_flags mapFlags, bool blocking, size_t *offsetPtr, size_t *sizePtr,
void *ptr, bool doTransferOnCpu);
MemObj *memObj = nullptr;
cl_command_type cmdType = 0;
cl_map_flags mapFlags = 0;
bool blocking = false;
MemObjOffsetArray offset = {};
MemObjSizeArray size = {};
MemObj *memObj = nullptr;
void *ptr = nullptr;
void *lockedPtr = nullptr;
cl_command_type cmdType = 0;
cl_map_flags mapFlags = 0;
uint32_t mipLevel = 0;
uint32_t mipPtrOffset = 0;
bool blocking = false;
bool doTransferOnCpu = false;
void *lockedPtr = nullptr;
void *getCpuPtrForReadWrite();
};
struct MapInfo {
MapInfo() = default;
MapInfo(void *ptr, size_t ptrLength, MemObjSizeArray size, MemObjOffsetArray offset, uint32_t mipLevel)
: ptr(ptr), ptrLength(ptrLength), size(size), offset(offset), mipLevel(mipLevel) {
: size(size), offset(offset), ptrLength(ptrLength), ptr(ptr), mipLevel(mipLevel) {
}
void *ptr = nullptr;
size_t ptrLength = 0;
MemObjSizeArray size = {};
MemObjOffsetArray offset = {};
bool readOnly = false;
size_t ptrLength = 0;
void *ptr = nullptr;
uint32_t mipLevel = 0;
bool readOnly = false;
};
class NonCopyableOrMovableClass {

2
runtime/mem_obj/buffer.cpp
View File

@ -264,7 +264,7 @@ Buffer *Buffer::create(Context *context,
auto gmm = memory->getDefaultGmm();
if ((gmm && gmm->isRenderCompressed) || !MemoryPool::isSystemMemoryPool(memory->getMemoryPool())) {
auto cmdQ = context->getSpecialQueue();
if (CL_SUCCESS != cmdQ->enqueueWriteBuffer(pBuffer, CL_TRUE, 0, size, hostPtr, 0, nullptr, nullptr)) {
if (CL_SUCCESS != cmdQ->enqueueWriteBuffer(pBuffer, CL_TRUE, 0, size, hostPtr, nullptr, 0, nullptr, nullptr)) {
errcodeRet = CL_OUT_OF_RESOURCES;
}
} else {

20
runtime/mem_obj/mem_obj.cpp
View File

@ -75,7 +75,10 @@ MemObj::~MemObj() {
graphicsAllocation = nullptr;
}
releaseAllocatedMapPtr();
if (!associatedMemObject) {
releaseMapAllocation();
releaseAllocatedMapPtr();
}
if (mcsAllocation) {
destroyGraphicsAllocation(mcsAllocation, false);
}
@ -283,6 +286,12 @@ void MemObj::releaseAllocatedMapPtr() {
allocatedMapPtr = nullptr;
}
void MemObj::releaseMapAllocation() {
if (mapAllocation) {
destroyGraphicsAllocation(mapAllocation, false);
}
}
void MemObj::destroyGraphicsAllocation(GraphicsAllocation *allocation, bool asyncDestroy) {
if (asyncDestroy) {
memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(allocation);
@ -302,13 +311,20 @@ bool MemObj::checkIfMemoryTransferIsRequired(size_t offsetInMemObjest, size_t of
}
void *MemObj::getBasePtrForMap() {
if (associatedMemObject) {
TakeOwnershipWrapper<MemObj> memObjOwnership(*this);
return associatedMemObject->getBasePtrForMap();
}
if (getFlags() & CL_MEM_USE_HOST_PTR) {
return getHostPtr();
} else {
TakeOwnershipWrapper<MemObj> memObjOwnership(*this);
if (!getAllocatedMapPtr()) {
if (!getMapAllocation()) {
auto memory = memoryManager->allocateSystemMemory(getSize(), MemoryConstants::pageSize);
setAllocatedMapPtr(memory);
AllocationProperties properties{false, getSize(), GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR};
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(properties, memory);
setMapAllocation(allocation);
}
return getAllocatedMapPtr();
}

11
runtime/mem_obj/mem_obj.h
View File

@ -71,6 +71,7 @@ class MemObj : public BaseObject<_cl_mem> {
void setHostPtrMinSize(size_t size);
void releaseAllocatedMapPtr();
void releaseMapAllocation();
bool isMemObjZeroCopy() const;
bool isMemObjWithHostPtrSVM() const;
@ -109,6 +110,15 @@ class MemObj : public BaseObject<_cl_mem> {
MemoryManager *getMemoryManager() const {
return memoryManager;
}
void setMapAllocation(GraphicsAllocation *allocation) {
mapAllocation = allocation;
}
GraphicsAllocation *getMapAllocation() const {
if (associatedMemObject) {
return associatedMemObject->getMapAllocation();
}
return mapAllocation;
}
protected:
void getOsSpecificMemObjectInfo(const cl_mem_info &paramName, size_t *srcParamSize, void **srcParam);
@ -132,6 +142,7 @@ class MemObj : public BaseObject<_cl_mem> {
MemoryManager *memoryManager = nullptr;
GraphicsAllocation *graphicsAllocation;
GraphicsAllocation *mcsAllocation = nullptr;
GraphicsAllocation *mapAllocation = nullptr;
std::shared_ptr<SharingHandler> sharingHandler;
class DestructorCallback {

9
runtime/memory_manager/surface.h
View File

@ -18,7 +18,7 @@ class Surface {
virtual ~Surface() = default;
virtual void makeResident(CommandStreamReceiver &csr) = 0;
virtual Surface *duplicate() = 0;
const bool IsCoherent;
bool IsCoherent;
};
class NullSurface : public Surface {
@ -105,6 +105,9 @@ class MemObjSurface : public Surface {
class GeneralSurface : public Surface {
public:
GeneralSurface() : Surface(false) {
gfxAllocation = nullptr;
}
GeneralSurface(GraphicsAllocation *gfxAlloc) : Surface(gfxAlloc->isCoherent()) {
gfxAllocation = gfxAlloc;
};
@ -114,6 +117,10 @@ class GeneralSurface : public Surface {
csr.makeResident(*gfxAllocation);
};
Surface *duplicate() override { return new GeneralSurface(gfxAllocation); };
void setGraphicsAllocation(GraphicsAllocation *newAllocation) {
gfxAllocation = newAllocation;
IsCoherent = newAllocation->isCoherent();
}
protected:
GraphicsAllocation *gfxAllocation;

2
unit_tests/aub_tests/command_queue/enqueue_map_buffer_aub_tests.cpp
View File

@ -68,7 +68,7 @@ HWTEST_F(AUBMapBuffer, MapUpdateUnmapVerify) {
std::unique_ptr<uint8_t[]> readMemory(new uint8_t[bufferSize]);
buffer->forceDisallowCPUCopy = true;
retVal = pCmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, bufferSize, readMemory.get(), 0, nullptr, nullptr);
retVal = pCmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, bufferSize, readMemory.get(), nullptr, 0, nullptr, nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
for (size_t i = 0; i < bufferSize; i++) {

3
unit_tests/aub_tests/command_queue/enqueue_read_buffer_aub_tests.cpp
View File

@ -67,6 +67,7 @@ HWTEST_P(AUBReadBuffer, simple) {
offset,
sizeWritten,
pDestMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
event);
@ -139,6 +140,7 @@ HWTEST_F(AUBReadBuffer, reserveCanonicalGpuAddress) {
0,
sizeof(dstMemory),
dstMemory,
nullptr,
0,
nullptr,
nullptr);
@ -193,6 +195,7 @@ struct AUBReadBufferUnaligned
offset,
size,
ptrOffset(dstMemory, offset),
nullptr,
0,
nullptr,
nullptr);

6
unit_tests/aub_tests/command_queue/enqueue_with_timestamp_packet_aub_tests.cpp
View File

@ -44,11 +44,11 @@ HWTEST_F(TimestampPacketAubTests, givenTwoBatchedEnqueuesWhenDependencyIsResolve
buffer->forceDisallowCPUCopy = true;
cl_event outEvent1, outEvent2;
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_FALSE, 0, bufferSize, writePattern1, 0, nullptr, &outEvent1);
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_FALSE, 0, bufferSize, writePattern1, nullptr, 0, nullptr, &outEvent1);
auto node1 = castToObject<Event>(outEvent1)->getTimestampPacketNodes()->peekNodes().at(0);
node1->getBaseGraphicsAllocation()->setAubWritable(true); // allow to write again after Buffer::create
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_TRUE, 0, bufferSize, writePattern2, 0, nullptr, &outEvent2);
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_TRUE, 0, bufferSize, writePattern2, nullptr, 0, nullptr, &outEvent2);
auto node2 = castToObject<Event>(outEvent2)->getTimestampPacketNodes()->peekNodes().at(0);
expectMemory<FamilyType>(reinterpret_cast<void *>(buffer->getGraphicsAllocation()->getGpuAddress()), writePattern2, bufferSize);
@ -79,7 +79,7 @@ HWTEST_F(TimestampPacketAubTests, givenMultipleWalkersWhenEnqueueingThenWriteAll
auto buffer = std::unique_ptr<Buffer>(Buffer::create(&context, CL_MEM_READ_WRITE, bufferSize, nullptr, retVal));
buffer->forceDisallowCPUCopy = true;
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_TRUE, 1, writeSize, writeData, 0, nullptr, &outEvent);
pCmdQ->enqueueWriteBuffer(buffer.get(), CL_TRUE, 1, writeSize, writeData, nullptr, 0, nullptr, &outEvent);
auto &timestampNodes = castToObject<Event>(outEvent)->getTimestampPacketNodes()->peekNodes();

2
unit_tests/aub_tests/command_queue/enqueue_write_buffer_aub_tests.cpp
View File

@ -70,6 +70,7 @@ HWTEST_P(AUBWriteBuffer, simple) {
offset,
sizeWritten,
pSrcMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
event);
@ -148,6 +149,7 @@ struct AUBWriteBufferUnaligned
offset,
size,
ptrOffset(srcMemory, offset),
nullptr,
0,
nullptr,
nullptr);

3
unit_tests/aub_tests/command_queue/enqueue_write_copy_read_buffer_aub_tests.cpp
View File

@ -61,6 +61,7 @@ void AubWriteCopyReadBuffer::runTest() {
0,
bufferSize,
srcMemoryToWrite,
nullptr,
numEventsInWaitList,
eventWaitList,
event);
@ -73,6 +74,7 @@ void AubWriteCopyReadBuffer::runTest() {
0,
bufferSize,
dstMemoryToWrite,
nullptr,
numEventsInWaitList,
eventWaitList,
event);
@ -108,6 +110,7 @@ void AubWriteCopyReadBuffer::runTest() {
0,
bufferSize,
hostPtrMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
event);

6
unit_tests/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
View File

@ -442,11 +442,11 @@ SKLTEST_F(AUBRunKernelIntegrateTest, deviceSideVme) {
residualsBuffer->forceDisallowCPUCopy = true;
shapesBuffer->forceDisallowCPUCopy = true;
retVal = pCmdQ->enqueueReadBuffer(motionVectorBuffer, true, 0, sizeof(destinationMV), destinationMV, 0, nullptr, nullptr);
retVal = pCmdQ->enqueueReadBuffer(motionVectorBuffer, true, 0, sizeof(destinationMV), destinationMV, nullptr, 0, nullptr, nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
retVal = pCmdQ->enqueueReadBuffer(residualsBuffer, true, 0, sizeof(destinationResiduals), destinationResiduals, 0, nullptr, nullptr);
retVal = pCmdQ->enqueueReadBuffer(residualsBuffer, true, 0, sizeof(destinationResiduals), destinationResiduals, nullptr, 0, nullptr, nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
retVal = pCmdQ->enqueueReadBuffer(shapesBuffer, true, 0, sizeof(destinationShapes), destinationShapes, 0, nullptr, nullptr);
retVal = pCmdQ->enqueueReadBuffer(shapesBuffer, true, 0, sizeof(destinationShapes), destinationShapes, nullptr, 0, nullptr, nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
// Check if our buffers matches expectations

2
unit_tests/command_queue/command_queue_hw_tests.cpp
View File

@ -994,7 +994,7 @@ HWTEST_F(CommandQueueHwTest, givenKernelSplitEnqueueReadBufferWhenBlockedThenEnq
cl_event blockedEvent = &userEvent;
cl_int status = pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, MemoryConstants::cacheLineSize, ptr, 1, &blockedEvent, nullptr);
cl_int status = pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, MemoryConstants::cacheLineSize, ptr, nullptr, 1, &blockedEvent, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
userEvent.setStatus(CL_COMPLETE);

4
unit_tests/command_queue/command_queue_tests.cpp
View File

@ -760,7 +760,7 @@ HWTEST_F(WaitForQueueCompletionTests, givenBlockingCallAndUnblockedQueueWhenEnqu
std::unique_ptr<MyCmdQueue<FamilyType>> cmdQ(new MyCmdQueue<FamilyType>(context.get(), device.get()));
uint32_t tmpPtr = 0;
auto buffer = std::unique_ptr<Buffer>(BufferHelper<>::create(context.get()));
cmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &tmpPtr, 0, nullptr, nullptr);
cmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &tmpPtr, nullptr, 0, nullptr, nullptr);
EXPECT_EQ(1u, cmdQ->waitUntilCompleteCounter);
EXPECT_FALSE(cmdQ->requestedUseQuickKmdSleep);
}
@ -771,7 +771,7 @@ HWTEST_F(WaitForQueueCompletionTests, givenBlockingCallAndBlockedQueueWhenEnqueu
cl_event clBlockingEvent = blockingEvent.get();
uint32_t tmpPtr = 0;
auto buffer = std::unique_ptr<Buffer>(BufferHelper<>::create(context.get()));
cmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &tmpPtr, 1, &clBlockingEvent, nullptr);
cmdQ->enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &tmpPtr, nullptr, 1, &clBlockingEvent, nullptr);
EXPECT_EQ(1u, cmdQ->waitUntilCompleteCounter);
EXPECT_FALSE(cmdQ->requestedUseQuickKmdSleep);
}

24
unit_tests/command_queue/enqueue_fixture.cpp
View File

@ -77,11 +77,12 @@ cl_int *EnqueueMapBufferTraits::errcodeRet = nullptr;
cl_command_type EnqueueMapBufferTraits::cmdType = CL_COMMAND_MAP_BUFFER;
// EnqueueReadBufferTraits
const cl_bool EnqueueReadBufferTraits::blocking = CL_TRUE;
const size_t EnqueueReadBufferTraits::offset = 0;
const size_t EnqueueReadBufferTraits::sizeInBytes = negOne;
void *EnqueueReadBufferTraits::hostPtr = ptrOutput;
cl_command_type EnqueueReadBufferTraits::cmdType = CL_COMMAND_READ_BUFFER;
const cl_bool EnqueueReadBufferTraits::blocking = CL_TRUE;
const size_t EnqueueReadBufferTraits::offset = 0;
const size_t EnqueueReadBufferTraits::sizeInBytes = negOne;
void *EnqueueReadBufferTraits::hostPtr = ptrOutput;
cl_command_type EnqueueReadBufferTraits::cmdType = CL_COMMAND_READ_BUFFER;
GraphicsAllocation *EnqueueReadBufferTraits::mapAllocation = nullptr;
// EnqueueReadImageTraits
const cl_bool EnqueueReadImageTraits::blocking = CL_TRUE;
@ -93,12 +94,13 @@ void *EnqueueReadImageTraits::hostPtr = ptrOutput;
cl_command_type EnqueueReadImageTraits::cmdType = CL_COMMAND_READ_IMAGE;
// EnqueueWriteBufferTraits
const bool EnqueueWriteBufferTraits::zeroCopy = true;
const cl_bool EnqueueWriteBufferTraits::blocking = CL_TRUE;
const size_t EnqueueWriteBufferTraits::offset = 0;
const size_t EnqueueWriteBufferTraits::sizeInBytes = negOne;
void *EnqueueWriteBufferTraits::hostPtr = ptrGarbage;
cl_command_type EnqueueWriteBufferTraits::cmdType = CL_COMMAND_WRITE_BUFFER;
const bool EnqueueWriteBufferTraits::zeroCopy = true;
const cl_bool EnqueueWriteBufferTraits::blocking = CL_TRUE;
const size_t EnqueueWriteBufferTraits::offset = 0;
const size_t EnqueueWriteBufferTraits::sizeInBytes = negOne;
void *EnqueueWriteBufferTraits::hostPtr = ptrGarbage;
cl_command_type EnqueueWriteBufferTraits::cmdType = CL_COMMAND_WRITE_BUFFER;
GraphicsAllocation *EnqueueWriteBufferTraits::mapAllocation = nullptr;
// EnqueueWriteBufferRectTraits
const bool EnqueueWriteBufferRectTraits::zeroCopy = true;

7
unit_tests/command_queue/enqueue_fixture.h
View File

@ -9,6 +9,7 @@
#include "runtime/command_queue/command_queue.h"
#include "runtime/event/user_event.h"
#include "runtime/kernel/kernel.h"
#include "runtime/memory_manager/graphics_allocation.h"
#include "unit_tests/fixtures/buffer_fixture.h"
#include "unit_tests/fixtures/image_fixture.h"
@ -390,6 +391,7 @@ struct EnqueueReadBufferTraits : public EnqueueTraits {
static const size_t sizeInBytes;
static void *hostPtr;
static cl_command_type cmdType;
static GraphicsAllocation *mapAllocation;
};
template <typename T = EnqueueReadBufferTraits>
@ -404,6 +406,7 @@ struct EnqueueReadBufferHelper {
size_t offset = Traits::offset,
size_t size = Traits::sizeInBytes,
void *ptr = Traits::hostPtr,
GraphicsAllocation *mapAllocation = Traits::mapAllocation,
cl_uint numEventsInWaitList = Traits::numEventsInWaitList,
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
@ -415,6 +418,7 @@ struct EnqueueReadBufferHelper {
offset,
size,
ptr,
mapAllocation,
numEventsInWaitList,
eventWaitList,
event);
@ -490,6 +494,7 @@ struct EnqueueWriteBufferTraits : public EnqueueTraits {
static const size_t sizeInBytes;
static void *hostPtr;
static cl_command_type cmdType;
static GraphicsAllocation *mapAllocation;
};
template <typename T = EnqueueWriteBufferTraits>
@ -504,6 +509,7 @@ struct EnqueueWriteBufferHelper {
size_t offset = Traits::offset,
size_t size = Traits::sizeInBytes,
void *ptr = Traits::hostPtr,
GraphicsAllocation *mapAllocation = Traits::mapAllocation,
cl_uint numEventsInWaitList = Traits::numEventsInWaitList,
const cl_event *eventWaitList = Traits::eventWaitList,
cl_event *event = Traits::event) {
@ -515,6 +521,7 @@ struct EnqueueWriteBufferHelper {
offset,
size,
ptr,
mapAllocation,
numEventsInWaitList,
eventWaitList,
event);

1
unit_tests/command_queue/enqueue_map_image_tests.cpp
View File

@ -209,6 +209,7 @@ HWTEST_F(EnqueueMapImageTest, givenTiledImageWhenMapImageIsCalledThenStorageIsSe
region, nullptr, nullptr, 0,
nullptr, nullptr, retVal);
EXPECT_TRUE(mockImage.ownershipTaken);
pDevice->getMemoryManager()->freeGraphicsMemory(mockImage.getMapAllocation());
mockImage.releaseAllocatedMapPtr();
}

8
unit_tests/command_queue/enqueue_read_buffer_event_tests.cpp
View File

@ -35,6 +35,7 @@ TEST_F(EnqueueReadBuffer, eventShouldBeReturned) {
offset,
size,
pDestMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -85,6 +86,7 @@ TEST_F(EnqueueReadBuffer, eventReturnedShouldBeMaxOfInputEventsAndCmdQPlus1) {
offset,
size,
pDestMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -123,6 +125,7 @@ TEST_F(EnqueueReadBuffer, givenInOrderQueueAndForcedCpuCopyOnReadBufferAndDstPtr
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -155,6 +158,7 @@ TEST_F(EnqueueReadBuffer, givenInOrderQueueAndForcedCpuCopyOnReadBufferAndDstPtr
0,
size,
ptr,
nullptr,
0,
nullptr,
&event);
@ -197,6 +201,7 @@ TEST_F(EnqueueReadBuffer, givenOutOfOrderQueueAndForcedCpuCopyOnReadBufferAndDst
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -233,6 +238,7 @@ TEST_F(EnqueueReadBuffer, givenInOrderQueueAndForcedCpuCopyOnReadBufferAndEventN
0,
size,
mem,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -277,6 +283,7 @@ TEST_F(EnqueueReadBuffer, givenInOrderQueueAndDisabledSupportCpuCopiesAndDstPtrE
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -318,6 +325,7 @@ TEST_F(EnqueueReadBuffer, givenOutOfOrderQueueAndDisabledSupportCpuCopiesAndDstP
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);

17
unit_tests/command_queue/enqueue_read_buffer_tests.cpp
View File

@ -287,6 +287,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenAlignedPointerAndAlignedSizeWhenReadBuf
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -304,6 +305,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenNotAlignedPointerAndAlignedSizeWhenRead
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -320,6 +322,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenNotAlignedPointerAndAlignedSizeWhenRead
0,
MemoryConstants::cacheLineSize,
ptr2,
nullptr,
0,
nullptr,
nullptr);
@ -340,6 +343,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPtr
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -359,6 +363,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstPt
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -377,6 +382,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesA
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -395,6 +401,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopies
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -413,6 +420,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopies
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -431,6 +439,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesA
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -447,6 +456,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenCommandQueueWhenEnqueueReadBufferIsCall
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -474,6 +484,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenEnqueueReadBufferCalledWhenLockedPtrInT
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -502,6 +513,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenForcedCpuCopyWhenEnqueueReadCompressedB
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -517,6 +529,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenForcedCpuCopyWhenEnqueueReadCompressedB
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -545,6 +558,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, gicenEnqueueReadBufferCalledWhenLockedPtrInT
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -565,6 +579,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenEnqueueReadBufferBlockingWhenAUBDumpAll
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -586,6 +601,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenEnqueueReadBufferNonBlockingWhenAUBDump
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -604,6 +620,7 @@ HWTEST_F(NegativeFailAllocationTest, givenEnqueueReadBufferWhenHostPtrAllocation
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);

2
unit_tests/command_queue/enqueue_thread_tests.cpp
View File

@ -135,6 +135,7 @@ HWTEST_F(EnqueueThreading, enqueueReadBuffer) {
0,
1024u,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -158,6 +159,7 @@ HWTEST_F(EnqueueThreading, enqueueWriteBuffer) {
0,
1024u,
ptr,
nullptr,
0,
nullptr,
nullptr);

8
unit_tests/command_queue/enqueue_write_buffer_event_tests.cpp
View File

@ -35,6 +35,7 @@ TEST_F(EnqueueWriteBufferTypeTest, eventShouldBeReturned) {
offset,
size,
pDestMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -85,6 +86,7 @@ TEST_F(EnqueueWriteBufferTypeTest, eventReturnedShouldBeMaxOfInputEventsAndCmdQP
offset,
size,
pDestMemory,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -124,6 +126,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndForcedCpuCopyOnWriteBuffe
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -160,6 +163,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndForcedCpuCopyOnWriteBuffe
0,
size,
mem,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -194,6 +198,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndForcedCpuCopyOnWriteBuffe
0,
size,
ptr,
nullptr,
0,
nullptr,
&event);
@ -236,6 +241,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenOutOfOrderQueueAndForcedCpuCopyOnWriteBu
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -276,6 +282,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopiesA
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);
@ -317,6 +324,7 @@ TEST_F(EnqueueWriteBufferTypeTest, givenOutOfOrderQueueAndDisabledSupportCpuCopi
0,
size,
ptr,
nullptr,
numEventsInWaitList,
eventWaitList,
&event);

11
unit_tests/command_queue/enqueue_write_buffer_tests.cpp
View File

@ -263,6 +263,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithEnabledSupportCpuCopiesAndDstPt
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -283,6 +284,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenOOQWithDisabledSupportCpuCopiesAndDstP
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -302,6 +304,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopies
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -320,6 +323,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopie
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -338,6 +342,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndDisabledSupportCpuCopie
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -356,6 +361,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopies
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -383,6 +389,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenEnqueueWriteBufferCalledWhenLockedPtrI
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -411,6 +418,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenForcedCpuCopyWhenEnqueueWriteCompresse
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -426,6 +434,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenForcedCpuCopyWhenEnqueueWriteCompresse
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -454,6 +463,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, givenEnqueueWriteBufferCalledWhenLockedPtrI
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -471,6 +481,7 @@ HWTEST_F(NegativeFailAllocationTest, givenEnqueueWriteBufferWhenHostPtrAllocatio
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);

1
unit_tests/command_queue/ioq_task_tests.cpp
View File

@ -90,6 +90,7 @@ TEST_F(IOQ, enqueueReadBuffer_blockingAndNonBlockedOnUserEvent) {
0,
BufferDefaults::sizeInBytes,
alignedReadPtr,
nullptr,
1,
&userEvent,
nullptr);

1
unit_tests/command_queue/ioq_task_tests_mt.cpp
View File

@ -42,6 +42,7 @@ TEST_F(IOQTaskTestsMt, enqueueReadBuffer_blockingAndBlockedOnUserEvent) {
0,
BufferDefaults::sizeInBytes,
alignedReadPtr,
nullptr,
1,
&userEvent,
nullptr);

12
unit_tests/command_queue/multiple_map_buffer_tests.cpp
View File

@ -46,18 +46,21 @@ struct MultipleMapBufferTest : public DeviceFixture, public ::testing::Test {
MockCmdQ(Context *context, Device *device) : CommandQueueHw<T>(context, device, 0) {}
cl_int enqueueReadBuffer(Buffer *buffer, cl_bool blockingRead, size_t offset, size_t size, void *ptr,
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {
GraphicsAllocation *mapAllocation, cl_uint numEventsInWaitList, const cl_event *eventWaitList,
cl_event *event) override {
enqueueSize = size;
enqueueOffset = offset;
readBufferCalled++;
if (failOnReadBuffer) {
return CL_OUT_OF_RESOURCES;
}
return CommandQueueHw<T>::enqueueReadBuffer(buffer, blockingRead, offset, size, ptr, numEventsInWaitList, eventWaitList, event);
return CommandQueueHw<T>::enqueueReadBuffer(buffer, blockingRead, offset, size, ptr, mapAllocation,
numEventsInWaitList, eventWaitList, event);
}
cl_int enqueueWriteBuffer(Buffer *buffer, cl_bool blockingWrite, size_t offset, size_t cb, const void *ptr,
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {
GraphicsAllocation *mapAllocation, cl_uint numEventsInWaitList, const cl_event *eventWaitList,
cl_event *event) override {
enqueueSize = cb;
enqueueOffset = offset;
unmapPtr = ptr;
@ -65,7 +68,8 @@ struct MultipleMapBufferTest : public DeviceFixture, public ::testing::Test {
if (failOnWriteBuffer) {
return CL_OUT_OF_RESOURCES;
}
return CommandQueueHw<T>::enqueueWriteBuffer(buffer, blockingWrite, offset, cb, ptr, numEventsInWaitList, eventWaitList, event);
return CommandQueueHw<T>::enqueueWriteBuffer(buffer, blockingWrite, offset, cb, ptr, mapAllocation,
numEventsInWaitList, eventWaitList, event);
}
cl_int enqueueMarkerWithWaitList(cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {

1
unit_tests/command_queue/ooq_task_tests.cpp
View File

@ -252,6 +252,7 @@ TEST_F(OOQTaskTests, enqueueReadBuffer_blockingAndNonBlockedOnUserEvent) {
0,
BufferDefaults::sizeInBytes,
alignedReadPtr,
nullptr,
1,
&userEvent,
nullptr);

1
unit_tests/command_queue/ooq_task_tests_mt.cpp
View File

@ -48,6 +48,7 @@ TEST_F(OOQTaskTestsMt, enqueueReadBuffer_blockingAndBlockedOnUserEvent) {
0,
BufferDefaults::sizeInBytes,
alignedReadPtr,
nullptr,
1,
&userEvent,
nullptr);

4
unit_tests/command_queue/read_write_buffer_cpu_copy.cpp
View File

@ -60,6 +60,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, simpleRead) {
offset,
size - offset,
unalignedReadPtr,
nullptr,
0,
nullptr,
nullptr);
@ -100,6 +101,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, givenDeviceThatDoesntSupportCpuCopiesWhenRe
offset,
size - offset,
unalignedReadPtr,
nullptr,
0,
nullptr,
nullptr);
@ -142,6 +144,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, givenDeviceThatDoesntSupportCpuCopiesWhenWr
offset,
size - offset,
unalignedWritePtr,
nullptr,
0,
nullptr,
nullptr);
@ -186,6 +189,7 @@ HWTEST_F(ReadWriteBufferCpuCopyTest, simpleWrite) {
offset,
size - offset,
unalignedWritePtr,
nullptr,
0,
nullptr,
nullptr);

8
unit_tests/command_queue/zero_size_enqueue_tests.cpp
View File

@ -118,7 +118,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerTest, enqueueReadBufferWhenZeroSizeEnqueueIsDetec
MockBuffer buffer;
size_t memory[1];
size_t zeroSize = 0;
mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, 0, nullptr, nullptr);
mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, nullptr);
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
}
@ -129,7 +129,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerTest, enqueueReadBufferWhenZeroSizeEnqueueIsDetec
MockBuffer buffer;
size_t memory[1];
size_t zeroSize = 0;
mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, 0, nullptr, &event);
mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, &event);
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
auto pEvent = (Event *)event;
@ -207,7 +207,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerTest, enqueueWriteBufferWhenZeroSizeEnqueueIsDete
MockBuffer buffer;
size_t memory[1];
size_t zeroSize = 0;
mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, 0, nullptr, nullptr);
mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, nullptr);
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
}
@ -218,7 +218,7 @@ HWTEST_F(ZeroSizeEnqueueHandlerTest, enqueueWriteBufferWhenZeroSizeEnqueueIsDete
MockBuffer buffer;
size_t memory[1];
size_t zeroSize = 0;
mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, 0, nullptr, &event);
mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, &event);
EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
auto pEvent = (Event *)event;

2
unit_tests/command_stream/command_stream_receiver_flush_task_1_tests.cpp
View File

@ -970,7 +970,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenBlockedKernelRequiringDCFlush
auto &commandStreamCSR = commandStreamReceiver.getCS();
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, 1, &blockingEvent, 0);
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 1, &blockingEvent, 0);
// Expect nothing was sent
EXPECT_EQ(0u, commandStreamCSR.getUsed());

10
unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp
View File

@ -44,7 +44,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenBlockedKernelNotRequiringDCFl
auto &commandStreamCSR = commandStreamReceiver.getCS();
commandQueue.enqueueWriteBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, 1, &blockingEvent, 0);
commandQueue.enqueueWriteBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 1, &blockingEvent, 0);
// Expect nothing was sent
EXPECT_EQ(0u, commandStreamCSR.getUsed());
@ -241,7 +241,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenEventIsQueried) {
commandStreamReceiver.taskCount = taskCount;
EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount());
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, 0, 0, &event);
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, &event);
EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount());
@ -314,11 +314,11 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests,
// Call requiring DCFlush, nonblocking
buffer->forceDisallowCPUCopy = true;
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, 0, 0, 0);
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, 0);
EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount());
commandQueue.enqueueReadBuffer(buffer, CL_TRUE, 0, sizeof(tempBuffer), dstBuffer, 0, 0, &event);
commandQueue.enqueueReadBuffer(buffer, CL_TRUE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, &event);
EXPECT_EQ(2u, commandStreamReceiver.peekLatestSentTaskCount());
@ -637,7 +637,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenNDRangeKer
auto buffer = Buffer::create(&ctx, CL_MEM_USE_HOST_PTR, sizeof(tempBuffer), tempBuffer, retVal);
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, 0, 0, 0);
commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, 0);
// Parse command list
parseCommands<FamilyType>(commandQueue);

2
unit_tests/command_stream/command_stream_receiver_flush_task_3_tests.cpp
View File

@ -1374,7 +1374,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandQueueWithThrottleHintW
buffer->forceDisallowCPUCopy = true;
uint32_t outPtr;
commandQueue.enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &outPtr, 0, nullptr, nullptr);
commandQueue.enqueueReadBuffer(buffer.get(), CL_TRUE, 0, 1, &outPtr, nullptr, 0, nullptr, nullptr);
EXPECT_EQ(QueueThrottle::LOW, mockCsr->passedDispatchFlags.throttle);
}

2
unit_tests/command_stream/command_stream_receiver_hw_tests.cpp
View File

@ -249,4 +249,4 @@ HWTEST_F(CommandStreamReceiverHwTest, WhenScratchSpaceIsRequiredThenCorrectAddre
uint64_t expectedScratchAddress = 0xAAABBBCCCDDD000ull;
scratchController->getScratchSpaceAllocation()->setCpuPtrAndGpuAddress(scratchController->getScratchSpaceAllocation()->getUnderlyingBuffer(), expectedScratchAddress);
EXPECT_TRUE(UnitTestHelper<FamilyType>::evaluateGshAddressForScratchSpace((expectedScratchAddress - MemoryConstants::pageSize), scratchController->calculateNewGSH()));
}
}

10
unit_tests/context/driver_diagnostics_enqueue_tests.cpp
View File

@ -23,6 +23,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingReadWhenEnqueueReadBufferI
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -46,6 +47,7 @@ TEST_P(PerformanceHintEnqueueReadBufferTest, GivenHostPtrAndSizeAlignmentsWhenEn
0,
sizeForReadBuffer,
(void *)addressForReadBuffer,
nullptr,
0,
nullptr,
nullptr);
@ -154,6 +156,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingWriteAndBufferDoesntSha
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -171,6 +174,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingWriteAndBufferSharesMem
0,
MemoryConstants::cacheLineSize,
address,
nullptr,
0,
nullptr,
nullptr);
@ -188,6 +192,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingWriteAndBufferDoesntShareM
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -205,6 +210,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingWriteAndBufferSharesMemWit
0,
MemoryConstants::cacheLineSize,
address,
nullptr,
0,
nullptr,
nullptr);
@ -222,6 +228,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingReadAndBufferDoesntShar
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -239,6 +246,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenNonBlockingReadAndBufferSharesMemW
0,
MemoryConstants::cacheLineSize,
address,
nullptr,
0,
nullptr,
nullptr);
@ -256,6 +264,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingReadAndBufferDoesntShareMe
0,
MemoryConstants::cacheLineSize,
ptr,
nullptr,
0,
nullptr,
nullptr);
@ -273,6 +282,7 @@ TEST_F(PerformanceHintEnqueueBufferTest, GivenBlockingReadAndBufferSharesMemWith
0,
MemoryConstants::cacheLineSize,
address,
nullptr,
0,
nullptr,
nullptr);

4
unit_tests/event/user_events_tests_mt.cpp
View File

@ -74,7 +74,7 @@ TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsC
uEvent.setStatus(CL_COMPLETE);
});
auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), sizeOfWaitList, eventWaitList, nullptr);
auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
t.join();
@ -103,7 +103,7 @@ TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsC
uEvent.setStatus(CL_COMPLETE);
});
auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), sizeOfWaitList, eventWaitList, nullptr);
auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
t.join();
}

14
unit_tests/mem_obj/mem_obj_tests.cpp
View File

@ -464,3 +464,17 @@ TEST(MemObj, givenGraphicsAllocationWhenCallingIsAllocDumpableThenItReturnsTheCo
gfxAllocation.setAllocDumpable(true);
EXPECT_TRUE(gfxAllocation.isAllocDumpable());
}
TEST(MemObj, givenMemObjNotUsingHostPtrWhenGettingBasePtrTwiceReturnSameMapPtr) {
MockContext context;
MemObj memObj(&context, CL_MEM_OBJECT_BUFFER, CL_MEM_READ_WRITE,
1, nullptr, nullptr, nullptr, true, false, false);
void *mapPtr = memObj.getBasePtrForMap();
EXPECT_NE(nullptr, mapPtr);
auto mapAllocation = memObj.getMapAllocation();
ASSERT_NE(nullptr, mapAllocation);
EXPECT_EQ(mapPtr, mapAllocation->getUnderlyingBuffer());
EXPECT_EQ(mapPtr, memObj.getAllocatedMapPtr());
}

43
unit_tests/mem_obj/sub_buffer_tests.cpp
View File

@ -162,4 +162,47 @@ TEST_F(SubBufferTest, GivenBufferWithMemoryStorageAndNullHostPtrWhenSubBufferIsC
buffer->release();
}
TEST_F(SubBufferTest, givenBufferWithHostPtrWhenSubbufferGetsMapPtrThenExpectBufferHostPtr) {
cl_buffer_region region = {0, 16};
auto subBuffer = buffer->createSubBuffer(CL_MEM_READ_WRITE, &region, retVal);
ASSERT_NE(nullptr, subBuffer);
ASSERT_EQ(CL_SUCCESS, retVal);
void *mapPtr = subBuffer->getBasePtrForMap();
EXPECT_EQ(pHostPtr, mapPtr);
mapPtr = subBuffer->getBasePtrForMap();
EXPECT_EQ(pHostPtr, mapPtr);
subBuffer->release();
}
TEST_F(SubBufferTest, givenBufferWithNoHostPtrWhenSubbufferGetsMapPtrThenExpectBufferMap) {
cl_buffer_region region = {0, 16};
Buffer *buffer = Buffer::create(&context, CL_MEM_READ_WRITE,
MemoryConstants::pageSize, nullptr, retVal);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(CL_SUCCESS, retVal);
auto subBuffer = buffer->createSubBuffer(CL_MEM_READ_WRITE, &region, retVal);
ASSERT_NE(nullptr, subBuffer);
ASSERT_EQ(CL_SUCCESS, retVal);
void *mapPtr = subBuffer->getBasePtrForMap();
void *bufferMapPtr = buffer->getBasePtrForMap();
EXPECT_EQ(bufferMapPtr, mapPtr);
auto mapAllocation = subBuffer->getMapAllocation();
auto bufferMapAllocation = buffer->getMapAllocation();
ASSERT_NE(nullptr, bufferMapAllocation);
EXPECT_EQ(bufferMapAllocation, mapAllocation);
EXPECT_EQ(bufferMapPtr, mapAllocation->getUnderlyingBuffer());
mapPtr = subBuffer->getBasePtrForMap();
EXPECT_EQ(bufferMapPtr, mapPtr);
subBuffer->release();
buffer->release();
}
} // namespace ULT

8
unit_tests/mocks/mock_command_queue.h
View File

@ -7,6 +7,7 @@
#pragma once
#include "runtime/command_queue/command_queue_hw.h"
#include "runtime/memory_manager/graphics_allocation.h"
#include "unit_tests/libult/ult_command_stream_receiver.h"
////////////////////////////////////////////////////////////////////////////////
@ -46,7 +47,8 @@ class MockCommandQueue : public CommandQueue {
}
cl_int enqueueWriteBuffer(Buffer *buffer, cl_bool blockingWrite, size_t offset, size_t size, const void *ptr,
cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {
GraphicsAllocation *mapAllocation, cl_uint numEventsInWaitList, const cl_event *eventWaitList,
cl_event *event) override {
writeBufferCounter++;
writeBufferBlocking = (CL_TRUE == blockingWrite);
writeBufferOffset = offset;
@ -114,10 +116,10 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
return BaseClass::cpuDataTransferHandler(transferProperties, eventsRequest, retVal);
}
cl_int enqueueWriteBuffer(Buffer *buffer, cl_bool blockingWrite, size_t offset, size_t size,
const void *ptr, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {
const void *ptr, GraphicsAllocation *mapAllocation, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) override {
EnqueueWriteBufferCounter++;
blockingWriteBuffer = blockingWrite == CL_TRUE;
return BaseClass::enqueueWriteBuffer(buffer, blockingWrite, offset, size, ptr, numEventsInWaitList, eventWaitList, event);
return BaseClass::enqueueWriteBuffer(buffer, blockingWrite, offset, size, ptr, mapAllocation, numEventsInWaitList, eventWaitList, event);
}
void enqueueHandlerHook(const unsigned int commandType, const MultiDispatchInfo &dispatchInfo) override {

2
unit_tests/scenarios/windows/enqueue_read_write_buffer_scenarios_windows_tests.cpp
View File

@ -81,7 +81,7 @@ HWTEST_F(EnqueueBufferWindowsTest, givenMisalignedHostPtrWhenEnqueueReadBufferCa
char *misalignedPtr = reinterpret_cast<char *>(memory) + 1;
buffer->forceDisallowCPUCopy = true;
auto retVal = cmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 4, misalignedPtr, 0, nullptr, nullptr);
auto retVal = cmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 4, misalignedPtr, nullptr, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(0, cmdQ->lastEnqueuedKernels.size());
Kernel *kernel = cmdQ->lastEnqueuedKernels[0];