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

Update for resolving dependencies by pipecontrol

Browse Source 
Flag ResolveDependenciesViaPipeControls now removes only same csr
dependencies. Still enables pipe controls.

Works through hwInfoConfig method isResolveDependenciesByPipeControlsSupported

Related-To: NEO-7321

Signed-off-by: Dominik Dabek <dominik.dabek@intel.com>
This commit is contained in:
Dominik Dabek
2022-11-29 13:28:05 +00:00
committed by Compute-Runtime-Automation
parent 1fa5710dff
commit 4adba15dbb
12 changed files with 113 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1277,49 +1277,65 @@ HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteEnabledAndDependenciesRe
EXPECT_EQ(1u, semaphoresFound); // total number of semaphores found in cmdList
}
HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteEnabledAndDependenciesResolvedViaPipeControlsIfPreviousOperationIsGPUKernelThenDoNotProgramSemaphores) {
HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteEnabledAndDependenciesResolvedViaPipeControlsAndSingleIOQWhenEnqueueKernelThenDoNotProgramSemaphoresButProgramPipeControlBeforeGpgpuWalker) {
DebugManagerStateRestore restorer;
DebugManager.flags.ResolveDependenciesViaPipeControls.set(1);
DebugManager.flags.ProgramGlobalFenceAsMiMemFenceCommandInCommandStream.set(1);
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
using WALKER = typename FamilyType::WALKER_TYPE;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
using MI_BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;
device->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = true;
MockMultiDispatchInfo multiDispatchInfo(device.get(), std::vector<Kernel *>({kernel->mockKernel}));
auto cmdQ1 = std::make_unique<MockCommandQueueHw<FamilyType>>(context, device.get(), nullptr);
auto &cmdStream = mockCmdQ->getCS(0);
mockCmdQ->updateLatestSentEnqueueType(NEO::EnqueueProperties::Operation::GpuKernel);
const cl_uint eventsOnWaitlist = 1;
MockTimestampPacketContainer timestamp(*device->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator(), 1);
const cl_uint eventsOnWaitlist = 4;
MockTimestampPacketContainer timestamp3(*device->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator(), 1);
MockTimestampPacketContainer timestamp4(*device->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator(), 1);
Event event(mockCmdQ, 0, 0, 0);
event.addTimestampPacketNodes(timestamp);
UserEvent event1;
event1.setStatus(CL_COMPLETE);
UserEvent event2;
event2.setStatus(CL_COMPLETE);
Event event3(cmdQ1.get(), 0, 0, 0);
event3.addTimestampPacketNodes(timestamp3);
Event event4(cmdQ1.get(), 0, 0, 0);
event4.addTimestampPacketNodes(timestamp4);
cl_event waitlist[] = {&event};
EventsRequest eventsRequest(eventsOnWaitlist, waitlist, nullptr);
CsrDependencies csrDeps;
eventsRequest.fillCsrDependenciesForTimestampPacketContainer(csrDeps, mockCmdQ->getGpgpuCommandStreamReceiver(), CsrDependencies::DependenciesType::OnCsr);
HardwareInterfaceWalkerArgs walkerArgs = createHardwareInterfaceWalkerArgs(CL_COMMAND_NDRANGE_KERNEL);
HardwareInterface<FamilyType>::dispatchWalker(
*mockCmdQ,
multiDispatchInfo,
csrDeps,
walkerArgs);
cl_event waitlist[] = {&event1, &event2, &event3, &event4};
ASSERT_EQ(cmdQ1->enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 0u, nullptr, nullptr), CL_SUCCESS);
ASSERT_EQ(cmdQ1->enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, eventsOnWaitlist, waitlist, nullptr), CL_SUCCESS);
ASSERT_NE(cmdQ1->commandStream, nullptr);
HardwareParse hwParser;
hwParser.parseCommands<FamilyType>(cmdStream, 0);
hwParser.parseCommands<FamilyType>(*cmdQ1->commandStream, 0u);
uint32_t semaphoresFound = 0;
for (auto it = hwParser.cmdList.begin(); it != hwParser.cmdList.end(); it++) {
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*it);
if (semaphoreCmd) {
semaphoresFound++;
auto it = hwParser.cmdList.begin();
size_t pipeControlCountFirstEnqueue = 0u;
size_t pipeControlCountSecondEnqueue = 0u;
size_t semaphoreWaitCount = 0u;
size_t currentEnqueue = 1u;
while (it != hwParser.cmdList.end()) {
MI_SEMAPHORE_WAIT *semaphoreWaitCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*it);
PIPE_CONTROL *pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*it);
MI_BATCH_BUFFER_END *miBatchBufferEnd = genCmdCast<MI_BATCH_BUFFER_END *>(*it);
if (pipeControlCmd != nullptr) {
if (currentEnqueue == 1) {
++pipeControlCountFirstEnqueue;
} else if (currentEnqueue == 2) {
++pipeControlCountSecondEnqueue;
}
} else if (semaphoreWaitCmd != nullptr) {
++semaphoreWaitCount;
} else if (miBatchBufferEnd != nullptr) {
if (++currentEnqueue > 2) {
break;
}
}
++it;
}
EXPECT_EQ(0u, semaphoresFound);
EXPECT_EQ(semaphoreWaitCount, 0u);
EXPECT_EQ(pipeControlCountSecondEnqueue, pipeControlCountFirstEnqueue + 1);
}
HWTEST_F(TimestampPacketTests, givenAlreadyAssignedNodeWhenEnqueueingNonBlockedThenMakeItResident) {