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

Limit usage of getBcsCommandStreamReceiver() 

Signed-off-by: Maciej Dziuban <maciej.dziuban@intel.com>
This commit is contained in:
Maciej Dziuban 2021-08-25 16:03:15 +00:00 committed by Compute-Runtime-Automation
parent 638d0b4b63
commit 42524b6bef
9 changed files with 74 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -137,6 +137,13 @@ CommandStreamReceiver *CommandQueue::getBcsCommandStreamReceiver() const {
return nullptr; return nullptr;
} }
CommandStreamReceiver *CommandQueue::getBcsForAuxTranslation() const {
if (bcsEngine) {
return bcsEngine->commandStreamReceiver;
}
return nullptr;
}
CommandStreamReceiver &CommandQueue::getCommandStreamReceiver(bool blitAllowed) const { CommandStreamReceiver &CommandQueue::getCommandStreamReceiver(bool blitAllowed) const {
if (blitAllowed) { if (blitAllowed) {
auto csr = getBcsCommandStreamReceiver(); auto csr = getBcsCommandStreamReceiver();
@ -626,9 +633,8 @@ void CommandQueue::releaseIndirectHeap(IndirectHeap::Type heapType) {
getGpgpuCommandStreamReceiver().releaseIndirectHeap(heapType); getGpgpuCommandStreamReceiver().releaseIndirectHeap(heapType);
} }
void CommandQueue::obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, bool blitEnqueue) { void CommandQueue::obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, CommandStreamReceiver &csr) {
auto allocator = blitEnqueue ? getBcsCommandStreamReceiver()->getTimestampPacketAllocator() TagAllocatorBase *allocator = csr.getTimestampPacketAllocator();
: getGpgpuCommandStreamReceiver().getTimestampPacketAllocator();
previousNodes.swapNodes(*timestampPacketContainer); previousNodes.swapNodes(*timestampPacketContainer);
@ -716,7 +722,7 @@ bool CommandQueue::queueDependenciesClearRequired() const {
} }
bool CommandQueue::blitEnqueueAllowed(cl_command_type cmdType) const { bool CommandQueue::blitEnqueueAllowed(cl_command_type cmdType) const {
auto blitterSupported = (getBcsCommandStreamReceiver() != nullptr); auto blitterSupported = bcsEngine != nullptr;
bool blitEnqueueAllowed = getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled() || this->isCopyOnly; bool blitEnqueueAllowed = getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled() || this->isCopyOnly;
if (DebugManager.flags.EnableBlitterForEnqueueOperations.get() != -1) { if (DebugManager.flags.EnableBlitterForEnqueueOperations.get() != -1) {

3
opencl/source/command_queue/command_queue.h
View File

@ -223,6 +223,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
MOCKABLE_VIRTUAL CommandStreamReceiver &getGpgpuCommandStreamReceiver() const; MOCKABLE_VIRTUAL CommandStreamReceiver &getGpgpuCommandStreamReceiver() const;
CommandStreamReceiver *getBcsCommandStreamReceiver() const; CommandStreamReceiver *getBcsCommandStreamReceiver() const;
CommandStreamReceiver *getBcsForAuxTranslation() const;
MOCKABLE_VIRTUAL CommandStreamReceiver &getCommandStreamReceiver(bool blitAllowed) const; MOCKABLE_VIRTUAL CommandStreamReceiver &getCommandStreamReceiver(bool blitAllowed) const;
Device &getDevice() const noexcept; Device &getDevice() const noexcept;
ClDevice &getClDevice() const { return *device; } ClDevice &getClDevice() const { return *device; }
@ -344,7 +345,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
virtual void obtainTaskLevelAndBlockedStatus(unsigned int &taskLevel, cl_uint &numEventsInWaitList, const cl_event *&eventWaitList, bool &blockQueueStatus, unsigned int commandType){}; virtual void obtainTaskLevelAndBlockedStatus(unsigned int &taskLevel, cl_uint &numEventsInWaitList, const cl_event *&eventWaitList, bool &blockQueueStatus, unsigned int commandType){};
bool isBlockedCommandStreamRequired(uint32_t commandType, const EventsRequest &eventsRequest, bool blockedQueue, bool isMarkerWithProfiling) const; bool isBlockedCommandStreamRequired(uint32_t commandType, const EventsRequest &eventsRequest, bool blockedQueue, bool isMarkerWithProfiling) const;
MOCKABLE_VIRTUAL void obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, bool blitEnqueue); MOCKABLE_VIRTUAL void obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, CommandStreamReceiver &csr);
void storeProperties(const cl_queue_properties *properties); void storeProperties(const cl_queue_properties *properties);
void processProperties(const cl_queue_properties *properties); void processProperties(const cl_queue_properties *properties);
void overrideEngine(aub_stream::EngineType engineType, EngineUsage engineUsage); void overrideEngine(aub_stream::EngineType engineType, EngineUsage engineUsage);

11
opencl/source/command_queue/command_queue_hw.h
View File

@ -383,7 +383,8 @@ class CommandQueueHw : public CommandQueue {
EventsRequest &eventsRequest, EventsRequest &eventsRequest,
EventBuilder &eventBuilder, EventBuilder &eventBuilder,
uint32_t taskLevel, uint32_t taskLevel,
PrintfHandler *printfHandler); PrintfHandler *printfHandler,
CommandStreamReceiver *bcsCsr);
void enqueueBlocked(uint32_t commandType, void enqueueBlocked(uint32_t commandType,
Surface **surfacesForResidency, Surface **surfacesForResidency,
@ -406,7 +407,8 @@ class CommandQueueHw : public CommandQueue {
EventsRequest &eventsRequest, EventsRequest &eventsRequest,
EventBuilder &eventBuilder, EventBuilder &eventBuilder,
uint32_t taskLevel, uint32_t taskLevel,
CsrDependencies &csrDeps); CsrDependencies &csrDeps,
CommandStreamReceiver *bcsCsr);
void processDispatchForCacheFlush(Surface **surfaces, void processDispatchForCacheFlush(Surface **surfaces,
size_t numSurfaces, size_t numSurfaces,
LinearStream *commandStream, LinearStream *commandStream,
@ -419,7 +421,8 @@ class CommandQueueHw : public CommandQueue {
LinearStream *commandStream, LinearStream *commandStream,
EventsRequest &eventsRequest, EventsRequest &eventsRequest,
CsrDependencies &csrDeps); CsrDependencies &csrDeps);
BlitProperties processDispatchForBlitEnqueue(const MultiDispatchInfo &multiDispatchInfo, BlitProperties processDispatchForBlitEnqueue(CommandStreamReceiver &blitCommandStreamReceiver,
const MultiDispatchInfo &multiDispatchInfo,
TimestampPacketDependencies &timestampPacketDependencies, TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest, const EventsRequest &eventsRequest,
LinearStream *commandStream, LinearStream *commandStream,
@ -477,7 +480,7 @@ class CommandQueueHw : public CommandQueue {
return commandStream; return commandStream;
} }
void processDispatchForBlitAuxTranslation(const MultiDispatchInfo &multiDispatchInfo, BlitPropertiesContainer &blitPropertiesContainer, void processDispatchForBlitAuxTranslation(CommandStreamReceiver &bcsCsr, const MultiDispatchInfo &multiDispatchInfo, BlitPropertiesContainer &blitPropertiesContainer,
TimestampPacketDependencies &timestampPacketDependencies, const EventsRequest &eventsRequest, TimestampPacketDependencies &timestampPacketDependencies, const EventsRequest &eventsRequest,
bool queueBlocked); bool queueBlocked);

51
opencl/source/command_queue/enqueue_common.h
View File

@ -228,7 +228,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
} }
if (nodesCount > 0) { if (nodesCount > 0) {
obtainNewTimestampPacketNodes(nodesCount, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, false); obtainNewTimestampPacketNodes(nodesCount, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, getGpgpuCommandStreamReceiver());
csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes); csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes);
} }
} }
@ -242,8 +242,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
} }
if (enqueueWithBlitAuxTranslation) { if (enqueueWithBlitAuxTranslation) {
processDispatchForBlitAuxTranslation(multiDispatchInfo, blitPropertiesContainer, timestampPacketDependencies, processDispatchForBlitAuxTranslation(*getBcsForAuxTranslation(), multiDispatchInfo, blitPropertiesContainer,
eventsRequest, blockQueue); timestampPacketDependencies, eventsRequest, blockQueue);
} }
if (eventBuilder.getEvent() && getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled()) { if (eventBuilder.getEvent() && getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled()) {
@ -323,7 +323,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
eventsRequest, eventsRequest,
eventBuilder, eventBuilder,
taskLevel, taskLevel,
printfHandler.get()); printfHandler.get(),
getBcsForAuxTranslation());
if (parentKernel) { if (parentKernel) {
getGpgpuCommandStreamReceiver().setMediaVFEStateDirty(true); getGpgpuCommandStreamReceiver().setMediaVFEStateDirty(true);
@ -345,7 +346,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
eventsRequest, eventsRequest,
eventBuilder, eventBuilder,
taskLevel, taskLevel,
csrDeps); csrDeps,
nullptr);
} else { } else {
UNRECOVERABLE_IF(enqueueProperties.operation != EnqueueProperties::Operation::EnqueueWithoutSubmission); UNRECOVERABLE_IF(enqueueProperties.operation != EnqueueProperties::Operation::EnqueueWithoutSubmission);
@ -489,18 +491,17 @@ void CommandQueueHw<GfxFamily>::processDispatchForKernels(const MultiDispatchInf
} }
template <typename GfxFamily> template <typename GfxFamily>
BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(const MultiDispatchInfo &multiDispatchInfo, BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(CommandStreamReceiver &blitCommandStreamReceiver,
const MultiDispatchInfo &multiDispatchInfo,
TimestampPacketDependencies &timestampPacketDependencies, TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest, LinearStream *commandStream, const EventsRequest &eventsRequest, LinearStream *commandStream,
uint32_t commandType, bool queueBlocked) { uint32_t commandType, bool queueBlocked) {
auto blitDirection = ClBlitProperties::obtainBlitDirection(commandType); auto blitDirection = ClBlitProperties::obtainBlitDirection(commandType);
auto blitCommandStreamReceiver = getBcsCommandStreamReceiver(); auto blitProperties = ClBlitProperties::constructProperties(blitDirection, blitCommandStreamReceiver,
auto blitProperties = ClBlitProperties::constructProperties(blitDirection, *blitCommandStreamReceiver,
multiDispatchInfo.peekBuiltinOpParams()); multiDispatchInfo.peekBuiltinOpParams());
if (!queueBlocked) { if (!queueBlocked) {
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(blitProperties.csrDependencies, *blitCommandStreamReceiver, eventsRequest.fillCsrDependenciesForTimestampPacketContainer(blitProperties.csrDependencies, blitCommandStreamReceiver,
CsrDependencies::DependenciesType::All); CsrDependencies::DependenciesType::All);
blitProperties.csrDependencies.timestampPacketContainer.push_back(&timestampPacketDependencies.cacheFlushNodes); blitProperties.csrDependencies.timestampPacketContainer.push_back(&timestampPacketDependencies.cacheFlushNodes);
@ -530,7 +531,8 @@ BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(const Mu
} }
template <typename GfxFamily> template <typename GfxFamily>
void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(const MultiDispatchInfo &multiDispatchInfo, void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(CommandStreamReceiver &bcsCsr,
const MultiDispatchInfo &multiDispatchInfo,
BlitPropertiesContainer &blitPropertiesContainer, BlitPropertiesContainer &blitPropertiesContainer,
TimestampPacketDependencies &timestampPacketDependencies, TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest, bool queueBlocked) { const EventsRequest &eventsRequest, bool queueBlocked) {
@ -569,10 +571,10 @@ void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(const Multi
if (!queueBlocked) { if (!queueBlocked) {
CsrDependencies csrDeps; CsrDependencies csrDeps;
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *getBcsCommandStreamReceiver(), CsrDependencies::DependenciesType::All); eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, bcsCsr, CsrDependencies::DependenciesType::All);
BlitProperties::setupDependenciesForAuxTranslation(blitPropertiesContainer, timestampPacketDependencies, BlitProperties::setupDependenciesForAuxTranslation(blitPropertiesContainer, timestampPacketDependencies,
*this->timestampPacketContainer, csrDeps, *this->timestampPacketContainer, csrDeps,
getGpgpuCommandStreamReceiver(), *getBcsCommandStreamReceiver()); getGpgpuCommandStreamReceiver(), bcsCsr);
} }
} }
@ -741,7 +743,8 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
EventsRequest &eventsRequest, EventsRequest &eventsRequest,
EventBuilder &eventBuilder, EventBuilder &eventBuilder,
uint32_t taskLevel, uint32_t taskLevel,
PrintfHandler *printfHandler) { PrintfHandler *printfHandler,
CommandStreamReceiver *bcsCsr) {
UNRECOVERABLE_IF(multiDispatchInfo.empty()); UNRECOVERABLE_IF(multiDispatchInfo.empty());
@ -906,7 +909,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
} }
if (enqueueProperties.blitPropertiesContainer->size() > 0) { if (enqueueProperties.blitPropertiesContainer->size() > 0) {
this->bcsTaskCount = getBcsCommandStreamReceiver()->blitBuffer(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice()); this->bcsTaskCount = bcsCsr->blitBuffer(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice());
dispatchFlags.implicitFlush = true; dispatchFlags.implicitFlush = true;
} }
@ -1041,7 +1044,8 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
EventsRequest &eventsRequest, EventsRequest &eventsRequest,
EventBuilder &eventBuilder, EventBuilder &eventBuilder,
uint32_t taskLevel, uint32_t taskLevel,
CsrDependencies &csrDeps) { CsrDependencies &csrDeps,
CommandStreamReceiver *bcsCsr) {
CompletionStamp completionStamp = {this->taskCount, this->taskLevel, this->flushStamp->peekStamp()}; CompletionStamp completionStamp = {this->taskCount, this->taskLevel, this->flushStamp->peekStamp()};
bool flushGpgpuCsr = true; bool flushGpgpuCsr = true;
@ -1120,7 +1124,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
if (enqueueProperties.operation == EnqueueProperties::Operation::Blit) { if (enqueueProperties.operation == EnqueueProperties::Operation::Blit) {
UNRECOVERABLE_IF(!enqueueProperties.blitPropertiesContainer); UNRECOVERABLE_IF(!enqueueProperties.blitPropertiesContainer);
this->bcsTaskCount = getBcsCommandStreamReceiver()->blitBuffer(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice()); this->bcsTaskCount = bcsCsr->blitBuffer(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice());
} }
return completionStamp; return completionStamp;
@ -1157,6 +1161,7 @@ template <typename GfxFamily>
template <uint32_t cmdType> template <uint32_t cmdType>
void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispatchInfo, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event, bool blocking) { void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispatchInfo, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event, bool blocking) {
auto commandStreamRecieverOwnership = getGpgpuCommandStreamReceiver().obtainUniqueOwnership(); auto commandStreamRecieverOwnership = getGpgpuCommandStreamReceiver().obtainUniqueOwnership();
auto bcsCsr = getBcsCommandStreamReceiver();
EventsRequest eventsRequest(numEventsInWaitList, eventWaitList, event); EventsRequest eventsRequest(numEventsInWaitList, eventWaitList, event);
EventBuilder eventBuilder; EventBuilder eventBuilder;
@ -1182,8 +1187,8 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
BlitPropertiesContainer blitPropertiesContainer; BlitPropertiesContainer blitPropertiesContainer;
CsrDependencies csrDeps; CsrDependencies csrDeps;
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *getBcsCommandStreamReceiver(), CsrDependencies::DependenciesType::All); eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *bcsCsr, CsrDependencies::DependenciesType::All);
auto allocator = getBcsCommandStreamReceiver()->getTimestampPacketAllocator(); auto allocator = bcsCsr->getTimestampPacketAllocator();
if (isCacheFlushForBcsRequired() && isGpgpuSubmissionForBcsRequired(blockQueue)) { if (isCacheFlushForBcsRequired() && isGpgpuSubmissionForBcsRequired(blockQueue)) {
timestampPacketDependencies.cacheFlushNodes.add(allocator->getTag()); timestampPacketDependencies.cacheFlushNodes.add(allocator->getTag());
@ -1193,7 +1198,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
timestampPacketDependencies.barrierNodes.add(allocator->getTag()); timestampPacketDependencies.barrierNodes.add(allocator->getTag());
} }
obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, true); obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, *bcsCsr);
csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes); csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes);
LinearStream *gpgpuCommandStream = {}; LinearStream *gpgpuCommandStream = {};
@ -1207,7 +1212,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
eventBuilder.getEvent()->addTimestampPacketNodes(*timestampPacketContainer); eventBuilder.getEvent()->addTimestampPacketNodes(*timestampPacketContainer);
} }
blitPropertiesContainer.push_back(processDispatchForBlitEnqueue(multiDispatchInfo, timestampPacketDependencies, blitPropertiesContainer.push_back(processDispatchForBlitEnqueue(*bcsCsr, multiDispatchInfo, timestampPacketDependencies,
eventsRequest, gpgpuCommandStream, cmdType, blockQueue)); eventsRequest, gpgpuCommandStream, cmdType, blockQueue));
CompletionStamp completionStamp = {CompletionStamp::notReady, taskLevel, 0}; CompletionStamp completionStamp = {CompletionStamp::notReady, taskLevel, 0};
@ -1215,7 +1220,9 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
const EnqueueProperties enqueueProperties(true, false, false, false, false, &blitPropertiesContainer); const EnqueueProperties enqueueProperties(true, false, false, false, false, &blitPropertiesContainer);
if (!blockQueue) { if (!blockQueue) {
completionStamp = enqueueCommandWithoutKernel(nullptr, 0, gpgpuCommandStream, gpgpuCommandStreamStart, blocking, enqueueProperties, timestampPacketDependencies, eventsRequest, eventBuilder, taskLevel, csrDeps); completionStamp = enqueueCommandWithoutKernel(nullptr, 0, gpgpuCommandStream, gpgpuCommandStreamStart, blocking,
enqueueProperties, timestampPacketDependencies, eventsRequest,
eventBuilder, taskLevel, csrDeps, bcsCsr);
if (eventBuilder.getEvent()) { if (eventBuilder.getEvent()) {
eventBuilder.getEvent()->flushStamp->replaceStampObject(this->flushStamp->getStampReference()); eventBuilder.getEvent()->flushStamp->replaceStampObject(this->flushStamp->getStampReference());

10
opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp
View File

@ -1673,24 +1673,24 @@ HWTEST_TEMPLATED_F(BlitEnqueueWithDisabledGpgpuSubmissionTests, givenCacheFlushR
HWTEST_TEMPLATED_F(BlitEnqueueWithDisabledGpgpuSubmissionTests, givenSubmissionToDifferentEngineWhenRequestingForNewTimestmapPacketThenDontClearDependencies) { HWTEST_TEMPLATED_F(BlitEnqueueWithDisabledGpgpuSubmissionTests, givenSubmissionToDifferentEngineWhenRequestingForNewTimestmapPacketThenDontClearDependencies) {
auto mockCommandQueue = static_cast<MockCommandQueueHw<FamilyType> *>(commandQueue.get()); auto mockCommandQueue = static_cast<MockCommandQueueHw<FamilyType> *>(commandQueue.get());
const bool clearDependencies = true; const bool clearDependencies = true;
const bool blitEnqueue = true; auto &gpgpuCsr = mockCommandQueue->getGpgpuCommandStreamReceiver();
const bool nonBlitEnqueue = false; auto &blitCsr = *mockCommandQueue->getBcsCommandStreamReceiver();
{ {
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, nonBlitEnqueue); // init mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, gpgpuCsr); // init
EXPECT_EQ(0u, previousNodes.peekNodes().size()); EXPECT_EQ(0u, previousNodes.peekNodes().size());
} }
{ {
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitEnqueue); mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitCsr);
EXPECT_EQ(1u, previousNodes.peekNodes().size()); EXPECT_EQ(1u, previousNodes.peekNodes().size());
} }
{ {
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitEnqueue); mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitCsr);
EXPECT_EQ(0u, previousNodes.peekNodes().size()); EXPECT_EQ(0u, previousNodes.peekNodes().size());
} }
} }

24
opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp
View File

@ -55,7 +55,7 @@ HWTEST_F(EnqueueHandlerTest, GivenCommandStreamWithoutKernelWhenCommandEnqueuedT
EnqueueProperties enqueueProperties(false, false, false, true, false, nullptr); EnqueueProperties enqueueProperties(false, false, false, true, false, nullptr);
mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, nullptr);
EXPECT_EQ(allocation->getTaskCount(mockCmdQ->getGpgpuCommandStreamReceiver().getOsContext().getContextId()), 1u); EXPECT_EQ(allocation->getTaskCount(mockCmdQ->getGpgpuCommandStreamReceiver().getOsContext().getContextId()), 1u);
} }
@ -97,7 +97,7 @@ HWTEST_F(EnqueueHandlerTimestampEnabledTest, givenProflingAndTimeStampPacketsEna
EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u); EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u);
mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, nullptr);
EXPECT_NE(ev->submitTimeStamp.CPUTimeinNS, 0u); EXPECT_NE(ev->submitTimeStamp.CPUTimeinNS, 0u);
EXPECT_NE(ev->submitTimeStamp.GPUTimeStamp, 0u); EXPECT_NE(ev->submitTimeStamp.GPUTimeStamp, 0u);
@ -129,7 +129,7 @@ HWTEST_F(EnqueueHandlerTimestampDisabledTest, givenProflingEnabledTimeStampPacke
EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u); EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u);
mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(surfaces, 1, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, nullptr);
EXPECT_NE(ev->submitTimeStamp.CPUTimeinNS, 0u); EXPECT_NE(ev->submitTimeStamp.CPUTimeinNS, 0u);
EXPECT_NE(ev->submitTimeStamp.GPUTimeStamp, 0u); EXPECT_NE(ev->submitTimeStamp.GPUTimeStamp, 0u);
@ -207,7 +207,7 @@ HWTEST_F(DispatchFlagsTests, whenEnqueueCommandWithoutKernelThenPassCorrectDispa
EnqueueProperties enqueueProperties(false, false, false, true, false, nullptr); EnqueueProperties enqueueProperties(false, false, false, true, false, nullptr);
mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, nullptr);
EXPECT_EQ(blocking, mockCsr->passedDispatchFlags.blocking); EXPECT_EQ(blocking, mockCsr->passedDispatchFlags.blocking);
EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush); EXPECT_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
@ -235,7 +235,7 @@ HWTEST_F(DispatchFlagsTests, whenEnqueueCommandWithoutKernelThenPassCorrectThrot
bool blocking = true; bool blocking = true;
mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, nullptr);
EXPECT_EQ(mockCmdQ->throttle, mockCsr->passedDispatchFlags.throttle); EXPECT_EQ(mockCmdQ->throttle, mockCsr->passedDispatchFlags.throttle);
} }
@ -264,10 +264,10 @@ HWTEST_F(DispatchFlagsTests, givenBlitEnqueueWhenDispatchingCommandsWithoutKerne
multiDispatchInfo.setBuiltinOpParams(builtinOpParams); multiDispatchInfo.setBuiltinOpParams(builtinOpParams);
CsrDependencies csrDeps; CsrDependencies csrDeps;
mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, true); mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, *mockCmdQ->getBcsCommandStreamReceiver());
timestampPacketDependencies.cacheFlushNodes.add(mockCmdQ->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator()->getTag()); timestampPacketDependencies.cacheFlushNodes.add(mockCmdQ->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator()->getTag());
BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(multiDispatchInfo, timestampPacketDependencies, BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(*mockCmdQ->getBcsCommandStreamReceiver(), multiDispatchInfo, timestampPacketDependencies,
eventsRequest, &mockCmdQ->getCS(0), CL_COMMAND_READ_BUFFER, false); eventsRequest, &mockCmdQ->getCS(0), CL_COMMAND_READ_BUFFER, false);
BlitPropertiesContainer blitPropertiesContainer; BlitPropertiesContainer blitPropertiesContainer;
@ -275,7 +275,7 @@ HWTEST_F(DispatchFlagsTests, givenBlitEnqueueWhenDispatchingCommandsWithoutKerne
EnqueueProperties enqueueProperties(true, false, false, false, false, &blitPropertiesContainer); EnqueueProperties enqueueProperties(true, false, false, false, false, &blitPropertiesContainer);
mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocking, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, mockCmdQ->getBcsCommandStreamReceiver());
EXPECT_TRUE(mockCsr->passedDispatchFlags.implicitFlush); EXPECT_TRUE(mockCsr->passedDispatchFlags.implicitFlush);
EXPECT_TRUE(mockCsr->passedDispatchFlags.guardCommandBufferWithPipeControl); EXPECT_TRUE(mockCsr->passedDispatchFlags.guardCommandBufferWithPipeControl);
@ -308,9 +308,9 @@ HWTEST_F(DispatchFlagsTests, givenN1EnabledWhenDispatchingWithoutKernelThenAllow
MultiDispatchInfo multiDispatchInfo; MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.setBuiltinOpParams(builtinOpParams); multiDispatchInfo.setBuiltinOpParams(builtinOpParams);
mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, true); mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, *mockCmdQ->getBcsCommandStreamReceiver());
timestampPacketDependencies.cacheFlushNodes.add(mockCmdQ->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator()->getTag()); timestampPacketDependencies.cacheFlushNodes.add(mockCmdQ->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator()->getTag());
BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(multiDispatchInfo, timestampPacketDependencies, BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(*mockCmdQ->getBcsCommandStreamReceiver(), multiDispatchInfo, timestampPacketDependencies,
eventsRequest, &mockCmdQ->getCS(0), CL_COMMAND_READ_BUFFER, false); eventsRequest, &mockCmdQ->getCS(0), CL_COMMAND_READ_BUFFER, false);
BlitPropertiesContainer blitPropertiesContainer; BlitPropertiesContainer blitPropertiesContainer;
blitPropertiesContainer.push_back(blitProperties); blitPropertiesContainer.push_back(blitProperties);
@ -320,12 +320,12 @@ HWTEST_F(DispatchFlagsTests, givenN1EnabledWhenDispatchingWithoutKernelThenAllow
mockCsr->nTo1SubmissionModelEnabled = false; mockCsr->nTo1SubmissionModelEnabled = false;
mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocked, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocked, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, mockCmdQ->getBcsCommandStreamReceiver());
EXPECT_FALSE(mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed); EXPECT_FALSE(mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed);
mockCsr->nTo1SubmissionModelEnabled = true; mockCsr->nTo1SubmissionModelEnabled = true;
mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocked, enqueueProperties, timestampPacketDependencies, mockCmdQ->enqueueCommandWithoutKernel(nullptr, 0, &mockCmdQ->getCS(0), 0, blocked, enqueueProperties, timestampPacketDependencies,
eventsRequest, eventBuilder, 0, csrDeps); eventsRequest, eventBuilder, 0, csrDeps, mockCmdQ->getBcsCommandStreamReceiver());
EXPECT_TRUE(mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed); EXPECT_TRUE(mockCsr->passedDispatchFlags.outOfOrderExecutionAllowed);
} }

4
opencl/test/unit_test/command_queue/enqueue_handler_tests.cpp
View File

@ -114,9 +114,9 @@ struct EnqueueHandlerWithAubSubCaptureTests : public EnqueueHandlerTest {
CommandQueueHw<FamilyType>::waitUntilComplete(gpgpuTaskCountToWait, bcsTaskCountToWait, flushStampToWait, useQuickKmdSleep); CommandQueueHw<FamilyType>::waitUntilComplete(gpgpuTaskCountToWait, bcsTaskCountToWait, flushStampToWait, useQuickKmdSleep);
} }
void obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, bool blitEnqueue) override { void obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, CommandStreamReceiver &csr) override {
timestampPacketDependenciesCleared = clearAllDependencies; timestampPacketDependenciesCleared = clearAllDependencies;
CommandQueueHw<FamilyType>::obtainNewTimestampPacketNodes(numberOfNodes, previousNodes, clearAllDependencies, blitEnqueue); CommandQueueHw<FamilyType>::obtainNewTimestampPacketNodes(numberOfNodes, previousNodes, clearAllDependencies, csr);
} }
bool waitUntilCompleteCalled = false; bool waitUntilCompleteCalled = false;

12
opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp
View File

@ -1183,7 +1183,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingNonBlockedT
auto cmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, device.get(), nullptr); auto cmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, device.get(), nullptr);
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, false); cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ->getGpgpuCommandStreamReceiver());
auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0); auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0);
csr.storeMakeResidentAllocations = true; csr.storeMakeResidentAllocations = true;
@ -1205,7 +1205,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingBlockedThen
auto cmdQ = clUniquePtr(new MockCommandQueueHw<FamilyType>(context, device.get(), nullptr)); auto cmdQ = clUniquePtr(new MockCommandQueueHw<FamilyType>(context, device.get(), nullptr));
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, false); cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ->getGpgpuCommandStreamReceiver());
auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0); auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0);
csr.storeMakeResidentAllocations = true; csr.storeMakeResidentAllocations = true;
@ -1231,7 +1231,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingThenKeepDep
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr); MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr);
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
cmdQ.obtainNewTimestampPacketNodes(2, previousNodes, false, false); cmdQ.obtainNewTimestampPacketNodes(2, previousNodes, false, cmdQ.getGpgpuCommandStreamReceiver());
firstNode.add(cmdQ.timestampPacketContainer->peekNodes().at(0)); firstNode.add(cmdQ.timestampPacketContainer->peekNodes().at(0));
firstNode.add(cmdQ.timestampPacketContainer->peekNodes().at(1)); firstNode.add(cmdQ.timestampPacketContainer->peekNodes().at(1));
auto firstTag0 = firstNode.getNode(0); auto firstTag0 = firstNode.getNode(0);
@ -1264,7 +1264,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingToOoqThenDo
cl_queue_properties properties[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0}; cl_queue_properties properties[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0};
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), properties); MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), properties);
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
cmdQ.obtainNewTimestampPacketNodes(1, previousNodes, false, false); cmdQ.obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ.getGpgpuCommandStreamReceiver());
cmdQ.enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); cmdQ.enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@ -1290,7 +1290,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingWithOmitTim
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr); MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr);
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
cmdQ.obtainNewTimestampPacketNodes(1, previousNodes, false, false); cmdQ.obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ.getGpgpuCommandStreamReceiver());
cmdQ.enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); cmdQ.enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@ -1441,7 +1441,7 @@ TEST_F(TimestampPacketTests, givenDispatchSizeWhenAskingForNewTimestampsThenObta
EXPECT_EQ(0u, mockCmdQ->timestampPacketContainer->peekNodes().size()); EXPECT_EQ(0u, mockCmdQ->timestampPacketContainer->peekNodes().size());
TimestampPacketContainer previousNodes; TimestampPacketContainer previousNodes;
mockCmdQ->obtainNewTimestampPacketNodes(dispatchSize, previousNodes, false, false); mockCmdQ->obtainNewTimestampPacketNodes(dispatchSize, previousNodes, false, mockCmdQ->getGpgpuCommandStreamReceiver());
EXPECT_EQ(dispatchSize, mockCmdQ->timestampPacketContainer->peekNodes().size()); EXPECT_EQ(dispatchSize, mockCmdQ->timestampPacketContainer->peekNodes().size());
} }

2
opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp
View File

@ -444,7 +444,7 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenBlockedBlitEnqueueWhenUnblockingThenMake
bufferForBlt->forceDisallowCPUCopy = true; bufferForBlt->forceDisallowCPUCopy = true;
TimestampPacketContainer previousTimestampPackets; TimestampPacketContainer previousTimestampPackets;
mockCmdQ->obtainNewTimestampPacketNodes(1, previousTimestampPackets, false, true); mockCmdQ->obtainNewTimestampPacketNodes(1, previousTimestampPackets, false, *mockCmdQ->getBcsCommandStreamReceiver());
auto dependencyFromPreviousEnqueue = mockCmdQ->timestampPacketContainer->peekNodes()[0]; auto dependencyFromPreviousEnqueue = mockCmdQ->timestampPacketContainer->peekNodes()[0];
auto event = make_releaseable<Event>(mockCmdQ, CL_COMMAND_READ_BUFFER, 0, 0); auto event = make_releaseable<Event>(mockCmdQ, CL_COMMAND_READ_BUFFER, 0, 0);