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

refactor: change queue and immediate command list to accept indirect lock 

Related-To: NEO-10356

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz 2025-04-10 21:08:13 +00:00 committed by Compute-Runtime-Automation
parent 4a4f1f934a
commit cf7209ddfe
45 changed files with 382 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/api/core/ze_cmdqueue_api_entrypoints.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -30,7 +30,7 @@ ze_result_t zeCommandQueueExecuteCommandLists(
uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence) {
return L0::CommandQueue::fromHandle(hCommandQueue)->executeCommandLists(numCommandLists, phCommandLists, hFence, true, nullptr);
return L0::CommandQueue::fromHandle(hCommandQueue)->executeCommandLists(numCommandLists, phCommandLists, hFence, true, nullptr, nullptr);
}
ze_result_t zeCommandQueueSynchronize(

2
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@ -348,7 +348,7 @@ inline ze_result_t CommandListCoreFamily<gfxCoreFamily>::executeCommandListImmed
ze_command_list_handle_t immediateHandle = this->toHandle();
this->commandContainer.removeDuplicatesFromResidencyContainer();
const auto commandListExecutionResult = cmdQImmediate->executeCommandLists(1, &immediateHandle, nullptr, performMigration, nullptr);
const auto commandListExecutionResult = cmdQImmediate->executeCommandLists(1, &immediateHandle, nullptr, performMigration, nullptr, nullptr);
if (commandListExecutionResult == ZE_RESULT_ERROR_DEVICE_LOST) {
return commandListExecutionResult;
}

9
level_zero/core/source/cmdlist/cmdlist_hw_immediate.h
View File

@ -191,11 +191,13 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
MOCKABLE_VIRTUAL ze_result_t executeCommandListImmediateWithFlushTask(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool copyOffloadSubmission, bool requireTaskCountUpdate,
MutexLock *outerLock);
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect);
ze_result_t executeCommandListImmediateWithFlushTaskImpl(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool requireTaskCountUpdate,
CommandQueue *cmdQ,
MutexLock *outerLock);
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect);
ze_result_t appendCommandLists(uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
@ -213,7 +215,8 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
MOCKABLE_VIRTUAL ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock);
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect);
bool preferCopyThroughLockedPtr(CpuMemCopyInfo &cpuMemCopyInfo, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents);
bool isSuitableUSMHostAlloc(NEO::SvmAllocationData *alloc);

62
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@ -424,14 +424,16 @@ NEO::CompletionStamp CommandListCoreFamilyImmediate<gfxCoreFamily>::flushRegular
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::executeCommandListImmediateWithFlushTask(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool copyOffloadSubmission, bool requireTaskCountUpdate,
MutexLock *outerLock) {
return executeCommandListImmediateWithFlushTaskImpl(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, requireTaskCountUpdate, getCmdQImmediate(copyOffloadSubmission), outerLock);
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) {
return executeCommandListImmediateWithFlushTaskImpl(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, requireTaskCountUpdate, getCmdQImmediate(copyOffloadSubmission), outerLock, outerLockForIndirect);
}
template <GFXCORE_FAMILY gfxCoreFamily>
inline ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::executeCommandListImmediateWithFlushTaskImpl(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool requireTaskCountUpdate, CommandQueue *cmdQ,
MutexLock *outerLock) {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) {
auto cmdQImp = static_cast<CommandQueueImp *>(cmdQ);
this->commandContainer.removeDuplicatesFromResidencyContainer();
@ -583,7 +585,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendLaunchKernel(
CommandListCoreFamily<gfxCoreFamily>::handleInOrderDependencyCounter(event, true, false);
}
return flushImmediate(ret, true, stallingCmdsForRelaxedOrdering, relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, stallingCmdsForRelaxedOrdering, relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -600,7 +602,7 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleInOrderNonWalkerSignal
if (event && event->isCounterBased()) {
event->hostEventSetValue(Event::STATE_INITIAL);
}
result = flushImmediate(result, true, hasStallingCmds, relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, nullptr, false, nullptr);
result = flushImmediate(result, true, hasStallingCmds, relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, nullptr, false, nullptr, nullptr);
NEO::RelaxedOrderingHelper::encodeRegistersBeforeDependencyCheckers<GfxFamily>(*this->commandContainer.getCommandStream(), isCopyOnly(false));
relaxedOrderingDispatch = true;
hasStallingCmds = hasStallingCmdsForRelaxedOrdering(1, relaxedOrderingDispatch);
@ -621,7 +623,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendLaunchKernelInd
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelIndirect(kernelHandle, pDispatchArgumentsBuffer,
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -648,7 +650,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendBarrier(ze_even
ret = CommandListCoreFamily<gfxCoreFamily>::appendBarrier(hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
this->dependenciesPresent = true;
return flushImmediate(ret, true, isStallingOperation, relaxedOrderingDispatch, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, isStallingOperation, relaxedOrderingDispatch, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -698,7 +700,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryCopy(
numWaitEvents, phWaitEvents, memoryCopyParams);
}
return flushImmediate(ret, true, hasStallindCmds, memoryCopyParams.relaxedOrderingDispatch, NEO::AppendOperations::kernel, memoryCopyParams.copyOffloadAllowed, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallindCmds, memoryCopyParams.relaxedOrderingDispatch, NEO::AppendOperations::kernel, memoryCopyParams.copyOffloadAllowed, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -756,7 +758,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryCopyRegio
hSignalEvent, numWaitEvents, phWaitEvents, memoryCopyParams);
}
return flushImmediate(ret, true, hasStallindCmds, memoryCopyParams.relaxedOrderingDispatch, NEO::AppendOperations::kernel, memoryCopyParams.copyOffloadAllowed, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallindCmds, memoryCopyParams.relaxedOrderingDispatch, NEO::AppendOperations::kernel, memoryCopyParams.copyOffloadAllowed, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -771,7 +773,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryFill(void
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendMemoryFill(ptr, pattern, patternSize, size, hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -783,7 +785,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalEvent(ze_
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
ret = CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(hSignalEvent, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmds, relaxedOrderingDispatch, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmds, relaxedOrderingDispatch, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -792,7 +794,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendEventReset(ze_e
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
ret = CommandListCoreFamily<gfxCoreFamily>::appendEventReset(hSignalEvent);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -822,7 +824,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendPageFaultCopy(N
} else {
ret = CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(dstAllocation, srcAllocation, size, flushHost);
}
return flushImmediate(ret, false, false, relaxedOrdering, NEO::AppendOperations::kernel, false, nullptr, false, nullptr);
return flushImmediate(ret, false, false, relaxedOrdering, NEO::AppendOperations::kernel, false, nullptr, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -847,7 +849,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitOnEvents(ui
return ret;
}
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -859,7 +861,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWriteGlobalTime
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWriteGlobalTimestamp(dstptr, hSignalEvent, numWaitEvents, phWaitEvents);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -904,7 +906,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyRegion
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyRegion(hDstImage, hSrcImage, pDstRegion, pSrcRegion, hSignalEvent,
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -922,7 +924,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyFromMe
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemory(hDstImage, srcPtr, pDstRegion, hSignalEvent,
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -940,7 +942,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyToMemo
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemory(dstPtr, hSrcImage, pSrcRegion, hSignalEvent,
numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -960,7 +962,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyFromMe
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(hDstImage, srcPtr, pDstRegion, srcRowPitch, srcSlicePitch,
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -980,7 +982,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendImageCopyToMemo
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(dstPtr, hSrcImage, pSrcRegion, destRowPitch, destSlicePitch,
hSignalEvent, numWaitEvents, phWaitEvents, relaxedOrderingDispatch);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch), relaxedOrderingDispatch, NEO::AppendOperations::kernel, false, hSignalEvent, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -993,21 +995,21 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryRangesBar
checkAvailableSpace(numWaitEvents, false, commonImmediateCommandSize, false);
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendMemoryRangesBarrier(numRanges, pRangeSizes, pRanges, hSignalEvent, numWaitEvents, phWaitEvents);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr);
return flushImmediate(ret, true, true, false, NEO::AppendOperations::nonKernel, false, hSignalEvent, false, nullptr, nullptr);
}
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);
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWaitOnMemory(desc, ptr, data, signalEventHandle, useQwordData);
return flushImmediate(ret, true, false, false, NEO::AppendOperations::nonKernel, false, signalEventHandle, false, nullptr);
return flushImmediate(ret, true, false, false, NEO::AppendOperations::nonKernel, false, signalEventHandle, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWriteToMemory(void *desc, void *ptr, uint64_t data) {
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendWriteToMemory(desc, ptr, data);
return flushImmediate(ret, true, false, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr);
return flushImmediate(ret, true, false, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr, nullptr);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@ -1223,7 +1225,8 @@ NEO::LinearStream *CommandListCoreFamilyImmediate<gfxCoreFamily>::getOptionalEpi
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) {
auto signalEvent = Event::fromHandle(hSignalEvent);
auto queue = getCmdQImmediate(copyOffloadSubmission);
@ -1238,7 +1241,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::flushImmediate(ze_res
if (signalEvent && (NEO::debugManager.flags.TrackNumCsrClientsOnSyncPoints.get() != 0)) {
signalEvent->setLatestUsedCmdQueue(queue);
}
inputRet = executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate, outerLock);
inputRet = executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate,
outerLock, outerLockForIndirect);
} else {
inputRet = executeCommandListImmediate(performMigration);
}
@ -1319,7 +1323,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::flushInOrderCounterSi
this->appendSignalInOrderDependencyCounter(nullptr, false, true);
this->inOrderExecInfo->addCounterValue(this->getInOrderIncrementValue());
this->handleInOrderCounterOverflow(false);
ret = flushImmediate(ret, false, true, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr);
ret = flushImmediate(ret, false, true, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr, nullptr);
}
return ret;
}
@ -1779,7 +1783,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendCommandLists(ui
ret = this->cmdQImmediate->executeCommandLists(numCommandLists, phCommandLists,
nullptr,
true,
this->commandContainer.getCommandStream());
this->commandContainer.getCommandStream(),
nullptr);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
@ -1811,7 +1816,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendCommandLists(ui
copyOffloadOperation,
hSignalEvent,
requireTaskCountUpdate,
&mainAppendLock);
&mainAppendLock,
nullptr);
}
} // namespace L0

3
level_zero/core/source/cmdqueue/cmdqueue.h
View File

@ -55,7 +55,8 @@ struct CommandQueue : _ze_command_queue_handle_t {
virtual ze_result_t executeCommandLists(uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence, bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream) = 0;
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect) = 0;
virtual ze_result_t synchronize(uint64_t timeout) = 0;
virtual ze_result_t getOrdinal(uint32_t *pOrdinal) = 0;
virtual ze_result_t getIndex(uint32_t *pIndex) = 0;

4
level_zero/core/source/cmdqueue/cmdqueue_hw.h
View File

@ -27,7 +27,8 @@ struct CommandQueueHw : public CommandQueueImp {
ze_result_t executeCommandLists(uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence, bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream) override;
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect) override;
void programStateBaseAddress(uint64_t gsba, bool useLocalMemoryForIndirectHeap, NEO::LinearStream &commandStream, bool cachedMOCSAllowed, NEO::StreamProperties *streamProperties);
size_t estimateStateBaseAddressCmdSize();
@ -83,6 +84,7 @@ struct CommandQueueHw : public CommandQueueImp {
void *currentPatchForChainedBbStart = nullptr;
NEO::ScratchSpaceController *scratchSpaceController = nullptr;
NEO::GraphicsAllocation *globalStatelessAllocation = nullptr;
std::unique_lock<std::mutex> *outerLockForIndirect = nullptr;
NEO::PreemptionMode preemptionMode{};
NEO::PreemptionMode statePreemption{};

3
level_zero/core/source/cmdqueue/cmdqueue_hw.inl
View File

@ -63,7 +63,8 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::executeCommandLists(
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence,
bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream) {
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect) {
auto ret = ZE_RESULT_SUCCESS;

2
level_zero/core/source/device/bcs_split.h
View File

@ -121,7 +121,7 @@ struct BcsSplit {
result = appendCall(localDstPtr, localSrcPtr, localSize, eventHandle);
if (cmdList->flushTaskSubmissionEnabled()) {
cmdList->executeCommandListImmediateWithFlushTaskImpl(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, NEO::AppendOperations::nonKernel, false, cmdQsForSplit[i], nullptr);
cmdList->executeCommandListImmediateWithFlushTaskImpl(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, NEO::AppendOperations::nonKernel, false, cmdQsForSplit[i], nullptr, nullptr);
} else {
cmdList->executeCommandListImmediateImpl(performMigration, cmdQsForSplit[i]);
}

2
level_zero/core/source/device/device_imp.cpp
View File

@ -155,7 +155,7 @@ ze_result_t DeviceImp::submitCopyForP2P(ze_device_handle_t hPeerDevice, ze_bool_
L0::CommandList::fromHandle(commandList)->close();
if (ret == ZE_RESULT_SUCCESS) {
ret = L0::CommandQueue::fromHandle(commandQueue)->executeCommandLists(1, &commandList, nullptr, true, nullptr);
ret = L0::CommandQueue::fromHandle(commandQueue)->executeCommandLists(1, &commandList, nullptr, true, nullptr, nullptr);
if (ret == ZE_RESULT_SUCCESS) {
this->crossAccessEnabledDevices[peerRootDeviceIndex] = true;
pPeerDevice->crossAccessEnabledDevices[this->getNEODevice()->getRootDeviceIndex()] = true;

4
level_zero/core/test/aub_tests/aub_hello_world_test.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2024 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -37,7 +37,7 @@ TEST_F(AUBHelloWorldL0, whenAppendMemoryCopyIsCalledThenMemoryIsProperlyCopied)
commandList->close();
auto pHCmdList = std::make_unique<ze_command_list_handle_t>(commandList->toHandle());
pCmdq->executeCommandLists(1, pHCmdList.get(), nullptr, false, nullptr);
pCmdq->executeCommandLists(1, pHCmdList.get(), nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
EXPECT_TRUE(csr->expectMemory(dstMemory, srcMemory, size, AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual));

4
level_zero/core/test/aub_tests/bindless/bindless_kernel_aub_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2024 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -81,7 +81,7 @@ HWTEST_F(L0BindlessAub, DISABLED_GivenBindlessKernelWhenExecutedThenOutputIsCorr
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernel(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
expectMemory<FamilyType>(reinterpret_cast<void *>(driverHandle->svmAllocsManager->getSVMAlloc(bufferDst)->gpuAllocations.getDefaultGraphicsAllocation()->getGpuAddress()),

10
level_zero/core/test/aub_tests/cmdlist/append_kernel_indirect_aub_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2024 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -58,7 +58,7 @@ TEST_F(AUBAppendKernelIndirectL0, whenAppendKernelIndirectThenGlobalWorkSizeIsPr
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernelIndirect(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
EXPECT_TRUE(csr->expectMemory(outBuffer, expectedGlobalWorkSize, size, AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual));
@ -103,7 +103,7 @@ TEST_F(AUBAppendKernelIndirectL0, whenAppendKernelIndirectThenGroupCountIsProper
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernelIndirect(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
EXPECT_TRUE(csr->expectMemory(outBuffer, groupCount, size, AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual));
@ -163,7 +163,7 @@ TEST_F(AUBAppendKernelIndirectL0, whenAppendMultipleKernelsIndirectThenGroupCoun
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchMultipleKernelsIndirect(cmdListHandle, 2, kernels, kernelCount, dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
EXPECT_TRUE(csr->expectMemory(outBuffer, groupCount, size, AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual));
@ -236,7 +236,7 @@ TEST_F(AUBAppendKernelIndirectL0, whenAppendKernelIndirectThenWorkDimIsProperlyP
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernelIndirect(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint32_t>::max());
EXPECT_TRUE(csr->expectMemory(outBuffer, &expectedWorkDim, size, AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareEqual));

4
level_zero/core/test/aub_tests/cmdlist/multitile_aub_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -96,7 +96,7 @@ HWTEST_F(SynchronizedDispatchMultiTileL0AubTests, givenFullSyncDispatchWhenExecu
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernel(cmdListHandle, kernel.get(), &groupCount, nullptr, 0, nullptr));
commandList->close();
cmdQ->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
cmdQ->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
cmdQ->synchronize(std::numeric_limits<uint32_t>::max());
auto csr = getSimulatedCsr<FamilyType>(0, 0);

4
level_zero/core/test/aub_tests/debugger/debugger_aub_tests.cpp
View File

@ -112,7 +112,7 @@ HWTEST2_F(DebuggerSingleAddressSpaceAub, GivenSingleAddressSpaceWhenCmdListIsExe
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernel(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint64_t>::max());
expectMemory<FamilyType>(reinterpret_cast<void *>(driverHandle->svmAllocsManager->getSVMAlloc(bufferDst)->gpuAllocations.getDefaultGraphicsAllocation()->getGpuAddress()),
@ -253,7 +253,7 @@ HWTEST2_F(DebuggerGlobalAllocatorAub, GivenKernelWithScratchWhenCmdListExecutedT
EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListAppendLaunchKernel(cmdListHandle, kernel, &dispatchTraits, nullptr, 0, nullptr));
commandList->close();
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
pCmdq->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
pCmdq->synchronize(std::numeric_limits<uint64_t>::max());
expectMemory<FamilyType>(reinterpret_cast<void *>(driverHandle->svmAllocsManager->getSVMAlloc(bufferDst)->gpuAllocations.getDefaultGraphicsAllocation()->getGpuAddress()),

52
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl
View File

@ -197,7 +197,7 @@ void CmdListPipelineSelectStateFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -283,7 +283,7 @@ void CmdListPipelineSelectStateFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -408,7 +408,7 @@ void CmdListPipelineSelectStateFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -465,7 +465,7 @@ void CmdListPipelineSelectStateFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -537,7 +537,7 @@ void CmdListPipelineSelectStateFixture::testBodyShareStateRegularImmediate() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -713,7 +713,7 @@ void CmdListPipelineSelectStateFixture::testBodyShareStateImmediateRegular() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -760,7 +760,7 @@ void CmdListPipelineSelectStateFixture::testBodySystolicAndScratchOnSecondComman
// execute first clear command list to settle global init
ze_command_list_handle_t commandLists[2] = {commandList->toHandle(), nullptr};
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto queueSize = cmdQueueStream.getUsed();
@ -768,7 +768,7 @@ void CmdListPipelineSelectStateFixture::testBodySystolicAndScratchOnSecondComman
// scratch makes globally front end dirty and so global init too,
// but dispatch systolic programming only before second command list
commandLists[1] = commandList2->toHandle();
result = commandQueue->executeCommandLists(2, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(2, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
GenCmdList cmdList;
@ -865,7 +865,7 @@ void CmdListThreadArbitrationFixture::testBody() {
EXPECT_TRUE(queueCsr->getStateComputeModeDirty());
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -934,7 +934,7 @@ void CmdListThreadArbitrationFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1024,7 +1024,7 @@ void CmdListThreadArbitrationFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1067,7 +1067,7 @@ void CmdListThreadArbitrationFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1132,7 +1132,7 @@ void CmdListLargeGrfFixture::testBody() {
EXPECT_TRUE(queueCsr->getStateComputeModeDirty());
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1201,7 +1201,7 @@ void CmdListLargeGrfFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1291,7 +1291,7 @@ void CmdListLargeGrfFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1334,7 +1334,7 @@ void CmdListLargeGrfFixture::testBody() {
commandList->close();
sizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
sizeAfter = cmdQueueStream.getUsed();
@ -1496,7 +1496,7 @@ void CommandListScratchPatchFixtureInit::testScratchInline(bool useImmediate) {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@ -1555,7 +1555,7 @@ void CommandListScratchPatchFixtureInit::testScratchGrowingPatching() {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto scratchAddress = scratchController->getScratchPatchAddress();
@ -1597,7 +1597,7 @@ void CommandListScratchPatchFixtureInit::testScratchGrowingPatching() {
result = commandList->close();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
scratchAddress = scratchController->getScratchPatchAddress();
@ -1614,7 +1614,7 @@ void CommandListScratchPatchFixtureInit::testScratchGrowingPatching() {
memset(scratchInlinePtr, 0, scratchInlinePointerSize);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue));
@ -1658,7 +1658,7 @@ void CommandListScratchPatchFixtureInit::testScratchSameNotPatching() {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto scratchAddress = scratchController->getScratchPatchAddress();
@ -1672,7 +1672,7 @@ void CommandListScratchPatchFixtureInit::testScratchSameNotPatching() {
memset(scratchInlinePtr, 0, scratchInlinePointerSize);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue));
@ -1767,7 +1767,7 @@ void CommandListScratchPatchFixtureInit::testScratchChangedControllerPatching()
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto scratchAddress = scratchControllerInitial->getScratchPatchAddress();
@ -1790,7 +1790,7 @@ void CommandListScratchPatchFixtureInit::testScratchChangedControllerPatching()
ultCsr->createScratchSpaceController();
auto scratchControllerSecond = csr->getScratchSpaceController();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
scratchAddress = scratchControllerSecond->getScratchPatchAddress();
@ -1807,7 +1807,7 @@ void CommandListScratchPatchFixtureInit::testScratchChangedControllerPatching()
memset(scratchInlinePtr, 0, scratchInlinePointerSize);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue));
@ -1892,7 +1892,7 @@ void CommandListScratchPatchFixtureInit::testExternalScratchPatching() {
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto scratchAddress = scratchController->getScratchPatchAddress();

6
level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
View File

@ -732,10 +732,12 @@ class MockCommandListImmediateHw : public WhiteBox<::L0::CommandListCoreFamilyIm
ze_result_t executeCommandListImmediateWithFlushTask(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool copyOffloadSubmission, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
++executeCommandListImmediateWithFlushTaskCalledCount;
if (callBaseExecute) {
return BaseClass::executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate, outerLock);
return BaseClass::executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate,
outerLock, outerLockForIndirect);
}
return executeCommandListImmediateWithFlushTaskReturnValue;
}

2
level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h
View File

@ -67,7 +67,7 @@ struct Mock<CommandQueue> : public CommandQueue {
ADDMETHOD_NOBASE(createFence, ze_result_t, ZE_RESULT_SUCCESS, (const ze_fence_desc_t *desc, ze_fence_handle_t *phFence));
ADDMETHOD_NOBASE(destroy, ze_result_t, ZE_RESULT_SUCCESS, ());
ADDMETHOD_NOBASE(executeCommandLists, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists, ze_fence_handle_t hFence, bool performMigration, NEO::LinearStream *parentImmediateCommandlistLinearStream));
ADDMETHOD_NOBASE(executeCommandLists, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists, ze_fence_handle_t hFence, bool performMigration, NEO::LinearStream *parentImmediateCommandlistLinearStream, std::unique_lock<std::mutex> *outerLockForIndirect));
ADDMETHOD_NOBASE(synchronize, ze_result_t, ZE_RESULT_SUCCESS, (uint64_t timeout));
ADDMETHOD_NOBASE(getPreemptionCmdProgramming, bool, false, ());
};

4
level_zero/core/test/unit_tests/os_interface/linux/cmdqueue_linux_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -73,7 +73,7 @@ HWTEST2_F(CommandQueueLinuxTests, givenExecBufferErrorOnXeHpcWhenExecutingComman
ze_command_list_handle_t cmdListHandles[1] = {commandList->toHandle()};
returnValue = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, returnValue);
commandQueue->destroy();
neoDevice->getMemoryManager()->freeGraphicsMemory(kernel.immutableData.isaGraphicsAllocation.release());

2
level_zero/core/test/unit_tests/sources/assert/test_assert.cpp
View File

@ -402,7 +402,7 @@ TEST_F(CommandQueueWithAssert, GivenCmdListWithAssertWhenExecutingThenCommandQue
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
EXPECT_TRUE(commandQueue->cmdListWithAssertExecuted);

28
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
View File

@ -1846,7 +1846,7 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenRegularCmdListWhenFlushingThenPassS
EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->close());
auto cmdListHandle = commandList->toHandle();
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr));
EXPECT_TRUE(ultCsr->latestFlushedBatchBuffer.hasStallingCmds);
}
@ -1865,14 +1865,14 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenRegularCmdListWhenNoPreambleExpecte
auto regularCmdBufferAllocation = commandList->getCmdContainer().getCommandStream()->getGraphicsAllocation();
// 1st dispatch can carry state preamble
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &queueStream = commandQueue->commandStream;
auto offsetBefore = queueStream.getUsed();
commandQueue->triggerBbStartJump();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto offsetAfter = queueStream.getUsed();
@ -1941,7 +1941,7 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenCmdListWhenCallingSynchronizeThenUn
auto numClients = csr->getNumClients();
auto cmdListHandle = commandList->toHandle();
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr));
EXPECT_EQ(numClients + 1, csr->getNumClients());
@ -2025,7 +2025,7 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenPrimaryBatchBufferWhenCopyCommandLi
size_t blitterContextInitSize = ultCsr->getCmdsSizeForHardwareContext();
auto cmdListHandle = commandListCopy->toHandle();
returnValue = commandQueueCopy->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
returnValue = commandQueueCopy->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto bbStartCmd = genCmdCast<MI_BATCH_BUFFER_START *>(bbStartSpace);
@ -2040,7 +2040,7 @@ HWTEST_F(PrimaryBatchBufferCmdListTest, givenPrimaryBatchBufferWhenCopyCommandLi
}
size_t queueSizeUsed = cmdQueueStream.getUsed();
returnValue = commandQueueCopy->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
returnValue = commandQueueCopy->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
bbStartCmd = genCmdCast<MI_BATCH_BUFFER_START *>(bbStartSpace);
@ -2096,7 +2096,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
// first command list settles global init and leaves state as uncached MOCS
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &cmdQueueStream = commandQueue->commandStream;
@ -2105,7 +2105,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
ze_command_list_handle_t sameCommandListTwice[] = {commandList2->toHandle(), commandList2->toHandle()};
// second command list requires uncached MOCS state, so no dynamic preamble for the fist instance, but leaves cached MOCS state
// second instance require dynamic preamble to reload MOCS to uncached state
result = commandQueue->executeCommandLists(2, sameCommandListTwice, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(2, sameCommandListTwice, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
GenCmdList cmdList;
@ -2139,7 +2139,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &cmdQueueStream = commandQueue->commandStream;
@ -2152,7 +2152,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
size_t queueUsedSize = cmdQueueStream.getUsed();
auto gpuReturnAddress = cmdQueueStream.getGpuBase() + queueUsedSize;
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &cmdContainer = commandList->getCmdContainer();
@ -2185,7 +2185,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
commandList2->toHandle(),
commandList3->toHandle()};
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &cmdQueueStream = commandQueue->commandStream;
@ -2211,7 +2211,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
result = commandList3->close();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(3, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(3, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
GenCmdList cmdList;
@ -2270,7 +2270,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
commandList2->toHandle(),
commandList3->toHandle()};
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &cmdQueueStream = commandQueue->commandStream;
@ -2293,7 +2293,7 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest,
result = commandList3->close();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(3, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(3, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
// 1st command list is preambleless

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@ -1693,7 +1693,7 @@ HWTEST2_F(FrontEndPrimaryBatchBufferCommandListTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (fePropertiesSupport.disableEuFusion) {
@ -1805,7 +1805,7 @@ HWTEST2_F(FrontEndPrimaryBatchBufferCommandListTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto commandListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (fePropertiesSupport.computeDispatchAllWalker) {

40
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_5.cpp
View File

@ -1317,7 +1317,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1370,7 +1370,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
queueBefore = cmdQueueStream.getUsed();
cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -1541,7 +1541,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1583,7 +1583,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
queueBefore = cmdQueueStream.getUsed();
cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -1711,7 +1711,7 @@ HWTEST2_F(CommandListBindlessSshPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1738,7 +1738,7 @@ HWTEST2_F(CommandListBindlessSshPrivateHeapTest,
queueBefore = cmdQueueStream.getUsed();
cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -1788,7 +1788,7 @@ HWTEST2_F(CommandListBindlessSshPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1865,7 +1865,7 @@ HWTEST2_F(CommandListBindlessSshPrivateHeapTest,
auto &cmdQueueStream = commandQueue->commandStream;
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1943,7 +1943,7 @@ HWTEST2_F(CommandListBindlessSshPrivateHeapTest,
auto &cmdQueueStream = commandQueue->commandStream;
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2377,7 +2377,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2674,7 +2674,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2788,7 +2788,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2860,7 +2860,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2958,7 +2958,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -3032,7 +3032,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -3193,7 +3193,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -3224,7 +3224,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_NE(firstHeapSurfaceBaseAddress, secondHeapSurfaceBaseAddress);
queueBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -3263,7 +3263,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -3314,7 +3314,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_EQ(secondHeapSurfaceBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
queueBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -3344,7 +3344,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto cmdListHandle = cmdListObject->toHandle();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
returnValue = cmdListObject->destroy();

48
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp
View File

@ -132,7 +132,7 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus
commandListImmediate.requiredStreamState.stateComputeMode.isCoherencyRequired.value = 0;
commandListImmediate.requiredStreamState.stateComputeMode.largeGrfMode.value = 1;
commandListImmediate.requiredStreamState.stateComputeMode.threadArbitrationPolicy.value = NEO::ThreadArbitrationPolicy::RoundRobin;
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr);
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr, nullptr);
NEO::StateComputeModePropertiesSupport scmPropertiesSupport = {};
productHelper.fillScmPropertiesSupportStructure(scmPropertiesSupport);
@ -162,7 +162,7 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus
commandListImmediate.requiredStreamState.stateComputeMode.isCoherencyRequired.value = 0;
commandListImmediate.requiredStreamState.stateComputeMode.largeGrfMode.value = 0;
commandListImmediate.requiredStreamState.stateComputeMode.threadArbitrationPolicy.value = NEO::ThreadArbitrationPolicy::AgeBased;
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr);
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr, nullptr);
expectedLargeGrfMode = scmPropertiesSupport.largeGrfMode ? 0 : -1;
expectedThreadArbitrationPolicy = scmPropertiesSupport.threadArbitrationPolicy ? NEO::ThreadArbitrationPolicy::AgeBased : -1;
@ -200,7 +200,7 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus
commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::renderCompute, returnValue));
auto &commandListImmediate = static_cast<MockCommandListImmediate<FamilyType::gfxCoreFamily> &>(*commandList);
commandListImmediate.containsAnyKernel = true;
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr);
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::kernel, false, false, nullptr, nullptr);
EXPECT_FALSE(commandListImmediate.containsAnyKernel);
}
@ -213,7 +213,7 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus
commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::renderCompute, returnValue));
auto &commandListImmediate = static_cast<MockCommandListImmediate<FamilyType::gfxCoreFamily> &>(*commandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr));
}
HWTEST2_F(CommandListExecuteImmediate, givenOutOfHostMemoryErrorOnFlushWhenExecutingCommandListImmediateWithFlushTaskThenProperErrorIsReturned, MatchAny) {
@ -225,7 +225,7 @@ HWTEST2_F(CommandListExecuteImmediate, givenOutOfHostMemoryErrorOnFlushWhenExecu
auto &commandStreamReceiver = neoDevice->getUltCommandStreamReceiver<FamilyType>();
commandStreamReceiver.flushReturnValue = SubmissionStatus::outOfHostMemory;
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr));
}
HWTEST2_F(CommandListExecuteImmediate, givenOutOfDeviceMemoryErrorOnFlushWhenExecutingCommandListImmediateWithFlushTaskThenProperErrorIsReturned, MatchAny) {
@ -237,7 +237,7 @@ HWTEST2_F(CommandListExecuteImmediate, givenOutOfDeviceMemoryErrorOnFlushWhenExe
auto &commandStreamReceiver = neoDevice->getUltCommandStreamReceiver<FamilyType>();
commandStreamReceiver.flushReturnValue = SubmissionStatus::outOfMemory;
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr));
}
HWTEST2_F(CommandListExecuteImmediate, GivenImmediateCommandListWhenCommandListIsCreatedThenCsrStateIsNotSet, MatchAny) {
@ -579,7 +579,7 @@ HWTEST2_F(CommandListTest, givenImmediateCommandListWhenFlushImmediateThenOverri
auto event = std::unique_ptr<Event>(static_cast<Event *>(L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device)));
event->csrs[0] = &mockCommandStreamReceiver;
cmdList.flushImmediate(ZE_RESULT_SUCCESS, false, false, false, NEO::AppendOperations::nonKernel, false, event->toHandle(), false, nullptr);
cmdList.flushImmediate(ZE_RESULT_SUCCESS, false, false, false, NEO::AppendOperations::nonKernel, false, event->toHandle(), false, nullptr, nullptr);
EXPECT_EQ(event->csrs[0], cmdList.getCsr(false));
}
@ -1277,7 +1277,7 @@ HWTEST2_F(CommandListTest, givenCmdListWithIndirectAccessWhenExecutingCommandLis
auto oldCommandQueue = commandListImmediate.cmdQImmediate;
commandListImmediate.cmdQImmediate = &mockCommandQueue;
commandListImmediate.indirectAllocationsAllowed = true;
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr);
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr);
EXPECT_EQ(mockCommandQueue.handleIndirectAllocationResidencyCalledTimes, 1u);
commandListImmediate.cmdQImmediate = oldCommandQueue;
}
@ -1329,7 +1329,7 @@ HWTEST2_F(CommandListTest, givenCmdListWithNoIndirectAccessWhenExecutingCommandL
auto oldCommandQueue = commandListImmediate.cmdQImmediate;
commandListImmediate.cmdQImmediate = &mockCommandQueue;
commandListImmediate.indirectAllocationsAllowed = false;
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr);
commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr);
EXPECT_EQ(mockCommandQueue.handleIndirectAllocationResidencyCalledTimes, 0u);
commandListImmediate.cmdQImmediate = oldCommandQueue;
}
@ -1492,7 +1492,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest, givenGlobalStatelessWh
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
auto result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(ultCsr->isMadeResident(globalStatelessAlloc));
@ -1554,7 +1554,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1700,7 +1700,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1812,7 +1812,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1881,7 +1881,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -1990,7 +1990,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
queueBefore = cmdQueueStream.getUsed();
cmdListHandle = commandListPrivateHeap->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -2120,7 +2120,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandListPrivateHeap->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2214,7 +2214,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
queueBefore = cmdQueueStream.getUsed();
cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueAfter = cmdQueueStream.getUsed();
@ -2401,7 +2401,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandListPrivateHeap->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2531,7 +2531,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandListPrivateHeap->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2665,7 +2665,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
size_t queueBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueAfter = cmdQueueStream.getUsed();
@ -2780,7 +2780,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
auto cmdListHandle = cmdListObject->toHandle();
auto usedBefore = csrStream.getUsed();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
returnValue = cmdListObject->destroy();
@ -2991,7 +2991,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest,
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
auto result = otherCommandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
auto result = otherCommandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(otherCommandQueue->csr->getScratchSpaceController(), otherCommandQueue->recordedScratchController);
@ -3046,7 +3046,7 @@ HWTEST2_F(ContextGroupStateBaseAddressGlobalStatelessTest,
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
auto result = otherCommandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
auto result = otherCommandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(primaryCsr->getScratchSpaceController(), otherCommandQueue->recordedScratchController);
@ -3130,7 +3130,7 @@ HWTEST2_F(CommandListStateBaseAddressGlobalStatelessTest, givenGlobalStatelessAn
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
auto result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(ultCsr->isMadeResident(globalStatelessAlloc));

8
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_7.cpp
View File

@ -1196,7 +1196,7 @@ HWTEST2_F(FrontEndMultiReturnCommandListTest,
size_t usedBefore = cmdQueueStream.getUsed();
auto cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t usedAfter = cmdQueueStream.getUsed();
@ -1446,7 +1446,7 @@ HWTEST2_F(FrontEndMultiReturnCommandListTest,
size_t usedBefore = cmdQueueStream.getUsed();
auto cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t usedAfter = cmdQueueStream.getUsed();
@ -1685,7 +1685,7 @@ HWTEST2_F(FrontEndMultiReturnCommandListTest, givenCmdQueueAndImmediateCmdListUs
auto cmdListHandle = commandList->toHandle();
usedBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
usedAfter = cmdQueueStream.getUsed();
@ -1866,7 +1866,7 @@ HWTEST2_F(FrontEndMultiReturnCommandListTest, givenCmdQueueAndImmediateCmdListUs
auto cmdListHandle = commandList->toHandle();
usedBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
usedAfter = cmdQueueStream.getUsed();

6
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
View File

@ -397,7 +397,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAppendedToCommandLi
auto commandListHandle = commandList->toHandle();
EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->synchronize(std::numeric_limits<uint64_t>::max()));
EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
@ -459,7 +459,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToC
auto commandListHandle = commandList->toHandle();
EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->synchronize(std::numeric_limits<uint64_t>::max()));
*reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
@ -526,7 +526,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToC
auto commandListHandle = commandList->toHandle();
EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr));
*reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);

8
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_memory.cpp
View File

@ -1248,7 +1248,7 @@ HWTEST2_F(AppendMemoryCopyFenceTest, givenRegularCmdListWhenDeviceToHostCopyProg
offset = cmdStream->getUsed();
cmdList.appendMemoryCopyRegion(hostBuffer, &dstRegion, 1, 1, deviceBuffer, &srcRegion, 1, 1, hostVisibleEvent->toHandle(), 0, nullptr, copyParams);
cmdList.close();
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_TRUE(verify(false));
}
@ -1259,7 +1259,7 @@ HWTEST2_F(AppendMemoryCopyFenceTest, givenRegularCmdListWhenDeviceToHostCopyProg
offset = cmdStream->getUsed();
cmdList.appendMemoryCopyRegion(hostBuffer, &dstRegion, 1, 1, deviceBuffer, &srcRegion, 1, 1, regularEvent->toHandle(), 0, nullptr, copyParams);
cmdList.close();
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_TRUE(verify(true));
}
@ -1270,7 +1270,7 @@ HWTEST2_F(AppendMemoryCopyFenceTest, givenRegularCmdListWhenDeviceToHostCopyProg
offset = cmdStream->getUsed();
cmdList.appendMemoryCopyRegion(hostBuffer, &dstRegion, 1, 1, deviceBuffer, &srcRegion, 1, 1, nullptr, 0, nullptr, copyParams);
cmdList.close();
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_TRUE(verify(true));
}
@ -1286,7 +1286,7 @@ HWTEST2_F(AppendMemoryCopyFenceTest, givenRegularCmdListWhenDeviceToHostCopyProg
EXPECT_FALSE(cmdList.taskCountUpdateFenceRequired);
cmdList.close();
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_TRUE(verify(false));
}

9
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
View File

@ -286,10 +286,12 @@ class MockCommandListImmediateHwWithWaitEventFail : public WhiteBox<::L0::Comman
ze_result_t executeCommandListImmediateWithFlushTask(bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies, NEO::AppendOperations appendOperation,
bool copyOffloadSubmission, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
++executeCommandListImmediateWithFlushTaskCalledCount;
if (callBaseExecute) {
return BaseClass::executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate, outerLock);
return BaseClass::executeCommandListImmediateWithFlushTask(performMigration, hasStallingCmds, hasRelaxedOrderingDependencies, appendOperation, copyOffloadSubmission, requireTaskCountUpdate,
outerLock, outerLockForIndirect);
}
return executeCommandListImmediateWithFlushTaskReturnValue;
}
@ -316,7 +318,8 @@ class MockCommandQueueExecute : public Mock<CommandQueue> {
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence,
bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream) override {
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
if (forceQueueExecuteError) {
return ZE_RESULT_ERROR_DEVICE_LOST;
}

12
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp
View File

@ -1751,7 +1751,7 @@ HWTEST2_F(RayTracingCmdListTest,
size_t queueSizeBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueSizeAfter = cmdQueueStream.getUsed();
@ -1762,7 +1762,7 @@ HWTEST2_F(RayTracingCmdListTest,
ultCsr->isMadeResident(rtAllocation, residentCount);
queueSizeBefore = cmdQueueStream.getUsed();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
queueSizeAfter = cmdQueueStream.getUsed();
@ -1789,7 +1789,7 @@ HWTEST2_F(RayTracingCmdListTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(ultCsr->registeredDcFlushForDcFlushMitigation, device->getProductHelper().isDcFlushMitigated());
@ -1824,7 +1824,7 @@ HWTEST2_F(RayTracingCmdListTest,
size_t queueSizeBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueSizeAfter = cmdQueueStream.getUsed();
@ -1963,7 +1963,7 @@ HWTEST2_F(RayTracingCmdListTest,
size_t queueSizeBefore = cmdQueueStream.getUsed();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
size_t queueSizeAfter = cmdQueueStream.getUsed();
@ -2401,7 +2401,7 @@ HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest,
}
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto &csrBaseAddressState = csrImmediate.getStreamProperties().stateBaseAddress;

26
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_1.cpp
View File

@ -573,7 +573,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, InOrderCmdListTests, givenInterruptableEventsWhenEx
EXPECT_NE(firstQueue->getCsr(), secondQueue->getCsr());
firstQueue->executeCommandLists(1, &cmdlistHandle, nullptr, false, nullptr);
firstQueue->executeCommandLists(1, &cmdlistHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1u, events[0]->csrs.size());
EXPECT_EQ(firstQueue->getCsr(), events[0]->csrs[0]);
EXPECT_EQ(1u, events[1]->csrs.size());
@ -581,7 +581,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, InOrderCmdListTests, givenInterruptableEventsWhenEx
EXPECT_EQ(1u, events[2]->csrs.size());
EXPECT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, events[2]->csrs[0]);
secondQueue->executeCommandLists(1, &cmdlistHandle, nullptr, false, nullptr);
secondQueue->executeCommandLists(1, &cmdlistHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1u, events[0]->csrs.size());
EXPECT_EQ(secondQueue->getCsr(), events[0]->csrs[0]);
EXPECT_EQ(1u, events[1]->csrs.size());
@ -2808,7 +2808,8 @@ HWTEST2_F(InOrderCmdListTests, givenRelaxedOrderingWhenProgrammingTimestampEvent
ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
flushData.push_back(this->cmdListCurrentStartOffset);
this->cmdListCurrentStartOffset = this->commandContainer.getCommandStream()->getUsed();
@ -2941,7 +2942,8 @@ HWTEST2_F(InOrderCmdListTests, givenRelaxedOrderingWhenProgrammingTimestampEvent
ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
auto hostAddr = reinterpret_cast<uint32_t *>(usedEvent->getCompletionFieldHostAddress());
eventCompletionData.push_back(*hostAddr);
@ -3008,7 +3010,8 @@ HWTEST2_F(InOrderCmdListTests, givenRegularNonTimestampEventWhenSkipItsConverted
ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
flushCounter++;
this->cmdListCurrentStartOffset = this->commandContainer.getCommandStream()->getUsed();
@ -3061,7 +3064,8 @@ HWTEST2_F(InOrderCmdListTests, givenDebugFlagSetWhenChainingWithRelaxedOrderingT
ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
flushCount++;
return ZE_RESULT_SUCCESS;
@ -3876,19 +3880,19 @@ HWTEST_F(InOrderCmdListTests, givenEventGeneratedByRegularCmdListWhenWaitingFrom
// 1 Execute call
offset = cmdStream->getUsed();
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr, nullptr);
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 1, &eventHandle, launchParams, false);
verifySemaphore(expectedCounterValue);
// 2 Execute calls
offset = cmdStream->getUsed();
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr, nullptr);
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 1, &eventHandle, launchParams, false);
verifySemaphore(expectedCounterValue + expectedCounterAppendValue);
// 3 Execute calls
offset = cmdStream->getUsed();
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularCmdListHandle, nullptr, false, nullptr, nullptr);
immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 1, &eventHandle, launchParams, false);
verifySemaphore(expectedCounterValue + (expectedCounterAppendValue * 2));
}
@ -5998,8 +6002,8 @@ HWTEST_F(InOrderCmdListTests, givenCounterBasedEventWhenAskingForEventAddressAnd
mockCmdQHw->initialize(false, false, false);
auto cmdListHandle = cmdList->toHandle();
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, zexEventGetDeviceAddress(eventHandle, &counterValue, &address));
EXPECT_EQ(4u, counterValue);

63
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_2.cpp
View File

@ -628,7 +628,8 @@ HWTEST2_F(CopyOffloadInOrderTests, givenRelaxedOrderingEnabledWhenDispatchingThe
public:
ze_result_t flushImmediate(ze_result_t inputRet, bool performMigration, bool hasStallingCmds, bool hasRelaxedOrderingDependencies,
NEO::AppendOperations appendOperation, bool copyOffloadSubmission, ze_event_handle_t hSignalEvent, bool requireTaskCountUpdate,
MutexLock *outerLock) override {
MutexLock *outerLock,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
latestRelaxedOrderingMode = hasRelaxedOrderingDependencies;
return ZE_RESULT_SUCCESS;
@ -1096,18 +1097,18 @@ HWTEST2_F(InOrderRegularCmdListTests, whenUsingRegularCmdListThenAddCmdsToPatch,
auto handle = regularCmdList->toHandle();
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(0);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(1);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(2);
if (regularCmdList->isQwordInOrderCounter()) {
regularCmdList->inOrderExecInfo->addRegularCmdListSubmissionCounter(static_cast<uint64_t>(std::numeric_limits<uint32_t>::max()) + 3);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(regularCmdList->inOrderExecInfo->getRegularCmdListSubmissionCounter() - 1);
}
@ -1167,14 +1168,14 @@ HWTEST2_F(InOrderRegularCmdListTests, givenCrossRegularCmdListDependenciesWhenEx
auto cmdListHandle1 = regularCmdList1->toHandle();
auto cmdListHandle2 = regularCmdList2->toHandle();
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
verifyPatching(5, baseEventWaitValue);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
verifyPatching(7, baseEventWaitValue);
}
@ -1208,9 +1209,9 @@ HWTEST2_F(InOrderRegularCmdListTests, givenCrossRegularCmdListDependenciesWhenEx
auto cmdListHandle1 = regularCmdList1->toHandle();
auto cmdListHandle2 = regularCmdList2->toHandle();
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr, nullptr);
auto cmdStream2 = regularCmdList2->getCmdContainer().getCommandStream();
@ -1242,17 +1243,17 @@ HWTEST2_F(InOrderRegularCmdListTests, givenCrossRegularCmdListDependenciesWhenEx
verifyPatching(1, baseEventWaitValue);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
verifyPatching(1, baseEventWaitValue + (2 * regularCmdList1->inOrderExecInfo->getCounterValue()));
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
verifyPatching(5, baseEventWaitValue + (2 * regularCmdList1->inOrderExecInfo->getCounterValue()));
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle1, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &cmdListHandle2, nullptr, false, nullptr, nullptr);
verifyPatching(7, baseEventWaitValue + (3 * regularCmdList1->inOrderExecInfo->getCounterValue()));
}
@ -1331,13 +1332,13 @@ HWTEST2_F(InOrderRegularCmdListTests, whenUsingRegularCmdListThenAddWalkerToPatc
auto handle = regularCmdList->toHandle();
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(0);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(1);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(2);
},
walkerVariantFromParser1, walkerVariantFromParser2, walkerVariantFromContainer1, walkerVariantFromContainer2);
@ -1658,19 +1659,19 @@ HWTEST2_F(InOrderRegularCmdListTests, givenNonInOrderRegularCmdListWhenPassingCo
auto inOrderRegularCmdListHandle = inOrderRegularCmdList->toHandle();
auto regularHandle = regularCmdList->toHandle();
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr, nullptr);
verifyPatching(0);
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr, nullptr);
verifyPatching(1);
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &inOrderRegularCmdListHandle, nullptr, false, nullptr, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr, nullptr);
verifyPatching(2);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &regularHandle, nullptr, false, nullptr, nullptr);
verifyPatching(2);
}
@ -3278,13 +3279,13 @@ HWTEST2_F(MultiTileInOrderCmdListTests, whenUsingRegularCmdListThenAddWalkerToPa
auto handle = regularCmdList->toHandle();
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(0);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(1);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr);
mockCmdQHw->executeCommandLists(1, &handle, nullptr, false, nullptr, nullptr);
verifyPatching(2);
},
walkerVariantFromParser1, walkerVariantFromParser2, walkerVariantFromContainer1, walkerVariantFromContainer2);

94
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp
View File

@ -352,7 +352,7 @@ HWTEST_F(CommandQueueCreate, given100CmdListsWhenExecutingThenCommandStreamIsNot
}
auto sizeBefore = commandQueue->commandStream.getUsed();
commandQueue->executeCommandLists(numHandles, cmdListHandles, nullptr, false, nullptr);
commandQueue->executeCommandLists(numHandles, cmdListHandles, nullptr, false, nullptr, nullptr);
auto sizeAfter = commandQueue->commandStream.getUsed();
EXPECT_LT(sizeBefore, sizeAfter);
@ -390,7 +390,7 @@ HWTEST2_F(CommandQueueCreate, givenOutOfHostMemoryErrorFromSubmitBatchBufferWhen
ze_command_list_handle_t cmdListHandles[1] = {commandList->toHandle()};
const auto result = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr);
const auto result = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, result);
commandQueue->destroy();
}
@ -417,7 +417,7 @@ HWTEST2_F(CommandQueueCreate, givenGpuHangInReservingLinearStreamWhenExecutingCo
ze_command_list_handle_t cmdListHandles[1] = {commandList->toHandle()};
const auto result = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr);
const auto result = commandQueue->executeCommandLists(1, cmdListHandles, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
commandQueue->destroy();
@ -487,11 +487,11 @@ HWTEST2_F(CommandQueueCreate, GivenDispatchTaskCountPostSyncRequiredWhenExecuteC
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
commandQueue->dispatchTaskCountPostSyncRequired = false;
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
auto estimatedSizeWithoutBarrier = commandQueue->requiredSizeCalled;
commandQueue->dispatchTaskCountPostSyncRequired = true;
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
auto estimatedSizeWithtBarrier = commandQueue->requiredSizeCalled;
auto sizeForBarrier = NEO::MemorySynchronizationCommands<FamilyType>::getSizeForBarrierWithPostSyncOperation(device->getNEODevice()->getRootDeviceEnvironment(), false);
@ -525,7 +525,7 @@ HWTEST_F(CommandQueueCreate, givenUpdateTaskCountFromWaitAndRegularCmdListWhenDi
commandList->close();
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
@ -728,7 +728,7 @@ TEST_F(CommandQueueCreate, givenCmdQueueWithBlitCopyWhenExecutingCopyBlitCommand
commandList->close();
auto commandListHandle = commandList->toHandle();
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(status, ZE_RESULT_SUCCESS);
@ -1037,7 +1037,7 @@ HWTEST2_F(ExecuteCommandListTests, givenExecuteCommandListWhenItReturnsThenConta
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation1);
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation2);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(0u, commandQueue->csr->getResidencyAllocations().size());
EXPECT_EQ(0u, commandQueue->heapContainer.size());
@ -1062,10 +1062,10 @@ HWTEST2_F(ExecuteCommandListTests, givenRegularCmdListWhenExecutionThenIncSubmis
auto commandListHandle = computeCmdList->toHandle();
computeCmdList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1u, computeCmdList->inOrderExecInfo->getRegularCmdListSubmissionCounter());
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(2u, computeCmdList->inOrderExecInfo->getRegularCmdListSubmissionCounter());
}
@ -1078,10 +1078,10 @@ HWTEST2_F(ExecuteCommandListTests, givenRegularCmdListWhenExecutionThenIncSubmis
copyCmdList->close();
commandQueue->isCopyOnlyCommandQueue = true;
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1u, copyCmdList->inOrderExecInfo->getRegularCmdListSubmissionCounter());
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(2u, copyCmdList->inOrderExecInfo->getRegularCmdListSubmissionCounter());
}
}
@ -1109,7 +1109,7 @@ HWTEST2_F(ExecuteCommandListTests, givenOutOfMemorySubmitBatchBufferThenExecuteC
auto commandListHandle = commandList->toHandle();
commandList->close();
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, res);
commandQueue->destroy();
@ -1144,7 +1144,7 @@ HWTEST2_F(CommandQueueDestroy, givenCommandQueueAndCommandListWithSshAndScratchW
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation1);
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation2);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(commandQueue->mockHeapContainer.size(), 3u);
commandQueue->destroy();
@ -1179,7 +1179,7 @@ HWTEST2_F(CommandQueueDestroy, givenCommandQueueAndCommandListWithSshAndPrivateS
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation1);
commandList->commandContainer.getSshAllocations().push_back(&graphicsAllocation2);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(commandQueue->mockHeapContainer.size(), 3u);
commandQueue->destroy();
@ -1205,7 +1205,7 @@ HWTEST2_F(ExecuteCommandListTests, givenBindlessHelperWhenCommandListIsExecutedO
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(commandQueue->mockHeapContainer.size(), 0u);
EXPECT_EQ(commandQueue->heapContainer.size(), 0u);
@ -1227,7 +1227,7 @@ HWTEST2_F(ExecuteCommandListTests, givenFailingSubmitBatchBufferThenExecuteComma
auto commandListHandle = commandList->toHandle();
commandList->close();
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, res);
commandQueue->destroy();
@ -1255,7 +1255,7 @@ HWTEST2_F(ExecuteCommandListTests, givenFailingSubmitBatchBufferThenResetGraphic
commandList->commandContainer.addToResidencyContainer(&graphicsAllocation1);
commandList->commandContainer.addToResidencyContainer(&graphicsAllocation2);
static_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(csr)->taskCount = 0;
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, res);
EXPECT_EQ(NEO::GraphicsAllocation::objectNotUsed, graphicsAllocation1.getTaskCount(csr->getOsContext().getContextId()));
@ -1287,7 +1287,7 @@ HWTEST2_F(ExecuteCommandListTests, givenFailingSubmitBatchBufferThenResetGraphic
commandList->commandContainer.addToResidencyContainer(&graphicsAllocation1);
commandList->commandContainer.addToResidencyContainer(&graphicsAllocation2);
static_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(csr)->taskCount = 2;
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, res);
auto expectedTaskCount = 2u;
@ -1318,7 +1318,7 @@ HWTEST2_F(ExecuteCommandListTests, givenFailingSubmitBatchBufferThenWaitForCompl
TaskCountType flushedTaskCountPrior = csr->peekTaskCount();
csr->setLatestFlushedTaskCount(flushedTaskCountPrior);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, res);
auto expectedFlushedTaskCount = heaplessStateInitEnabled ? 1u : 0u;
@ -1344,7 +1344,7 @@ HWTEST2_F(ExecuteCommandListTests, givenSuccessfulSubmitBatchBufferThenExecuteCo
auto &ultCsr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
ultCsr.recursiveLockCounter = 0;
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(1u, ultCsr.recursiveLockCounter);
@ -1386,10 +1386,10 @@ HWTEST2_F(ExecuteCommandListTests, givenCommandQueueHavingTwoB2BCommandListsThen
EXPECT_EQ(true, csr->getMediaVFEStateDirty());
EXPECT_EQ(true, csr->getGSBAStateDirty());
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(false, csr->getMediaVFEStateDirty());
EXPECT_EQ(false, csr->getGSBAStateDirty());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(false, csr->getMediaVFEStateDirty());
EXPECT_EQ(false, csr->getGSBAStateDirty());
@ -1425,8 +1425,8 @@ HWTEST2_F(ExecuteCommandListTests, givenCommandQueueHavingTwoB2BCommandListsThen
ASSERT_NE(nullptr, commandQueue);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1467,9 +1467,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
auto commandListHandle1 = commandList1->toHandle();
commandList1->close();
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1500,9 +1500,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
usedSpaceAfter = commandQueue1->commandStream.getUsed();
@ -1545,9 +1545,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
auto commandListHandle1 = commandList1->toHandle();
commandList1->close();
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(0u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1578,9 +1578,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
usedSpaceAfter = commandQueue1->commandStream.getUsed();
@ -1623,9 +1623,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
auto commandListHandle1 = commandList1->toHandle();
commandList1->close();
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1656,9 +1656,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
usedSpaceAfter = commandQueue1->commandStream.getUsed();
@ -1701,9 +1701,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
auto commandListHandle1 = commandList1->toHandle();
commandList1->close();
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(0u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1733,9 +1733,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(2048u, csr->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
usedSpaceAfter = commandQueue1->commandStream.getUsed();
@ -1792,9 +1792,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
auto commandListHandle1 = commandList1->toHandle();
commandList1->close();
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(0u, csr->getScratchSpaceController()->getPerThreadScratchSizeSlot1());
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(512u, csr->getScratchSpaceController()->getPerThreadScratchSizeSlot1());
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1822,9 +1822,9 @@ HWTEST2_F(ExecuteCommandListTests, givenTwoCommandQueuesHavingTwoB2BCommandLists
false,
false,
returnValue));
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle0, nullptr, false, nullptr, nullptr);
EXPECT_EQ(1024u, csr->getScratchSpaceController()->getPerThreadScratchSizeSlot1());
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, &commandListHandle1, nullptr, false, nullptr, nullptr);
EXPECT_EQ(2048u, csr->getScratchSpaceController()->getPerThreadScratchSizeSlot1());
usedSpaceAfter = commandQueue1->commandStream.getUsed();
@ -1861,7 +1861,7 @@ HWTEST_F(ExecuteCommandListTests, givenDirectSubmissionEnabledWhenExecutingCmdLi
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1907,7 +1907,7 @@ HWTEST_F(ExecuteCommandListTests, givenDirectSubmissionEnabledAndDebugFlagSetWhe
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();

16
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp
View File

@ -139,7 +139,7 @@ HWTEST_TEMPLATED_F(AubCsrTest, givenAubCsrSyncQueueAndKmdWaitWhenCallingExecuteC
auto commandListHandle = commandList->toHandle();
commandList->close();
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(aubCsr->pollForCompletionCalled, 1u);
L0::CommandQueue::fromHandle(commandQueue)->destroy();
@ -165,7 +165,7 @@ HWTEST_TEMPLATED_F(AubCsrTest, givenAubCsrAndSyncQueueWhenCallingExecuteCommandL
auto commandListHandle = commandList->toHandle();
commandList->close();
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(aubCsr->pollForCompletionCalled, 0u);
L0::CommandQueue::fromHandle(commandQueue)->destroy();
@ -191,7 +191,7 @@ HWTEST_TEMPLATED_F(AubCsrTest, givenAubCsrAndAsyncQueueWhenCallingExecuteCommand
auto commandListHandle = commandList->toHandle();
commandList->close();
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
queue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(aubCsr->pollForCompletionCalled, 0u);
L0::CommandQueue::fromHandle(commandQueue)->destroy();
@ -385,7 +385,7 @@ HWTEST2_F(MultiTileCommandQueueSynchronizeTest, givenMultiplePartitionCountWhenC
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
commandList->close();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
uint64_t timeout = std::numeric_limits<uint64_t>::max();
@ -425,7 +425,7 @@ HWTEST2_F(MultiTileCommandQueueSynchronizeTest, givenCsrHasMultipleActivePartiti
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
EXPECT_EQ(2u, commandQueue->partitionCount);
@ -510,12 +510,12 @@ HWTEST_F(CommandQueueSynchronizeTest, givenSynchronousCommandQueueWhenTagUpdateF
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
commandList->close();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -813,7 +813,7 @@ HWTEST2_F(DeviceWithDualStorage, givenCmdListWithAppendedKernelAndUsmTransferAnd
auto sizeBefore = commandQueue->commandStream.getUsed();
auto pageFaultSizeBefore = pageFaultCmdQueue->commandStream.getUsed();
auto handle = commandList->toHandle();
commandQueue->executeCommandLists(1, &handle, nullptr, true, nullptr);
commandQueue->executeCommandLists(1, &handle, nullptr, true, nullptr, nullptr);
auto sizeAfter = commandQueue->commandStream.getUsed();
auto pageFaultSizeAfter = pageFaultCmdQueue->commandStream.getUsed();
EXPECT_LT(sizeBefore, sizeAfter);

32
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_3.cpp
View File

@ -314,7 +314,7 @@ HWTEST_F(CommandQueueCommandsSingleTile, givenCommandQueueWhenExecutingCommandLi
auto commandListHandle = commandList->toHandle();
commandList->close();
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto globalFence = csr.getGlobalFenceAllocation();
if (globalFence) {
@ -364,7 +364,7 @@ HWTEST2_F(CommandQueueCommandsMultiTile, givenCommandQueueOnMultiTileWhenExecuti
auto commandListHandle = commandList->toHandle();
auto workPartitionAllocation = csr.getWorkPartitionAllocation();
csr.expectedGa = workPartitionAllocation;
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
auto status = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(status, ZE_RESULT_SUCCESS);
EXPECT_EQ(2u, csr.activePartitionsConfig);
@ -454,7 +454,7 @@ HWTEST_F(CommandQueueIndirectAllocations, givenDebugModeToTreatIndirectAllocatio
EXPECT_FALSE(gpuAlloc->isResident(csr.getOsContext().getContextId()));
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(gpuAlloc->isResident(csr.getOsContext().getContextId()));
@ -519,7 +519,7 @@ HWTEST_F(CommandQueueIndirectAllocations, givenDeviceThatSupportsSubmittingIndir
static_cast<MockMemoryManager *>(driverHandle->getMemoryManager())->overrideAllocateAsPackReturn = 1u;
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(gpuAlloc->isResident(csr.getOsContext().getContextId()));
@ -1057,7 +1057,7 @@ HWTEST2_F(CommandQueueTest, whenExecuteCommandListsIsCalledThenCorrectSizeOfFron
calculatedSize = estimateAllCommmandLists<FamilyType::gfxCoreFamily>(commandQueue, csr, commandLists, commandListSize, true);
EXPECT_EQ(1 * singleFrontEndCmdSize, calculatedSize);
commandQueue->executeCommandLists(4, commandLists, nullptr, false, nullptr);
commandQueue->executeCommandLists(4, commandLists, nullptr, false, nullptr, nullptr);
}
int32_t expectedComputeDispatchAllWalkerEnable = fePropertiesSupport.computeDispatchAllWalker ? 0 : -1;
expectedSingleFrontEndSizeNumber = fePropertiesSupport.computeDispatchAllWalker ? 1 : 0;
@ -1071,7 +1071,7 @@ HWTEST2_F(CommandQueueTest, whenExecuteCommandListsIsCalledThenCorrectSizeOfFron
calculatedSize = estimateAllCommmandLists<FamilyType::gfxCoreFamily>(commandQueue, csr, commandLists, commandListSize, true);
EXPECT_EQ((expectedSingleFrontEndSizeNumber + 1) * singleFrontEndCmdSize, calculatedSize);
commandQueue->executeCommandLists(3, commandLists, nullptr, false, nullptr);
commandQueue->executeCommandLists(3, commandLists, nullptr, false, nullptr, nullptr);
}
EXPECT_EQ(expectedComputeDispatchAllWalkerEnable, csr->getStreamProperties().frontEndState.computeDispatchAllWalkerEnable.value);
{
@ -1093,7 +1093,7 @@ HWTEST2_F(CommandQueueTest, whenExecuteCommandListsIsCalledThenCorrectSizeOfFron
calculatedSize = estimateAllCommmandLists<FamilyType::gfxCoreFamily>(commandQueue, csr, commandLists, commandListSize, true);
EXPECT_EQ(1 * singleFrontEndCmdSize, calculatedSize);
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr, nullptr);
}
expectedComputeDispatchAllWalkerEnable = fePropertiesSupport.computeDispatchAllWalker ? 1 : -1;
EXPECT_EQ(expectedComputeDispatchAllWalkerEnable, csr->getStreamProperties().frontEndState.computeDispatchAllWalkerEnable.value);
@ -1106,7 +1106,7 @@ HWTEST2_F(CommandQueueTest, whenExecuteCommandListsIsCalledThenCorrectSizeOfFron
calculatedSize = estimateAllCommmandLists<FamilyType::gfxCoreFamily>(commandQueue, csr, commandLists, commandListSize, true);
EXPECT_EQ(1 * singleFrontEndCmdSize, calculatedSize);
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr, nullptr);
}
expectedComputeDispatchAllWalkerEnable = fePropertiesSupport.computeDispatchAllWalker ? 0 : -1;
EXPECT_EQ(expectedComputeDispatchAllWalkerEnable, csr->getStreamProperties().frontEndState.computeDispatchAllWalkerEnable.value);
@ -1138,7 +1138,7 @@ HWTEST2_F(CommandQueueTest, givenRegularKernelScheduledAsCooperativeWhenExecuteC
EXPECT_EQ(-1, csr->getStreamProperties().frontEndState.computeDispatchAllWalkerEnable.value);
ze_command_list_handle_t commandLists[] = {commandList->toHandle()};
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr, nullptr);
NEO::FrontEndPropertiesSupport fePropertiesSupport = {};
auto &productHelper = device->getProductHelper();
productHelper.fillFrontEndPropertiesSupportStructure(fePropertiesSupport, device->getHwInfo());
@ -1197,24 +1197,24 @@ HWTEST2_F(CommandQueueTest, givenTwoCommandQueuesUsingOneCsrWhenExecuteCommandLi
int32_t expectedCurrentState = dispatchAllWalkerSupport ? 0 : -1;
commandQueue1->executeCommandLists(1, commandListsA, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, commandListsA, nullptr, false, nullptr, nullptr);
EXPECT_EQ(expectedCurrentState, currentStreamValue);
commandQueue2->executeCommandLists(1, commandListsA, nullptr, false, nullptr);
commandQueue2->executeCommandLists(1, commandListsA, nullptr, false, nullptr, nullptr);
EXPECT_EQ(expectedCurrentState, currentStreamValue);
commandQueue2->executeCommandLists(1, commandListsB, nullptr, false, nullptr);
commandQueue2->executeCommandLists(1, commandListsB, nullptr, false, nullptr, nullptr);
expectedCurrentState = expectedCurrentState != -1 ? 1 : -1;
EXPECT_EQ(expectedCurrentState, currentStreamValue);
commandQueue1->executeCommandLists(1, commandListsB, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, commandListsB, nullptr, false, nullptr, nullptr);
EXPECT_EQ(expectedCurrentState, currentStreamValue);
commandQueue2->executeCommandLists(1, commandListsA, nullptr, false, nullptr);
commandQueue2->executeCommandLists(1, commandListsA, nullptr, false, nullptr, nullptr);
expectedCurrentState = expectedCurrentState != -1 ? 0 : -1;
EXPECT_EQ(expectedCurrentState, currentStreamValue);
commandQueue1->executeCommandLists(1, commandListsB, nullptr, false, nullptr);
commandQueue1->executeCommandLists(1, commandListsB, nullptr, false, nullptr, nullptr);
expectedCurrentState = expectedCurrentState != -1 ? 1 : -1;
EXPECT_EQ(expectedCurrentState, currentStreamValue);
@ -1332,7 +1332,7 @@ HWTEST2_F(DeferredFirstSubmissionCmdQueueTests, givenDebugFlagSetWhenSubmittingT
EXPECT_EQ(0u, commandQueue1->getCsr()->peekTaskCount());
EXPECT_EQ(0u, commandQueue2->getCsr()->peekTaskCount());
commandQueue2->executeCommandLists(1, &commandListHandle2, nullptr, false, nullptr);
commandQueue2->executeCommandLists(1, &commandListHandle2, nullptr, false, nullptr, nullptr);
EXPECT_NE(0u, primaryCsr->peekTaskCount());
EXPECT_EQ(1u, primaryCsr->initializeDeviceWithFirstSubmissionCalled);

6
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_debugger.cpp
View File

@ -73,7 +73,7 @@ HWTEST_F(L0CmdQueueDebuggerTest, givenDebuggingEnabledWhenCmdListRequiringSbaPro
ze_command_list_handle_t commandListHandle = commandList->toHandle();
const uint32_t numCommandLists = 1u;
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr);
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = cmdStream.getUsed();
@ -209,7 +209,7 @@ HWTEST2_F(L0CmdQueueDebuggerTest, givenDebugEnabledWhenCommandsAreExecutedTwoTim
ze_command_list_handle_t commandListHandle = commandList->toHandle();
const uint32_t numCommandLists = 1u;
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr);
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = cmdStream.getUsed();
@ -228,7 +228,7 @@ HWTEST2_F(L0CmdQueueDebuggerTest, givenDebugEnabledWhenCommandsAreExecutedTwoTim
EXPECT_EQ(cmdList.end(), itCsrCommand);
}
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr);
result = cmdQ->executeCommandLists(numCommandLists, &commandListHandle, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
GenCmdList cmdList2;

44
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist.cpp
View File

@ -137,7 +137,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenACommandListExecutedRequiresUncach
auto commandList2 = CommandList::whiteboxCast(CommandList::fromHandle(commandLists[1]));
commandList1->requiresQueueUncachedMocs = true;
commandList2->requiresQueueUncachedMocs = true;
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->destroy();
}
@ -170,7 +170,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, givenCommandListThatRequiresDisabledEU
auto commandList1 = static_cast<WhiteBoxCommandList *>(CommandList::fromHandle(commandLists[0]));
commandList1->requiredStreamState.frontEndState.disableEUFusion.set(true);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto &productHelper = device->getProductHelper();
bool disableEuFusion = productHelper.getFrontEndPropertyDisableEuFusionSupport();
@ -199,7 +199,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenASecondLevelBatchBufferPerCommandL
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -254,7 +254,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, givenFenceWhenExecutingCmdListThenFenc
ASSERT_NE(nullptr, fence);
EXPECT_EQ(ZE_RESULT_NOT_READY, fence->queryStatus());
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fence, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fence, true, nullptr, nullptr);
*csr.tagAddress = 11;
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(*csr.tagAddress, fence->taskCount);
@ -287,7 +287,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, whenExecutingCommandListsThenEndingPip
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -334,7 +334,7 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenCommandQueueHaving2CommandListsT
ASSERT_NE(nullptr, commandQueue);
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1024u, neoDevice->getDefaultEngine().commandStreamReceiver->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
@ -363,7 +363,7 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenCommandQueueHaving2CommandListsT
CommandList::fromHandle(commandLists[0])->close();
CommandList::fromHandle(commandLists[1])->close();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(2048u, neoDevice->getDefaultEngine().commandStreamReceiver->getScratchSpaceController()->getPerThreadScratchSpaceSizeSlot0());
@ -418,7 +418,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, givenMidThreadPreemptionWhenCommandsAr
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -476,7 +476,7 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenMidThreadPreemptionWhenCommandsA
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->synchronize(0);
@ -501,7 +501,7 @@ HWTEST2_F(CommandQueueExecuteCommandLists, givenMidThreadPreemptionWhenCommandsA
EXPECT_EQ(cmdList.end(), itorSip);
}
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->synchronize(0);
@ -566,7 +566,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsImplicitScalingDisabled, givenCommandLi
pCommandListWithCooperativeKernels->appendLaunchKernelWithParams(&kernel, threadGroupDimensions, nullptr, launchParams);
pCommandListWithCooperativeKernels->close();
ze_command_list_handle_t commandListCooperative[] = {pCommandListWithCooperativeKernels->toHandle()};
auto result = pCommandQueue->executeCommandLists(1, commandListCooperative, nullptr, false, nullptr);
auto result = pCommandQueue->executeCommandLists(1, commandListCooperative, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1u, pMockCsr->submitBatchBufferCalled);
@ -577,7 +577,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsImplicitScalingDisabled, givenCommandLi
pCommandListWithNonCooperativeKernels->appendLaunchKernelWithParams(&kernel, threadGroupDimensions, nullptr, launchParams);
pCommandListWithNonCooperativeKernels->close();
ze_command_list_handle_t commandListNonCooperative[] = {pCommandListWithNonCooperativeKernels->toHandle()};
result = pCommandQueue->executeCommandLists(1, commandListNonCooperative, nullptr, false, nullptr);
result = pCommandQueue->executeCommandLists(1, commandListNonCooperative, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(2u, pMockCsr->submitBatchBufferCalled);
@ -613,7 +613,7 @@ void CommandQueueExecuteCommandListsFixture::twoCommandListCommandPreemptionTest
commandListThreadGroup->toHandle(),
commandListDisabled->toHandle()};
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->synchronize(0);
@ -621,7 +621,7 @@ void CommandQueueExecuteCommandListsFixture::twoCommandListCommandPreemptionTest
EXPECT_EQ(NEO::PreemptionMode::Disabled, currentCsr->getPreemptionMode());
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(NEO::PreemptionMode::Disabled, currentCsr->getPreemptionMode());
@ -914,7 +914,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, GivenCopyCommandQueueWhenExecutingCopy
commandList->close();
zet_command_list_handle_t cmdListHandle = commandList->toHandle();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
size_t usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -994,7 +994,7 @@ HWTEST_F(CommandQueueExecuteCommandListSWTagsTests, givenEnableSWTagsWhenExecuti
}
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr);
auto result = commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1020,7 +1020,7 @@ HWTEST_F(CommandQueueExecuteCommandListSWTagsTests, givenEnableSWTagsAndCommandL
CommandList::whiteboxCast(CommandList::fromHandle(commandLists[0]))->commandListPreemptionMode = PreemptionMode::Disabled;
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr);
auto result = commandQueue->executeCommandLists(1, commandLists, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1118,7 +1118,7 @@ HWTEST2_F(MultiDeviceCommandQueueExecuteCommandLists, givenMultiplePartitionCoun
// 1st execute call initialized pipeline
auto usedSpaceBefore1stExecute = commandQueue->commandStream.getUsed();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceOn1stExecute = commandQueue->commandStream.getUsed() - usedSpaceBefore1stExecute;
@ -1133,7 +1133,7 @@ HWTEST2_F(MultiDeviceCommandQueueExecuteCommandLists, givenMultiplePartitionCoun
findPartitionRegister<FamilyType>(cmdList, true);
auto usedSpaceBefore2ndExecute = commandQueue->commandStream.getUsed();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter2ndExecute = commandQueue->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter2ndExecute, usedSpaceBefore2ndExecute);
@ -1149,7 +1149,7 @@ HWTEST2_F(MultiDeviceCommandQueueExecuteCommandLists, givenMultiplePartitionCoun
findPartitionRegister<FamilyType>(cmdList, false);
auto usedSpaceBefore3rdExecute = commandQueue->commandStream.getUsed();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter3rdExecute = commandQueue->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter3rdExecute, usedSpaceBefore3rdExecute);
@ -1211,7 +1211,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, GivenUpdateTaskCountFromWaitWhenExecut
commandList->close();
zet_command_list_handle_t cmdListHandle = commandList->toHandle();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, fenceHandle, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, fenceHandle, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
size_t usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -1265,7 +1265,7 @@ HWTEST_F(CommandQueueExecuteCommandLists, GivenCopyCommandQueueWhenExecutingCopy
zet_command_list_handle_t cmdListHandle = commandList->toHandle();
commandList->close();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, fenceHandle, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, fenceHandle, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
size_t usedSpaceAfter = commandQueue->commandStream.getUsed();

28
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp
View File

@ -34,7 +34,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, GivenSynchronousModeWhenExe
ze_command_list_handle_t commandLists[] = {
CommandList::create(productFamily, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false)->toHandle()};
CommandList::fromHandle(commandLists[0])->close();
mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr);
mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(mockCmdQ->synchronizedCalled, 1u);
CommandList::fromHandle(commandLists[0])->destroy();
mockCmdQ->destroy();
@ -52,7 +52,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, GivenSynchronousModeAndDevi
ze_command_list_handle_t commandLists[] = {
CommandList::create(productFamily, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false)->toHandle()};
CommandList::fromHandle(commandLists[0])->close();
const auto result = mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr);
const auto result = mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(mockCmdQ->synchronizedCalled, 1u);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
@ -69,7 +69,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, GivenAsynchronousModeWhenEx
ze_command_list_handle_t commandLists[] = {
CommandList::create(productFamily, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false)->toHandle()};
CommandList::fromHandle(commandLists[0])->close();
mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr);
mockCmdQ->executeCommandLists(1, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(mockCmdQ->synchronizedCalled, 0u);
CommandList::fromHandle(commandLists[0])->destroy();
mockCmdQ->destroy();
@ -98,7 +98,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, whenUsingFenceThenLastPipeC
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
CommandList::fromHandle(commandLists[0])->close();
CommandList::fromHandle(commandLists[1])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, fenceHandle, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -150,7 +150,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, givenTwoCommandQueuesUsingS
CommandList::fromHandle(commandList)->close();
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
returnValue = commandQueue->executeCommandLists(1, &commandList, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &commandList, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
@ -175,7 +175,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, givenTwoCommandQueuesUsingS
ASSERT_NE(nullptr, commandQueue2);
usedSpaceBefore = commandQueue2->commandStream.getUsed();
returnValue = commandQueue2->executeCommandLists(1, &commandList, nullptr, false, nullptr);
returnValue = commandQueue2->executeCommandLists(1, &commandList, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
usedSpaceAfter = commandQueue2->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
@ -211,7 +211,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, givenTwoCommandQueuesUsingS
CommandList::fromHandle(commandList)->close();
auto usedSpaceBefore = commandQueue->commandStream.getUsed();
returnValue = commandQueue->executeCommandLists(1, &commandList, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &commandList, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
@ -242,7 +242,7 @@ HWTEST2_F(CommandQueueExecuteCommandListsSimpleTest, givenTwoCommandQueuesUsingS
ASSERT_NE(nullptr, commandQueue2);
usedSpaceBefore = commandQueue2->commandStream.getUsed();
returnValue = commandQueue2->executeCommandLists(1, &commandList, nullptr, false, nullptr);
returnValue = commandQueue2->executeCommandLists(1, &commandList, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
usedSpaceAfter = commandQueue2->commandStream.getUsed();
ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
@ -386,7 +386,7 @@ struct PauseOnGpuFixture : public Test<ModuleFixture> {
result = commandList->close();
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(1u, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1u, &commandListHandle, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
}
@ -428,7 +428,7 @@ struct PauseOnGpuTests : public PauseOnGpuFixture {
result = commandList->close();
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(1u, &commandListHandle, nullptr, false, nullptr);
result = commandQueue->executeCommandLists(1u, &commandListHandle, nullptr, false, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
}
};
@ -775,7 +775,7 @@ HWTEST_F(CommandQueueExecuteCommandListsSimpleTest, GivenDirtyFlagForContextInBi
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
CommandList::fromHandle(commandLists[0])->close();
CommandList::fromHandle(commandLists[1])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -822,7 +822,7 @@ HWTEST_F(CommandQueueExecuteCommandListsSimpleTest, GivenRegisterInstructionCach
CommandList::create(productFamily, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false)->toHandle()};
uint32_t numCommandLists = 1;
CommandList::fromHandle(commandLists[0])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -889,7 +889,7 @@ HWTEST_F(CommandQueueExecuteCommandListsMultiDeviceTest, GivenDirtyFlagForContex
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
CommandList::fromHandle(commandLists[0])->close();
CommandList::fromHandle(commandLists[1])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -934,7 +934,7 @@ HWTEST_F(CommandQueueExecuteCommandListsSimpleTest, givenRegularCommandListNotCl
auto commandListHandle = commandList->toHandle();
returnValue = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
returnValue = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, returnValue);
commandList->close();

6
level_zero/core/test/unit_tests/sources/context/test_context.cpp
View File

@ -787,7 +787,7 @@ HWTEST_F(ContextMakeMemoryResidentAndMigrationTests,
returnValue, false));
auto commandListHandle = commandList->toHandle();
commandList->close();
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(mockPageFaultManager->moveAllocationToGpuDomainCalledTimes, 1u);
@ -839,7 +839,7 @@ HWTEST2_F(ContextMakeMemoryResidentAndMigrationTests,
commandList->close();
auto commandListHandle = commandList->toHandle();
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(mockPageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomainCalled, 1u);
@ -889,7 +889,7 @@ HWTEST_F(ContextMakeMemoryResidentAndMigrationTests,
auto commandListHandle = commandList->toHandle();
commandList->close();
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
res = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(mockPageFaultManager->moveAllocationToGpuDomainCalledTimes, 0u);

16
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@ -116,7 +116,7 @@ HWTEST_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledWhenCommandL
commandList->close();
}
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -198,7 +198,7 @@ HWTEST_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledWhenTwoComma
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
returnValue = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
returnValue = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -211,7 +211,7 @@ HWTEST_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledWhenTwoComma
auto stateSipCmds = findAll<STATE_SIP *>(cmdList.begin(), cmdList.end());
EXPECT_EQ(1u, stateSipCmds.size());
returnValue = commandQueue2->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
returnValue = commandQueue2->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter2 = commandQueue2->commandStream.getUsed();
@ -555,7 +555,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledForRegularCo
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
commandList->close();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -591,7 +591,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledForRegularC
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
commandList->close();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -925,7 +925,7 @@ HWTEST_F(DebuggerWithGlobalBindlessTest, GivenGlobalBindlessHeapWhenExecutingCmd
commandList->close();
memoryOperationsHandler->captureGfxAllocationsForMakeResident = true;
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto allocIter = std::find(memoryOperationsHandler->gfxAllocationsForMakeResident.begin(),
@ -992,7 +992,7 @@ HWTEST2_F(L0DebuggerGlobalStatelessTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
commandList->close();
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(statelessSurfaceHeap->getCpuBase());
@ -1015,7 +1015,7 @@ HWTEST2_F(L0DebuggerGlobalStatelessTest,
memset(debugSurfaceState, 0, sizeof(RENDER_SURFACE_STATE));
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr);
returnValue = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
char zeroBuffer[sizeof(RENDER_SURFACE_STATE)];

6
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp
View File

@ -487,7 +487,7 @@ HWTEST2_P(L0DebuggerWithBlitterTest, givenUseCsrImmediateSubmissionEnabledForReg
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
commandList->close();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -564,7 +564,7 @@ HWTEST2_P(L0DebuggerWithBlitterTest, givenDebuggingEnabledWhenInternalCmdQIsUsed
auto commandList = whiteboxCast(static_cast<L0::CommandListImp *>(CommandList::fromHandle(commandLists[0])));
commandList->closedCmdList = true;
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto sbaBuffer = device->getL0Debugger()->getSbaTrackingBuffer(neoDevice->getDefaultEngine().commandStreamReceiver->getOsContext().getContextId());
@ -626,7 +626,7 @@ HWTEST_P(L0DebuggerWithBlitterTest, givenDebuggingEnabledWhenCommandListIsExecut
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
commandList->close();
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();

14
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp
View File

@ -146,7 +146,7 @@ HWTEST2_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledAndRequired
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();
@ -212,7 +212,7 @@ HWTEST2_F(L0DebuggerPerContextAddressSpaceGlobalBindlessTest, givenDebuggingEnab
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandList->getCmdContainer().getCommandStream()->getUsed();
@ -288,7 +288,7 @@ HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledAndDebuggerLogsWhenCommandQueueIs
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -325,7 +325,7 @@ HWTEST2_F(L0DebuggerSimpleTest, givenNullL0DebuggerAndDebuggerLogsWhenCommandQue
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -357,7 +357,7 @@ HWTEST2_F(L0DebuggerTest, givenL0DebuggerAndDebuggerLogsDisabledWhenCommandQueue
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandQueue->synchronize(0);
@ -453,7 +453,7 @@ HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledWhenCommandListIsExecutedThenSbaB
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto sbaBuffer = device->getL0Debugger()->getSbaTrackingBuffer(neoDevice->getDefaultEngine().commandStreamReceiver->getOsContext().getContextId());
@ -531,7 +531,7 @@ HWTEST2_F(L0DebuggerSingleAddressSpace, givenDebuggingEnabledWhenCommandListIsEx
auto commandList = CommandList::fromHandle(commandLists[0]);
commandList->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandQueue->commandStream.getUsed();

9
level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp
View File

@ -3809,7 +3809,8 @@ TEST_F(MultipleDevicesTest, givenDeviceFailsExecuteCommandListThenCanAccessPeerR
ze_result_t executeCommandLists(uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence, bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream)
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect)
override { return ZE_RESULT_ERROR_UNKNOWN; }
};
@ -3868,7 +3869,8 @@ TEST_F(MultipleDevicesTest, givenQueryPeerStatsReturningBandwidthZeroAndDeviceFa
ze_result_t executeCommandLists(uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence, bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream)
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect)
override { return ZE_RESULT_ERROR_UNKNOWN; }
};
@ -3928,7 +3930,8 @@ TEST_F(MultipleDevicesTest, givenQueryPeerStatsReturningBandwidthNonZeroAndDevic
ze_result_t executeCommandLists(uint32_t numCommandLists,
ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence, bool performMigration,
NEO::LinearStream *parentImmediateCommandlistLinearStream) override {
NEO::LinearStream *parentImmediateCommandlistLinearStream,
std::unique_lock<std::mutex> *outerLockForIndirect) override {
return ZE_RESULT_SUCCESS;
}
};

6
level_zero/core/test/unit_tests/xe2_hpg_core/test_cmdqueue_xe2_hpg_core.cpp
View File

@ -38,7 +38,7 @@ HWTEST2_F(CommandQueueCommandsXe2HpgCore, givenCommandQueueWhenExecutingCommandL
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto globalFence = csr->getGlobalFenceAllocation();
@ -69,9 +69,9 @@ HWTEST2_F(CommandQueueCommandsXe2HpgCore, givenCommandQueueWhenExecutingCommandL
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceAfter1stExecute = commandQueue->commandStream.getUsed();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceOn2ndExecute = commandQueue->commandStream.getUsed() - usedSpaceAfter1stExecute;
GenCmdList cmdList;

12
level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp
View File

@ -212,7 +212,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenForceMemoryPrefetchForKmdMigra
auto commandQueue = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, false, returnValue);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto mockMemoryManager = reinterpret_cast<NEO::MockMemoryManager *>(neoDevice->getMemoryManager());
@ -286,7 +286,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenNoForceMemoryPrefetchForKmdMig
auto commandQueue = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, false, returnValue);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto mockMemoryManager = reinterpret_cast<NEO::MockMemoryManager *>(neoDevice->getMemoryManager());
@ -322,7 +322,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenEnableBOChunkingPrefetchWhenEx
auto commandQueue = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, false, returnValue);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto mockMemoryManager = reinterpret_cast<NEO::MockMemoryManager *>(neoDevice->getMemoryManager());
@ -357,7 +357,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenForceMemoryPrefetchForKmdMigra
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::renderCompute, returnValue));
auto &commandListImmediate = static_cast<MockCommandListImmediate<FamilyType::gfxCoreFamily> &>(*commandList);
result = commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr);
result = commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false, NEO::AppendOperations::nonKernel, false, false, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto mockMemoryManager = reinterpret_cast<NEO::MockMemoryManager *>(neoDevice->getMemoryManager());
@ -628,7 +628,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenAppendMemoryPrefetchForKmdMigr
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
commandList->close();
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(memoryManager->setMemPrefetchCalled);
@ -780,7 +780,7 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenAppendMemoryPrefetchForKmdMigr
result = commandList->close();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr);
result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true, nullptr, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(memoryManager->setMemPrefetchCalled);

8
level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp
View File

@ -45,7 +45,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenCommandQueueWhenExecutingCommandListsT
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto globalFence = csr.getGlobalFenceAllocation();
@ -73,7 +73,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenCommandQueueWhenExecutingCommandListsT
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto globalFence = csr->getGlobalFenceAllocation();
@ -104,9 +104,9 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenCommandQueueWhenExecutingCommandListsF
auto commandListHandle = commandList->toHandle();
commandList->close();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceAfter1stExecute = commandQueue->commandStream.getUsed();
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr);
commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr);
auto usedSpaceOn2ndExecute = commandQueue->commandStream.getUsed() - usedSpaceAfter1stExecute;
GenCmdList cmdList;

6
level_zero/core/test/unit_tests/xe_hpg_core/test_cmdqueue_enqueuecommandlist_xe_hpg_core.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2024 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -41,7 +41,7 @@ XE_HPG_CORETEST_F(CommandQueueExecuteCommandListsXeHpgCore, WhenExecutingCmdList
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
CommandList::fromHandle(commandLists[0])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
@ -87,7 +87,7 @@ XE_HPG_CORETEST_F(CommandQueueExecuteCommandListsXeHpgCore, WhenExecutingCmdList
uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
CommandList::fromHandle(commandLists[0])->close();
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr);
auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true, nullptr, nullptr);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);