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;
}
CommandStreamReceiver *CommandQueue::getBcsForAuxTranslation() const {
if (bcsEngine) {
return bcsEngine->commandStreamReceiver;
}
return nullptr;
}
CommandStreamReceiver &CommandQueue::getCommandStreamReceiver(bool blitAllowed) const {
if (blitAllowed) {
auto csr = getBcsCommandStreamReceiver();
@ -626,9 +633,8 @@ void CommandQueue::releaseIndirectHeap(IndirectHeap::Type heapType) {
getGpgpuCommandStreamReceiver().releaseIndirectHeap(heapType);
}
void CommandQueue::obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, bool blitEnqueue) {
auto allocator = blitEnqueue ? getBcsCommandStreamReceiver()->getTimestampPacketAllocator()
: getGpgpuCommandStreamReceiver().getTimestampPacketAllocator();
void CommandQueue::obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, CommandStreamReceiver &csr) {
TagAllocatorBase *allocator = csr.getTimestampPacketAllocator();
previousNodes.swapNodes(*timestampPacketContainer);
@ -716,7 +722,7 @@ bool CommandQueue::queueDependenciesClearRequired() const {
}
bool CommandQueue::blitEnqueueAllowed(cl_command_type cmdType) const {
auto blitterSupported = (getBcsCommandStreamReceiver() != nullptr);
auto blitterSupported = bcsEngine != nullptr;
bool blitEnqueueAllowed = getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled() || this->isCopyOnly;
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;
CommandStreamReceiver *getBcsCommandStreamReceiver() const;
CommandStreamReceiver *getBcsForAuxTranslation() const;
MOCKABLE_VIRTUAL CommandStreamReceiver &getCommandStreamReceiver(bool blitAllowed) const;
Device &getDevice() const noexcept;
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){};
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 processProperties(const cl_queue_properties *properties);
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,
EventBuilder &eventBuilder,
uint32_t taskLevel,
PrintfHandler *printfHandler);
PrintfHandler *printfHandler,
CommandStreamReceiver *bcsCsr);
void enqueueBlocked(uint32_t commandType,
Surface **surfacesForResidency,
@ -406,7 +407,8 @@ class CommandQueueHw : public CommandQueue {
EventsRequest &eventsRequest,
EventBuilder &eventBuilder,
uint32_t taskLevel,
CsrDependencies &csrDeps);
CsrDependencies &csrDeps,
CommandStreamReceiver *bcsCsr);
void processDispatchForCacheFlush(Surface **surfaces,
size_t numSurfaces,
LinearStream *commandStream,
@ -419,7 +421,8 @@ class CommandQueueHw : public CommandQueue {
LinearStream *commandStream,
EventsRequest &eventsRequest,
CsrDependencies &csrDeps);
BlitProperties processDispatchForBlitEnqueue(const MultiDispatchInfo &multiDispatchInfo,
BlitProperties processDispatchForBlitEnqueue(CommandStreamReceiver &blitCommandStreamReceiver,
const MultiDispatchInfo &multiDispatchInfo,
TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest,
LinearStream *commandStream,
@ -477,7 +480,7 @@ class CommandQueueHw : public CommandQueue {
return commandStream;
}
void processDispatchForBlitAuxTranslation(const MultiDispatchInfo &multiDispatchInfo, BlitPropertiesContainer &blitPropertiesContainer,
void processDispatchForBlitAuxTranslation(CommandStreamReceiver &bcsCsr, const MultiDispatchInfo &multiDispatchInfo, BlitPropertiesContainer &blitPropertiesContainer,
TimestampPacketDependencies &timestampPacketDependencies, const EventsRequest &eventsRequest,
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) {
obtainNewTimestampPacketNodes(nodesCount, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, false);
obtainNewTimestampPacketNodes(nodesCount, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, getGpgpuCommandStreamReceiver());
csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes);
}
}
@ -242,8 +242,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
}
if (enqueueWithBlitAuxTranslation) {
processDispatchForBlitAuxTranslation(multiDispatchInfo, blitPropertiesContainer, timestampPacketDependencies,
eventsRequest, blockQueue);
processDispatchForBlitAuxTranslation(*getBcsForAuxTranslation(), multiDispatchInfo, blitPropertiesContainer,
timestampPacketDependencies, eventsRequest, blockQueue);
}
if (eventBuilder.getEvent() && getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled()) {
@ -323,7 +323,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
eventsRequest,
eventBuilder,
taskLevel,
printfHandler.get());
printfHandler.get(),
getBcsForAuxTranslation());
if (parentKernel) {
getGpgpuCommandStreamReceiver().setMediaVFEStateDirty(true);
@ -345,7 +346,8 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
eventsRequest,
eventBuilder,
taskLevel,
csrDeps);
csrDeps,
nullptr);
} else {
UNRECOVERABLE_IF(enqueueProperties.operation != EnqueueProperties::Operation::EnqueueWithoutSubmission);
@ -489,18 +491,17 @@ void CommandQueueHw<GfxFamily>::processDispatchForKernels(const MultiDispatchInf
}
template <typename GfxFamily>
BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(const MultiDispatchInfo &multiDispatchInfo,
BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(CommandStreamReceiver &blitCommandStreamReceiver,
const MultiDispatchInfo &multiDispatchInfo,
TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest, LinearStream *commandStream,
uint32_t commandType, bool queueBlocked) {
auto blitDirection = ClBlitProperties::obtainBlitDirection(commandType);
auto blitCommandStreamReceiver = getBcsCommandStreamReceiver();
auto blitProperties = ClBlitProperties::constructProperties(blitDirection, *blitCommandStreamReceiver,
auto blitProperties = ClBlitProperties::constructProperties(blitDirection, blitCommandStreamReceiver,
multiDispatchInfo.peekBuiltinOpParams());
if (!queueBlocked) {
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(blitProperties.csrDependencies, *blitCommandStreamReceiver,
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(blitProperties.csrDependencies, blitCommandStreamReceiver,
CsrDependencies::DependenciesType::All);
blitProperties.csrDependencies.timestampPacketContainer.push_back(&timestampPacketDependencies.cacheFlushNodes);
@ -530,7 +531,8 @@ BlitProperties CommandQueueHw<GfxFamily>::processDispatchForBlitEnqueue(const Mu
}
template <typename GfxFamily>
void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(const MultiDispatchInfo &multiDispatchInfo,
void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(CommandStreamReceiver &bcsCsr,
const MultiDispatchInfo &multiDispatchInfo,
BlitPropertiesContainer &blitPropertiesContainer,
TimestampPacketDependencies &timestampPacketDependencies,
const EventsRequest &eventsRequest, bool queueBlocked) {
@ -569,10 +571,10 @@ void CommandQueueHw<GfxFamily>::processDispatchForBlitAuxTranslation(const Multi
if (!queueBlocked) {
CsrDependencies csrDeps;
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *getBcsCommandStreamReceiver(), CsrDependencies::DependenciesType::All);
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, bcsCsr, CsrDependencies::DependenciesType::All);
BlitProperties::setupDependenciesForAuxTranslation(blitPropertiesContainer, timestampPacketDependencies,
*this->timestampPacketContainer, csrDeps,
getGpgpuCommandStreamReceiver(), *getBcsCommandStreamReceiver());
getGpgpuCommandStreamReceiver(), bcsCsr);
}
}
@ -741,7 +743,8 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
EventsRequest &eventsRequest,
EventBuilder &eventBuilder,
uint32_t taskLevel,
PrintfHandler *printfHandler) {
PrintfHandler *printfHandler,
CommandStreamReceiver *bcsCsr) {
UNRECOVERABLE_IF(multiDispatchInfo.empty());
@ -906,7 +909,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
}
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;
}
@ -1041,7 +1044,8 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
EventsRequest &eventsRequest,
EventBuilder &eventBuilder,
uint32_t taskLevel,
CsrDependencies &csrDeps) {
CsrDependencies &csrDeps,
CommandStreamReceiver *bcsCsr) {
CompletionStamp completionStamp = {this->taskCount, this->taskLevel, this->flushStamp->peekStamp()};
bool flushGpgpuCsr = true;
@ -1120,7 +1124,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
if (enqueueProperties.operation == EnqueueProperties::Operation::Blit) {
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;
@ -1157,6 +1161,7 @@ template <typename GfxFamily>
template <uint32_t cmdType>
void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispatchInfo, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event, bool blocking) {
auto commandStreamRecieverOwnership = getGpgpuCommandStreamReceiver().obtainUniqueOwnership();
auto bcsCsr = getBcsCommandStreamReceiver();
EventsRequest eventsRequest(numEventsInWaitList, eventWaitList, event);
EventBuilder eventBuilder;
@ -1182,8 +1187,8 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
BlitPropertiesContainer blitPropertiesContainer;
CsrDependencies csrDeps;
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *getBcsCommandStreamReceiver(), CsrDependencies::DependenciesType::All);
auto allocator = getBcsCommandStreamReceiver()->getTimestampPacketAllocator();
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, *bcsCsr, CsrDependencies::DependenciesType::All);
auto allocator = bcsCsr->getTimestampPacketAllocator();
if (isCacheFlushForBcsRequired() && isGpgpuSubmissionForBcsRequired(blockQueue)) {
timestampPacketDependencies.cacheFlushNodes.add(allocator->getTag());
@ -1193,7 +1198,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
timestampPacketDependencies.barrierNodes.add(allocator->getTag());
}
obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, true);
obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, clearAllDependencies, *bcsCsr);
csrDeps.timestampPacketContainer.push_back(&timestampPacketDependencies.previousEnqueueNodes);
LinearStream *gpgpuCommandStream = {};
@ -1207,7 +1212,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDispat
eventBuilder.getEvent()->addTimestampPacketNodes(*timestampPacketContainer);
}
blitPropertiesContainer.push_back(processDispatchForBlitEnqueue(multiDispatchInfo, timestampPacketDependencies,
blitPropertiesContainer.push_back(processDispatchForBlitEnqueue(*bcsCsr, multiDispatchInfo, timestampPacketDependencies,
eventsRequest, gpgpuCommandStream, cmdType, blockQueue));
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);
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()) {
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) {
auto mockCommandQueue = static_cast<MockCommandQueueHw<FamilyType> *>(commandQueue.get());
const bool clearDependencies = true;
const bool blitEnqueue = true;
const bool nonBlitEnqueue = false;
auto &gpgpuCsr = mockCommandQueue->getGpgpuCommandStreamReceiver();
auto &blitCsr = *mockCommandQueue->getBcsCommandStreamReceiver();
{
TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, nonBlitEnqueue); // init
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, gpgpuCsr); // init
EXPECT_EQ(0u, previousNodes.peekNodes().size());
}
{
TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitEnqueue);
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitCsr);
EXPECT_EQ(1u, previousNodes.peekNodes().size());
}
{
TimestampPacketContainer previousNodes;
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitEnqueue);
mockCommandQueue->obtainNewTimestampPacketNodes(1, previousNodes, clearDependencies, blitCsr);
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);
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);
}
@ -97,7 +97,7 @@ HWTEST_F(EnqueueHandlerTimestampEnabledTest, givenProflingAndTimeStampPacketsEna
EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u);
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.GPUTimeStamp, 0u);
@ -129,7 +129,7 @@ HWTEST_F(EnqueueHandlerTimestampDisabledTest, givenProflingEnabledTimeStampPacke
EXPECT_EQ(ev->submitTimeStamp.GPUTimeStamp, 0u);
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.GPUTimeStamp, 0u);
@ -207,7 +207,7 @@ HWTEST_F(DispatchFlagsTests, whenEnqueueCommandWithoutKernelThenPassCorrectDispa
EnqueueProperties enqueueProperties(false, false, false, true, false, nullptr);
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_FALSE(mockCsr->passedDispatchFlags.implicitFlush);
@ -235,7 +235,7 @@ HWTEST_F(DispatchFlagsTests, whenEnqueueCommandWithoutKernelThenPassCorrectThrot
bool blocking = true;
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);
}
@ -264,10 +264,10 @@ HWTEST_F(DispatchFlagsTests, givenBlitEnqueueWhenDispatchingCommandsWithoutKerne
multiDispatchInfo.setBuiltinOpParams(builtinOpParams);
CsrDependencies csrDeps;
mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, true);
mockCmdQ->obtainNewTimestampPacketNodes(1, timestampPacketDependencies.previousEnqueueNodes, true, *mockCmdQ->getBcsCommandStreamReceiver());
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);
BlitPropertiesContainer blitPropertiesContainer;
@ -275,7 +275,7 @@ HWTEST_F(DispatchFlagsTests, givenBlitEnqueueWhenDispatchingCommandsWithoutKerne
EnqueueProperties enqueueProperties(true, false, false, false, false, &blitPropertiesContainer);
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.guardCommandBufferWithPipeControl);
@ -308,9 +308,9 @@ HWTEST_F(DispatchFlagsTests, givenN1EnabledWhenDispatchingWithoutKernelThenAllow
MultiDispatchInfo multiDispatchInfo;
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());
BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(multiDispatchInfo, timestampPacketDependencies,
BlitProperties blitProperties = mockCmdQ->processDispatchForBlitEnqueue(*mockCmdQ->getBcsCommandStreamReceiver(), multiDispatchInfo, timestampPacketDependencies,
eventsRequest, &mockCmdQ->getCS(0), CL_COMMAND_READ_BUFFER, false);
BlitPropertiesContainer blitPropertiesContainer;
blitPropertiesContainer.push_back(blitProperties);
@ -320,12 +320,12 @@ HWTEST_F(DispatchFlagsTests, givenN1EnabledWhenDispatchingWithoutKernelThenAllow
mockCsr->nTo1SubmissionModelEnabled = false;
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);
mockCsr->nTo1SubmissionModelEnabled = true;
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);
}

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);
}
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;
CommandQueueHw<FamilyType>::obtainNewTimestampPacketNodes(numberOfNodes, previousNodes, clearAllDependencies, blitEnqueue);
CommandQueueHw<FamilyType>::obtainNewTimestampPacketNodes(numberOfNodes, previousNodes, clearAllDependencies, csr);
}
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);
TimestampPacketContainer previousNodes;
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, false);
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ->getGpgpuCommandStreamReceiver());
auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0);
csr.storeMakeResidentAllocations = true;
@ -1205,7 +1205,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingBlockedThen
auto cmdQ = clUniquePtr(new MockCommandQueueHw<FamilyType>(context, device.get(), nullptr));
TimestampPacketContainer previousNodes;
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, false);
cmdQ->obtainNewTimestampPacketNodes(1, previousNodes, false, cmdQ->getGpgpuCommandStreamReceiver());
auto firstNode = cmdQ->timestampPacketContainer->peekNodes().at(0);
csr.storeMakeResidentAllocations = true;
@ -1231,7 +1231,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingThenKeepDep
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr);
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(1));
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};
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), properties);
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);
@ -1290,7 +1290,7 @@ HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingWithOmitTim
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr);
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);
@ -1441,7 +1441,7 @@ TEST_F(TimestampPacketTests, givenDispatchSizeWhenAskingForNewTimestampsThenObta
EXPECT_EQ(0u, mockCmdQ->timestampPacketContainer->peekNodes().size());
TimestampPacketContainer previousNodes;
mockCmdQ->obtainNewTimestampPacketNodes(dispatchSize, previousNodes, false, false);
mockCmdQ->obtainNewTimestampPacketNodes(dispatchSize, previousNodes, false, mockCmdQ->getGpgpuCommandStreamReceiver());
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;
TimestampPacketContainer previousTimestampPackets;
mockCmdQ->obtainNewTimestampPacketNodes(1, previousTimestampPackets, false, true);
mockCmdQ->obtainNewTimestampPacketNodes(1, previousTimestampPackets, false, *mockCmdQ->getBcsCommandStreamReceiver());
auto dependencyFromPreviousEnqueue = mockCmdQ->timestampPacketContainer->peekNodes()[0];
auto event = make_releaseable<Event>(mockCmdQ, CL_COMMAND_READ_BUFFER, 0, 0);