mirror of
https://github.com/intel/compute-runtime.git
synced 2025-12-22 01:48:50 +08:00
Revert "feature: Append recorded commandlist into immediate (8/N)"
This reverts commit acfeffe274.
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
19602907b8
commit
3997d2a6b3
@@ -242,7 +242,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::initialize(Device *device, NEO
|
||||
this->l1CachePolicyData.init(productHelper);
|
||||
this->cmdListHeapAddressModel = L0GfxCoreHelper::getHeapAddressModel(rootDeviceEnvironment);
|
||||
this->dummyBlitWa.rootDeviceEnvironment = &(neoDevice->getRootDeviceEnvironmentRef());
|
||||
this->dispatchCmdListBatchBufferAsPrimary = L0GfxCoreHelper::dispatchCmdListBatchBufferAsPrimary(rootDeviceEnvironment, !(isImmediateType() && this->internalUsage));
|
||||
this->dispatchCmdListBatchBufferAsPrimary = L0GfxCoreHelper::dispatchCmdListBatchBufferAsPrimary(rootDeviceEnvironment, !isImmediateType());
|
||||
this->useOnlyGlobalTimestamps = gfxCoreHelper.useOnlyGlobalTimestamps();
|
||||
this->maxFillPaternSizeForCopyEngine = productHelper.getMaxFillPaternSizeForCopyEngine();
|
||||
this->heaplessModeEnabled = compilerProductHelper.isHeaplessModeEnabled();
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -193,7 +193,7 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
|
||||
void handleHeapsAndResidencyForImmediateRegularTask(void *&sshCpuBaseAddress);
|
||||
void handleDebugSurfaceStateUpdate(NEO::IndirectHeap *ssh);
|
||||
|
||||
void checkAvailableSpace(uint32_t numEvents, bool hasRelaxedOrderingDependencies, size_t commandSize, bool requestCommandBufferInLocalMem);
|
||||
void checkAvailableSpace(uint32_t numEvents, bool hasRelaxedOrderingDependencies, size_t commandSize);
|
||||
void updateDispatchFlagsWithRequiredStreamState(NEO::DispatchFlags &dispatchFlags);
|
||||
|
||||
MOCKABLE_VIRTUAL ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, bool kernelOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate);
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -51,26 +51,12 @@ CommandListCoreFamilyImmediate<gfxCoreFamily>::CommandListCoreFamilyImmediate(ui
|
||||
}
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
void CommandListCoreFamilyImmediate<gfxCoreFamily>::checkAvailableSpace(uint32_t numEvents, bool hasRelaxedOrderingDependencies, size_t commandSize, bool requestCommandBufferInLocalMem) {
|
||||
void CommandListCoreFamilyImmediate<gfxCoreFamily>::checkAvailableSpace(uint32_t numEvents, bool hasRelaxedOrderingDependencies, size_t commandSize) {
|
||||
this->commandContainer.fillReusableAllocationLists();
|
||||
|
||||
// Command container might have two command buffers - one in local mem (mainly for relaxed ordering and any other specific purposes) and one in system mem for copying into ring buffer.
|
||||
// If relaxed ordering is needed in given dispatch or if we need to force Local mem usage, and current command stream is in system memory, swap of command streams is required to ensure local memory.
|
||||
// If relaxed ordering is not needed and command buffer is in local mem, then also we need to swap.
|
||||
bool swapStreams = false;
|
||||
if (hasRelaxedOrderingDependencies) {
|
||||
if (NEO::MemoryPoolHelper::isSystemMemoryPool(this->commandContainer.getCommandStream()->getGraphicsAllocation()->getMemoryPool())) {
|
||||
swapStreams = true;
|
||||
}
|
||||
} else {
|
||||
if (requestCommandBufferInLocalMem && NEO::MemoryPoolHelper::isSystemMemoryPool(this->commandContainer.getCommandStream()->getGraphicsAllocation()->getMemoryPool())) {
|
||||
swapStreams = true;
|
||||
} else if (!requestCommandBufferInLocalMem && !NEO::MemoryPoolHelper::isSystemMemoryPool(this->commandContainer.getCommandStream()->getGraphicsAllocation()->getMemoryPool())) {
|
||||
swapStreams = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (swapStreams) {
|
||||
/* Command container might has two command buffers. If it has, one is in local memory, because relaxed ordering requires that and one in system for copying it into ring buffer.
|
||||
If relaxed ordering is needed in given dispatch and current command stream is in system memory, swap of command streams is required to ensure local memory. Same in the opposite scenario. */
|
||||
if (hasRelaxedOrderingDependencies == NEO::MemoryPoolHelper::isSystemMemoryPool(this->commandContainer.getCommandStream()->getGraphicsAllocation()->getMemoryPool())) {
|
||||
if (this->commandContainer.swapStreams()) {
|
||||
this->cmdListCurrentStartOffset = this->commandContainer.getCommandStream()->getUsed();
|
||||
}
|
||||
@@ -528,7 +514,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendLaunchKernel(
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
bool stallingCmdsForRelaxedOrdering = hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
bool hostWait = waitForEventsFromHost();
|
||||
if (hostWait) {
|
||||
this->synchronizeEventList(numWaitEvents, phWaitEvents);
|
||||
@@ -585,7 +571,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendLaunchKernelInd
|
||||
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelIndirect(kernelHandle, pDispatchArgumentsBuffer,
|
||||
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -612,7 +598,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendBarrier(ze_even
|
||||
isStallingOperation = hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch);
|
||||
}
|
||||
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize);
|
||||
|
||||
ret = CommandListCoreFamily<gfxCoreFamily>::appendBarrier(hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
|
||||
@@ -637,7 +623,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryCopy(
|
||||
auto sizePerBlit = sizeof(typename GfxFamily::XY_COPY_BLT) + NEO::BlitCommandsHelper<GfxFamily>::estimatePostBlitCommandSize();
|
||||
estimatedSize += nBlits * sizePerBlit;
|
||||
}
|
||||
checkAvailableSpace(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch, estimatedSize, false);
|
||||
checkAvailableSpace(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch, estimatedSize);
|
||||
|
||||
bool hasStallindCmds = hasStallingCmdsForRelaxedOrdering(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch);
|
||||
|
||||
@@ -693,7 +679,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryCopyRegio
|
||||
auto sizePerBlit = sizeof(typename GfxFamily::XY_COPY_BLT) + NEO::BlitCommandsHelper<GfxFamily>::estimatePostBlitCommandSize();
|
||||
estimatedSize += xBlits * yBlits * zBlits * sizePerBlit;
|
||||
}
|
||||
checkAvailableSpace(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch, estimatedSize, false);
|
||||
checkAvailableSpace(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch, estimatedSize);
|
||||
|
||||
bool hasStallindCmds = hasStallingCmdsForRelaxedOrdering(numWaitEvents, memoryCopyParams.relaxedOrderingDispatch);
|
||||
|
||||
@@ -736,7 +722,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryFill(void
|
||||
ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendMemoryFill(ptr, pattern, patternSize, size, hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
|
||||
@@ -750,7 +736,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalEvent(ze_
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(0, false);
|
||||
bool hasStallingCmds = !Event::fromHandle(hSignalEvent)->isCounterBased() || hasStallingCmdsForRelaxedOrdering(0, relaxedOrderingDispatch);
|
||||
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
ret = CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(hSignalEvent, relaxedOrderingDispatch);
|
||||
return flushImmediate(ret, true, hasStallingCmds, relaxedOrderingDispatch, false, false, hSignalEvent, false);
|
||||
}
|
||||
@@ -759,7 +745,7 @@ template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendEventReset(ze_event_handle_t hSignalEvent) {
|
||||
ze_result_t ret = ZE_RESULT_SUCCESS;
|
||||
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
ret = CommandListCoreFamily<gfxCoreFamily>::appendEventReset(hSignalEvent);
|
||||
return flushImmediate(ret, true, true, false, false, false, hSignalEvent, false);
|
||||
}
|
||||
@@ -769,7 +755,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendPageFaultCopy(N
|
||||
NEO::GraphicsAllocation *srcAllocation,
|
||||
size_t size, bool flushHost) {
|
||||
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
|
||||
ze_result_t ret;
|
||||
|
||||
@@ -806,7 +792,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitOnEvents(ui
|
||||
}
|
||||
|
||||
if (!skipFlush) {
|
||||
checkAvailableSpace(numEvents, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numEvents, false, commonImmediateCommandSize);
|
||||
}
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(numEvents, phWaitEvents, outWaitCmds, relaxedOrderingAllowed, trackDependencies, apiRequest, skipAddingWaitEventsToResidency, false, copyOffloadOperation);
|
||||
@@ -824,7 +810,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWriteGlobalTime
|
||||
uint64_t *dstptr, ze_event_handle_t hSignalEvent,
|
||||
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
|
||||
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWriteGlobalTimestamp(dstptr, hSignalEvent, numWaitEvents, phWaitEvents);
|
||||
|
||||
@@ -868,7 +854,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyRegion
|
||||
auto sizePerBlit = sizeof(typename GfxFamily::XY_BLOCK_COPY_BLT) + NEO::BlitCommandsHelper<GfxFamily>::estimatePostBlitCommandSize();
|
||||
estimatedSize += nBlits * sizePerBlit;
|
||||
}
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, estimatedSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, estimatedSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyRegion(hDstImage, hSrcImage, pDstRegion, pSrcRegion, hSignalEvent,
|
||||
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -886,7 +872,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyFromMe
|
||||
ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemory(hDstImage, srcPtr, pDstRegion, hSignalEvent,
|
||||
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -904,7 +890,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyToMemo
|
||||
ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemory(dstPtr, hSrcImage, pSrcRegion, hSignalEvent,
|
||||
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -924,7 +910,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyFromMe
|
||||
ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(hDstImage, srcPtr, pDstRegion, srcRowPitch, srcSlicePitch,
|
||||
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -944,7 +930,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyToMemo
|
||||
ze_event_handle_t *phWaitEvents, bool relaxedOrderingDispatch) {
|
||||
relaxedOrderingDispatch = isRelaxedOrderingDispatchAllowed(numWaitEvents, false);
|
||||
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, relaxedOrderingDispatch, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(dstPtr, hSrcImage, pSrcRegion, destRowPitch, destSlicePitch,
|
||||
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
|
||||
@@ -959,7 +945,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryRangesBar
|
||||
ze_event_handle_t hSignalEvent,
|
||||
uint32_t numWaitEvents,
|
||||
ze_event_handle_t *phWaitEvents) {
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize);
|
||||
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendMemoryRangesBarrier(numRanges, pRangeSizes, pRanges, hSignalEvent, numWaitEvents, phWaitEvents);
|
||||
return flushImmediate(ret, true, true, false, false, false, hSignalEvent, false);
|
||||
@@ -967,14 +953,14 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryRangesBar
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitOnMemory(void *desc, void *ptr, uint64_t data, ze_event_handle_t signalEventHandle, bool useQwordData) {
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWaitOnMemory(desc, ptr, data, signalEventHandle, useQwordData);
|
||||
return flushImmediate(ret, true, false, false, false, false, signalEventHandle, false);
|
||||
}
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWriteToMemory(void *desc, void *ptr, uint64_t data) {
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWriteToMemory(desc, ptr, data);
|
||||
return flushImmediate(ret, true, false, false, false, false, nullptr, false);
|
||||
}
|
||||
@@ -1573,10 +1559,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendCommandLists(ui
|
||||
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
|
||||
|
||||
auto ret = ZE_RESULT_SUCCESS;
|
||||
|
||||
// For API functionality, we require command buffer alloc in local mem for.
|
||||
// So ensure we force it when checking available space and when allocating any new comand buffer allocs
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize, true);
|
||||
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize);
|
||||
if (numWaitEvents) {
|
||||
ret = this->appendWaitOnEvents(numWaitEvents, phWaitEvents, nullptr, false, true, true, true, true, false);
|
||||
}
|
||||
@@ -1601,9 +1584,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendCommandLists(ui
|
||||
}
|
||||
|
||||
bool hasStallingCmds = true;
|
||||
ret = flushImmediate(ret, true, hasStallingCmds, relaxedOrderingDispatch, true, false, hSignalEvent, true);
|
||||
|
||||
return ret;
|
||||
return flushImmediate(ret, true, hasStallingCmds, relaxedOrderingDispatch, true, false, hSignalEvent, true);
|
||||
}
|
||||
|
||||
} // namespace L0
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -98,7 +98,7 @@ ze_result_t CommandQueueImp::initialize(bool copyOnly, bool isInternal, bool imm
|
||||
auto &productHelper = rootDeviceEnvironment.getHelper<NEO::ProductHelper>();
|
||||
this->doubleSbaWa = productHelper.isAdditionalStateBaseAddressWARequired(hwInfo);
|
||||
this->cmdListHeapAddressModel = L0GfxCoreHelper::getHeapAddressModel(rootDeviceEnvironment);
|
||||
this->dispatchCmdListBatchBufferAsPrimary = L0GfxCoreHelper::dispatchCmdListBatchBufferAsPrimary(rootDeviceEnvironment, !(immediateCmdListQueue && internalUsage));
|
||||
this->dispatchCmdListBatchBufferAsPrimary = L0GfxCoreHelper::dispatchCmdListBatchBufferAsPrimary(rootDeviceEnvironment, !immediateCmdListQueue);
|
||||
auto &compilerProductHelper = rootDeviceEnvironment.getHelper<NEO::CompilerProductHelper>();
|
||||
this->heaplessModeEnabled = compilerProductHelper.isHeaplessModeEnabled();
|
||||
this->heaplessStateInitEnabled = compilerProductHelper.isHeaplessStateInitEnabled(this->heaplessModeEnabled);
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -1287,6 +1287,10 @@ void CommandQueueHw<gfxCoreFamily>::programOneCmdListBatchBufferStartSecondaryBa
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx.containsParentImmediateStream) {
|
||||
NEO::EncodeBatchBufferStartOrEnd<GfxFamily>::programBatchBufferEnd(commandContainer);
|
||||
}
|
||||
}
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -1733,10 +1733,10 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenForcedPrimaryBatchBufferWhenRegular
|
||||
EXPECT_TRUE(commandList->dispatchCmdListBatchBufferAsPrimary);
|
||||
EXPECT_TRUE(commandQueue->dispatchCmdListBatchBufferAsPrimary);
|
||||
|
||||
EXPECT_TRUE(commandListImmediate->dispatchCmdListBatchBufferAsPrimary);
|
||||
EXPECT_FALSE(commandListImmediate->dispatchCmdListBatchBufferAsPrimary);
|
||||
ASSERT_NE(nullptr, commandListImmediate->cmdQImmediate);
|
||||
auto immediateCmdQueue = static_cast<L0::ult::CommandQueue *>(commandListImmediate->cmdQImmediate);
|
||||
EXPECT_TRUE(immediateCmdQueue->dispatchCmdListBatchBufferAsPrimary);
|
||||
EXPECT_FALSE(immediateCmdQueue->dispatchCmdListBatchBufferAsPrimary);
|
||||
}
|
||||
|
||||
HWTEST_F(PrimaryBatchBufferCmdListTest, givenPrimaryBatchBufferWhenAppendingKernelAndClosingCommandListThenExpectAlignedSpaceForBatchBufferStart) {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -927,7 +927,7 @@ HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamForImmediateCmdListWhenC
|
||||
auto immediateCmdList = static_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get());
|
||||
auto secondaryCmdStream = reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get();
|
||||
|
||||
immediateCmdList->checkAvailableSpace(0u, false, commonImmediateCommandSize, false);
|
||||
immediateCmdList->checkAvailableSpace(0u, false, commonImmediateCommandSize);
|
||||
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->getMemoryPool()));
|
||||
@@ -938,144 +938,6 @@ HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamForImmediateCmdListWhenC
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList->getGraphicsAllocation()->getMemoryPool()));
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamInHostMemForImmediateCmdListWhenCheckAvailableSpaceForRelaxedOrderingThenSwapCommandStreams, MatchAny) {
|
||||
auto &gfxCoreHelper = device->getGfxCoreHelper();
|
||||
auto &productHelper = device->getProductHelper();
|
||||
if (!gfxCoreHelper.isPlatformFlushTaskEnabled(productHelper)) {
|
||||
GTEST_SKIP();
|
||||
}
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.DirectSubmissionFlatRingBuffer.set(-1);
|
||||
|
||||
static_cast<MockMemoryManager *>(device->getNEODevice()->getMemoryManager())->localMemorySupported[0] = true;
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
|
||||
ze_result_t returnValue;
|
||||
CommandStreamReceiver *csr = nullptr;
|
||||
device->getCsrForOrdinalAndIndex(&csr, desc.ordinal, desc.index, ZE_COMMAND_QUEUE_PRIORITY_NORMAL, false);
|
||||
reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
|
||||
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::copy, returnValue));
|
||||
ASSERT_NE(nullptr, commandList);
|
||||
EXPECT_NE(reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get(), nullptr);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
auto immediateCmdList = static_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get());
|
||||
|
||||
auto secondaryCmdStream = reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get();
|
||||
|
||||
immediateCmdList->getCmdContainer().swapStreams();
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
immediateCmdList->checkAvailableSpace(0u, true, commonImmediateCommandSize, false);
|
||||
|
||||
EXPECT_NE(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
}
|
||||
|
||||
struct CmdContainerMockLocalAllocTests : public CommandContainer {
|
||||
using CommandContainer::secondaryCommandStreamForImmediateCmdList;
|
||||
};
|
||||
|
||||
HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamForImmediateCmdListButNotYetUsingHostAllocWhenCallingAppendCmdlistsThenDoNotSwapCommandStreams, IsPVC) {
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.DirectSubmissionFlatRingBuffer.set(-1);
|
||||
|
||||
static_cast<MockMemoryManager *>(device->getNEODevice()->getMemoryManager())->localMemorySupported[0] = true;
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
|
||||
ze_result_t returnValue;
|
||||
CommandStreamReceiver *csr = nullptr;
|
||||
device->getCsrForOrdinalAndIndex(&csr, desc.ordinal, desc.index, ZE_COMMAND_QUEUE_PRIORITY_NORMAL, false);
|
||||
reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
|
||||
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::copy, returnValue));
|
||||
ASSERT_NE(nullptr, commandList);
|
||||
EXPECT_NE(reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get(), nullptr);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
auto secondaryCmdStream = reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get();
|
||||
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::copy, 0u, returnValue, false));
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
|
||||
ze_result_t result = ZE_RESULT_SUCCESS;
|
||||
result = commandList->appendCommandLists(1u, &commandListHandle, nullptr, 0u, nullptr);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
|
||||
EXPECT_NE(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_FALSE(MemoryPoolHelper::isSystemMemoryPool(commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->getMemoryPool()));
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamForImmediateCmdListButAndUsingHostAllocWhenCallingAppendCmdlistsThenSwapCommandStreamsAndAppendSucceeds, IsAtLeastXeHpcCore) {
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.DirectSubmissionFlatRingBuffer.set(-1);
|
||||
|
||||
static_cast<MockMemoryManager *>(device->getNEODevice()->getMemoryManager())->localMemorySupported[0] = true;
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
|
||||
ze_result_t returnValue;
|
||||
CommandStreamReceiver *csr = nullptr;
|
||||
device->getCsrForOrdinalAndIndex(&csr, desc.ordinal, desc.index, ZE_COMMAND_QUEUE_PRIORITY_NORMAL, false);
|
||||
reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
|
||||
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::copy, returnValue));
|
||||
ASSERT_NE(nullptr, commandList);
|
||||
EXPECT_NE(reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get(), nullptr);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
auto secondaryCmdStream = reinterpret_cast<CmdContainerMockLocalAllocTests *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get();
|
||||
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::compute, 0u, returnValue, false));
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
|
||||
commandList->getCmdContainer().swapStreams();
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
|
||||
ze_result_t result = ZE_RESULT_SUCCESS;
|
||||
result = commandList->appendCommandLists(1u, &commandListHandle, nullptr, 0u, nullptr);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
|
||||
EXPECT_NE(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListCreate, givenSecondaryCommandStreamForImmediateCmdListAndAlreadyUsingHostAllocThenAppendingRegularCommandlistsIntoImmediateUsesLocalAndRestoresHostAlloc, MatchAny) {
|
||||
if (!device->getHwInfo().featureTable.flags.ftrLocalMemory) {
|
||||
GTEST_SKIP();
|
||||
}
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.DirectSubmissionFlatRingBuffer.set(-1);
|
||||
|
||||
static_cast<MockMemoryManager *>(device->getNEODevice()->getMemoryManager())->localMemorySupported[0] = true;
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
|
||||
ze_result_t returnValue;
|
||||
CommandStreamReceiver *csr = nullptr;
|
||||
device->getCsrForOrdinalAndIndex(&csr, desc.ordinal, desc.index, ZE_COMMAND_QUEUE_PRIORITY_NORMAL, false);
|
||||
reinterpret_cast<UltCommandStreamReceiver<FamilyType> *>(csr)->directSubmissionAvailable = true;
|
||||
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::copy, returnValue));
|
||||
ASSERT_NE(nullptr, commandList);
|
||||
EXPECT_NE(reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get(), nullptr);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
auto immediateCmdList = static_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get());
|
||||
auto secondaryCmdStream = reinterpret_cast<CmdContainerMock *>(&commandList->getCmdContainer())->secondaryCommandStreamForImmediateCmdList.get();
|
||||
|
||||
immediateCmdList->checkAvailableSpace(0u, false, commonImmediateCommandSize, false);
|
||||
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_TRUE(MemoryPoolHelper::isSystemMemoryPool(commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::copy, 0u, returnValue, false));
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
|
||||
ze_result_t result = ZE_RESULT_SUCCESS;
|
||||
result = commandList->appendCommandLists(1u, &commandListHandle, nullptr, 0u, nullptr);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_TRUE(commandList->getCmdContainer().usingSecondaryCmdbufInHostMem());
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListCreate, givenNoSecondaryCommandStreamForImmediateCmdListWhenCheckAvailableSpaceThenNotSwapCommandStreams, MatchAny) {
|
||||
if (!device->getHwInfo().featureTable.flags.ftrLocalMemory) {
|
||||
GTEST_SKIP();
|
||||
@@ -1094,7 +956,7 @@ HWTEST2_F(CommandListCreate, givenNoSecondaryCommandStreamForImmediateCmdListWhe
|
||||
auto immediateCmdList = static_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get());
|
||||
auto cmdStream = commandList->getCmdContainer().getCommandStream();
|
||||
|
||||
immediateCmdList->checkAvailableSpace(0u, false, commonImmediateCommandSize, false);
|
||||
immediateCmdList->checkAvailableSpace(0u, false, commonImmediateCommandSize);
|
||||
|
||||
EXPECT_EQ(commandList->getCmdContainer().getCommandStream(), cmdStream);
|
||||
EXPECT_FALSE(MemoryPoolHelper::isSystemMemoryPool(commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->getMemoryPool()));
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2022-2024 Intel Corporation
|
||||
* Copyright (C) 2022-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -1889,12 +1889,12 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenThereIsNoEnoughSpaceFo
|
||||
|
||||
commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->updateTaskCount(0u, 0u);
|
||||
commandList->getCmdContainer().getCommandStream()->getSpace(useSize);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
EXPECT_EQ(1U, commandList->getCmdContainer().getCmdBufferAllocations().size());
|
||||
|
||||
commandList->getCmdContainer().getCommandStream()->getSpace(useSize);
|
||||
auto latestFlushedTaskCount = whiteBoxCmdList->getCsr(false)->peekLatestFlushedTaskCount();
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
EXPECT_EQ(1U, commandList->getCmdContainer().getCmdBufferAllocations().size());
|
||||
EXPECT_EQ(latestFlushedTaskCount + 1, whiteBoxCmdList->getCsr(false)->peekLatestFlushedTaskCount());
|
||||
}
|
||||
@@ -1916,12 +1916,12 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenThereIsNoEnoughSpaceFo
|
||||
|
||||
commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation()->updateTaskCount(0u, 0u);
|
||||
commandList->getCmdContainer().getCommandStream()->getSpace(useSize);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(numEvents, false, commonImmediateCommandSize, false);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(numEvents, false, commonImmediateCommandSize);
|
||||
EXPECT_EQ(1U, commandList->getCmdContainer().getCmdBufferAllocations().size());
|
||||
|
||||
commandList->getCmdContainer().getCommandStream()->getSpace(useSize);
|
||||
auto latestFlushedTaskCount = whiteBoxCmdList->getCsr(false)->peekLatestFlushedTaskCount();
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(numEvents, false, commonImmediateCommandSize, false);
|
||||
reinterpret_cast<CommandListCoreFamilyImmediate<gfxCoreFamily> *>(commandList.get())->checkAvailableSpace(numEvents, false, commonImmediateCommandSize);
|
||||
EXPECT_EQ(1U, commandList->getCmdContainer().getCmdBufferAllocations().size());
|
||||
EXPECT_EQ(latestFlushedTaskCount + 1, whiteBoxCmdList->getCsr(false)->peekLatestFlushedTaskCount());
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2022-2024 Intel Corporation
|
||||
* Copyright (C) 2022-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -1280,7 +1280,7 @@ HWTEST2_F(MultiTileImmediateCommandListAppendLaunchKernelXeHpCoreTest, givenImpl
|
||||
auto itorBbStart = find<MI_BATCH_BUFFER_START *>(cmdList.begin(), cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorBbStart);
|
||||
auto cmdBbStart = genCmdCast<MI_BATCH_BUFFER_START *>(*itorBbStart);
|
||||
EXPECT_NE(MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH, cmdBbStart->getSecondLevelBatchBuffer());
|
||||
EXPECT_EQ(MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH, cmdBbStart->getSecondLevelBatchBuffer());
|
||||
}
|
||||
} // namespace ult
|
||||
} // namespace L0
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -154,7 +154,7 @@ HWTEST2_F(CommandListAppendSignalEvent, givenCommandListWhenAppendWriteGlobalTim
|
||||
EXPECT_FALSE(cmd->getDcFlushEnable());
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListAndAppendingRegularCommandlistWithWaitOnEventsAndSignalEventThenUseSemaphoreAndPipeControl, IsXeHpcCore) {
|
||||
HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListAndAppendingRegularCommandlistWithWaitOnEventsAndSignalEventThenUseSemaphoreAndPipeControl, IsAtLeastXeHpcCore) {
|
||||
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
|
||||
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
|
||||
using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
|
||||
@@ -222,81 +222,6 @@ HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListAndAppendingRegular
|
||||
ASSERT_TRUE(postSyncFound);
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListAndSecondaryDispatchModeForcedAndAppendingRegularCommandlistWithWaitOnEventsAndSignalEventThenUseSemaphoreAndPipeControl, MatchAny) {
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.DispatchCmdlistCmdBufferPrimary.set(0);
|
||||
|
||||
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
|
||||
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
|
||||
using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
|
||||
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
|
||||
using MI_BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;
|
||||
|
||||
ze_event_pool_desc_t eventPoolDesc = {};
|
||||
eventPoolDesc.count = 1;
|
||||
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
|
||||
|
||||
ze_event_desc_t eventDesc = {};
|
||||
eventDesc.index = 0;
|
||||
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
|
||||
ze_result_t result = ZE_RESULT_SUCCESS;
|
||||
auto eventPoolHostVisible = std::unique_ptr<L0::EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
auto eventHostVisible = std::unique_ptr<L0::Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPoolHostVisible.get(), &eventDesc, device));
|
||||
|
||||
auto waitEventPool = std::unique_ptr<L0::EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
auto waitEvent = std::unique_ptr<L0::Event>(Event::create<typename FamilyType::TimestampPacketType>(waitEventPool.get(), &eventDesc, device));
|
||||
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
|
||||
ze_result_t returnValue;
|
||||
std::unique_ptr<L0::CommandList> immCommandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::renderCompute, returnValue));
|
||||
ASSERT_NE(nullptr, immCommandList);
|
||||
|
||||
ze_event_handle_t hSignalEventHandle = eventHostVisible->toHandle();
|
||||
ze_event_handle_t hWaitEventHandle = waitEvent->toHandle();
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::compute, 0u, returnValue, false));
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
auto usedSpaceBefore = immCommandList->getCmdContainer().getCommandStream()->getUsed();
|
||||
result = immCommandList->appendCommandLists(1u, &commandListHandle, hSignalEventHandle, 1u, &hWaitEventHandle);
|
||||
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
|
||||
|
||||
auto usedSpaceAfter = immCommandList->getCmdContainer().getCommandStream()->getUsed();
|
||||
ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
|
||||
|
||||
GenCmdList cmdList;
|
||||
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(cmdList,
|
||||
immCommandList->getCmdContainer().getCommandStream()->getCpuBase(),
|
||||
usedSpaceAfter));
|
||||
|
||||
auto itorSemaphore = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorSemaphore);
|
||||
|
||||
auto itorBBStart = find<MI_BATCH_BUFFER_START *>(itorSemaphore, cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorBBStart);
|
||||
|
||||
auto itorPC = findAll<PIPE_CONTROL *>(itorBBStart, cmdList.end());
|
||||
ASSERT_NE(0u, itorPC.size());
|
||||
bool postSyncFound = false;
|
||||
for (auto it : itorPC) {
|
||||
auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
|
||||
if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
|
||||
EXPECT_NE(cmd->getImmediateData(), Event::STATE_CLEARED);
|
||||
EXPECT_TRUE(cmd->getCommandStreamerStallEnable());
|
||||
EXPECT_EQ(MemorySynchronizationCommands<FamilyType>::getDcFlushEnable(true, device->getNEODevice()->getRootDeviceEnvironment()), cmd->getDcFlushEnable());
|
||||
postSyncFound = true;
|
||||
}
|
||||
}
|
||||
ASSERT_TRUE(postSyncFound);
|
||||
|
||||
auto itorBBEnd = find<MI_BATCH_BUFFER_END *>(itorBBStart, cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorBBEnd);
|
||||
}
|
||||
|
||||
HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListWithComputeQueueAndAppendingRegularCommandlistThenCsrMakeNonTesidentSkippedFromCmdQueue, IsAtLeastXeHpcCore) {
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
|
||||
@@ -329,6 +254,7 @@ HWTEST2_F(CommandListAppendSignalEvent, givenImmediateCmdListWithComputeQueueAnd
|
||||
|
||||
HWTEST2_F(CommandListAppendSignalEvent, givenCopyOnlyImmediateCmdListAndAppendingRegularCommandlistWithWaitOnEventsAndSignalEventThenUseSemaphoreAndFlushDw, IsAtLeastXeHpcCore) {
|
||||
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
|
||||
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
|
||||
using MI_FLUSH_DW = typename FamilyType::MI_FLUSH_DW;
|
||||
|
||||
ze_event_pool_desc_t eventPoolDesc = {};
|
||||
@@ -357,10 +283,6 @@ HWTEST2_F(CommandListAppendSignalEvent, givenCopyOnlyImmediateCmdListAndAppendin
|
||||
ze_event_handle_t hSignalEventHandle = eventHostVisible->toHandle();
|
||||
ze_event_handle_t hWaitEventHandle = waitEvent->toHandle();
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::copy, 0u, returnValue, false));
|
||||
void *srcPtr = reinterpret_cast<void *>(0x1234);
|
||||
void *dstPtr = reinterpret_cast<void *>(0x2345);
|
||||
CmdListMemoryCopyParams copyParams = {};
|
||||
commandListRegular->appendMemoryCopy(dstPtr, srcPtr, 8, nullptr, 0, nullptr, copyParams);
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
auto usedSpaceBefore = immCommandList->getCmdContainer().getCommandStream()->getUsed();
|
||||
@@ -379,6 +301,9 @@ HWTEST2_F(CommandListAppendSignalEvent, givenCopyOnlyImmediateCmdListAndAppendin
|
||||
auto itorSemaphore = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorSemaphore);
|
||||
|
||||
auto itorBBStart = find<MI_BATCH_BUFFER_START *>(itorSemaphore, cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorBBStart);
|
||||
|
||||
uint32_t expectedMiFlushCount = 1;
|
||||
NEO::EncodeDummyBlitWaArgs waArgs{false, &(device->getNEODevice()->getRootDeviceEnvironmentRef())};
|
||||
if (MockEncodeMiFlushDW<FamilyType>::getWaSize(waArgs) > 0) {
|
||||
@@ -739,7 +664,7 @@ HWTEST2_F(CommandListAppendUsedPacketSignalEvent,
|
||||
event->signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
|
||||
|
||||
commandList->partitionCount = packets;
|
||||
commandList->checkAvailableSpace(0, false, commonImmediateCommandSize, false);
|
||||
commandList->checkAvailableSpace(0, false, commonImmediateCommandSize);
|
||||
commandList->appendSignalEventPostWalker(event.get(), nullptr, nullptr, false, false, false);
|
||||
EXPECT_EQ(packets, event->getPacketsInUse());
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -202,6 +202,7 @@ HWTEST2_F(CommandListAppendWaitOnEvent, givenImmediateCmdListWithDirectSubmissio
|
||||
|
||||
HWTEST2_F(CommandListAppendWaitOnEvent, givenImmediateCmdListAndAppendingRegularCommandlistWithWaitOnEventsThenUseSemaphore, IsAtLeastXeHpcCore) {
|
||||
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
|
||||
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
|
||||
|
||||
ze_command_queue_desc_t desc = {};
|
||||
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
|
||||
@@ -211,10 +212,6 @@ HWTEST2_F(CommandListAppendWaitOnEvent, givenImmediateCmdListAndAppendingRegular
|
||||
|
||||
ze_event_handle_t hEventHandle = event->toHandle();
|
||||
std::unique_ptr<L0::CommandList> commandListRegular(CommandList::create(productFamily, device, NEO::EngineGroupType::compute, 0u, returnValue, false));
|
||||
void *srcPtr = reinterpret_cast<void *>(0x1234);
|
||||
void *dstPtr = reinterpret_cast<void *>(0x2345);
|
||||
CmdListMemoryCopyParams copyParams = {};
|
||||
commandListRegular->appendMemoryCopy(dstPtr, srcPtr, 8, nullptr, 0, nullptr, copyParams);
|
||||
commandListRegular->close();
|
||||
auto commandListHandle = commandListRegular->toHandle();
|
||||
auto result = immCommandList->appendCommandLists(1u, &commandListHandle, nullptr, 1u, &hEventHandle);
|
||||
@@ -230,6 +227,9 @@ HWTEST2_F(CommandListAppendWaitOnEvent, givenImmediateCmdListAndAppendingRegular
|
||||
|
||||
auto itor = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itor);
|
||||
|
||||
auto itorBBStart = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
|
||||
ASSERT_NE(cmdList.end(), itorBBStart);
|
||||
}
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2024 Intel Corporation
|
||||
* Copyright (C) 2020-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -540,6 +540,48 @@ HWTEST_F(CommandQueueCreate, givenUpdateTaskCountFromWaitAndRegularCmdListWhenDi
|
||||
commandQueue->destroy();
|
||||
}
|
||||
|
||||
HWTEST_F(CommandQueueCreate, givenUpdateTaskCountFromWaitAndImmediateCmdListWhenDispatchTaskCountWriteThenNoPipeControlFlushed) {
|
||||
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
|
||||
using POST_SYNC_OPERATION = typename FamilyType::PIPE_CONTROL::POST_SYNC_OPERATION;
|
||||
|
||||
DebugManagerStateRestore restorer;
|
||||
debugManager.flags.UpdateTaskCountFromWait.set(3);
|
||||
|
||||
const ze_command_queue_desc_t desc = {};
|
||||
ze_result_t returnValue;
|
||||
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
|
||||
device,
|
||||
neoDevice->getDefaultEngine().commandStreamReceiver,
|
||||
&desc,
|
||||
false,
|
||||
false,
|
||||
true,
|
||||
returnValue));
|
||||
|
||||
auto commandList = CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::renderCompute, returnValue);
|
||||
ASSERT_NE(nullptr, commandList);
|
||||
|
||||
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
|
||||
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
|
||||
|
||||
GenCmdList cmdList;
|
||||
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
|
||||
cmdList, ptrOffset(commandQueue->commandStream.getCpuBase(), 0), commandQueue->commandStream.getUsed()));
|
||||
|
||||
auto pipeControls = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
|
||||
bool pipeControlsPostSync = false;
|
||||
for (size_t i = 0; i < pipeControls.size(); i++) {
|
||||
auto pipeControl = reinterpret_cast<PIPE_CONTROL *>(*pipeControls[i]);
|
||||
if (pipeControl->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
|
||||
pipeControlsPostSync = true;
|
||||
}
|
||||
}
|
||||
EXPECT_FALSE(pipeControlsPostSync);
|
||||
|
||||
commandList->destroy();
|
||||
commandQueue->destroy();
|
||||
}
|
||||
|
||||
HWTEST_F(CommandQueueCreate, givenContainerWithAllocationsWhenResidencyContainerIsEmptyThenMakeResidentWasNotCalled) {
|
||||
auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
|
||||
csr->setupContext(*neoDevice->getDefaultEngine().osContext);
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2019-2024 Intel Corporation
|
||||
* Copyright (C) 2019-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -89,8 +89,6 @@ class CommandContainer : public NonCopyableOrMovableClass {
|
||||
|
||||
LinearStream *getCommandStream() { return commandStream.get(); }
|
||||
|
||||
bool usingSecondaryCmdbufInHostMem() { return useSecondaryCommandStream; }
|
||||
|
||||
IndirectHeap *getIndirectHeap(HeapType heapType);
|
||||
|
||||
HeapHelper *getHeapHelper() { return heapHelper.get(); }
|
||||
@@ -121,7 +119,7 @@ class CommandContainer : public NonCopyableOrMovableClass {
|
||||
GraphicsAllocation *obtainNextCommandBufferAllocation();
|
||||
GraphicsAllocation *obtainNextCommandBufferAllocation(bool forceHostMemory);
|
||||
|
||||
MOCKABLE_VIRTUAL bool swapStreams();
|
||||
bool swapStreams();
|
||||
|
||||
void reset();
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2019-2024 Intel Corporation
|
||||
* Copyright (C) 2019-2025 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@@ -98,25 +98,6 @@ TEST_F(CommandContainerHeapStateTests, givenDirtyHeapsWhenSettingStateForSingleH
|
||||
}
|
||||
}
|
||||
|
||||
using CommandContainerSwapStreamTest = Test<CommandContainerFixture>;
|
||||
TEST_F(CommandContainerSwapStreamTest, givenCommandContainerInitializedWithSecondaryCmdBufferAndForceSwapStreamsReturnsFalseThenCallIsUnsuccessful) {
|
||||
class MyMockCommandContainer : public CommandContainer {
|
||||
public:
|
||||
bool swapStreams() override {
|
||||
swapStreamsCalled++;
|
||||
return forceSwapAction;
|
||||
}
|
||||
|
||||
uint32_t swapStreamsCalled = 0u;
|
||||
bool forceSwapAction = false;
|
||||
};
|
||||
|
||||
MyMockCommandContainer cmdContainer;
|
||||
cmdContainer.initialize(pDevice, nullptr, HeapSize::defaultHeapSize, true, true);
|
||||
|
||||
EXPECT_FALSE(cmdContainer.swapStreams());
|
||||
}
|
||||
|
||||
TEST_F(CommandContainerTest, givenCmdContainerWhenCreatingCommandBufferThenCorrectAllocationTypeIsSet) {
|
||||
CommandContainer cmdContainer;
|
||||
cmdContainer.initialize(pDevice, nullptr, HeapSize::defaultHeapSize, true, false);
|
||||
@@ -145,22 +126,6 @@ TEST_F(CommandContainerTest, givenCreateSecondaryCmdBufferInHostMemWhenInitializ
|
||||
EXPECT_EQ(cmdContainer.secondaryCommandStreamForImmediateCmdList.get(), cmdStream);
|
||||
}
|
||||
|
||||
TEST_F(CommandContainerTest, givenCreateSecondaryCmdBufferInHostMemWhenInitializeThenCreateAdditionalLinearStreamAndReturnAccordingly) {
|
||||
MyMockCommandContainer cmdContainer;
|
||||
cmdContainer.initialize(pDevice, nullptr, HeapSize::defaultHeapSize, true, true);
|
||||
|
||||
EXPECT_NE(cmdContainer.secondaryCommandStreamForImmediateCmdList.get(), nullptr);
|
||||
|
||||
auto secondaryCmdStream = cmdContainer.secondaryCommandStreamForImmediateCmdList.get();
|
||||
auto cmdStream = cmdContainer.getCommandStream();
|
||||
|
||||
EXPECT_TRUE(cmdContainer.swapStreams());
|
||||
EXPECT_TRUE(cmdContainer.usingSecondaryCmdbufInHostMem());
|
||||
|
||||
EXPECT_EQ(cmdContainer.getCommandStream(), secondaryCmdStream);
|
||||
EXPECT_EQ(cmdContainer.secondaryCommandStreamForImmediateCmdList.get(), cmdStream);
|
||||
}
|
||||
|
||||
TEST_F(CommandContainerTest, whenInitializeThenNotCreateAdditionalLinearStream) {
|
||||
MyMockCommandContainer cmdContainer;
|
||||
cmdContainer.initialize(pDevice, nullptr, HeapSize::defaultHeapSize, true, false);
|
||||
|
||||
Reference in New Issue
Block a user