diff --git a/level_zero/core/source/cmdlist/cmdlist.h b/level_zero/core/source/cmdlist/cmdlist.h index 249b6802c9..8620d784e9 100644 --- a/level_zero/core/source/cmdlist/cmdlist.h +++ b/level_zero/core/source/cmdlist/cmdlist.h @@ -199,6 +199,15 @@ struct CommandList : _ze_command_list_handle_t { commandListPerThreadScratchSize[slotId] = size; } + uint32_t getCommandListPatchedPerThreadScratchSize(uint32_t slotId) const { + return commandListPatchedPerThreadScratchSize[slotId]; + } + + void setCommandListPatchedPerThreadScratchSize(uint32_t slotId, uint32_t size) { + UNRECOVERABLE_IF(slotId > 1); + commandListPatchedPerThreadScratchSize[slotId] = size; + } + uint32_t getCommandListSLMEnable() const { return commandListSLMEnabled; } @@ -404,6 +413,9 @@ struct CommandList : _ze_command_list_handle_t { size_t cmdListCurrentStartOffset = 0; size_t maxFillPaternSizeForCopyEngine = 0; + uint32_t commandListPerThreadScratchSize[2]{}; + uint32_t commandListPatchedPerThreadScratchSize[2]{}; + ze_command_list_flags_t flags = 0u; NEO::PreemptionMode commandListPreemptionMode = NEO::PreemptionMode::Initial; NEO::EngineGroupType engineGroupType = NEO::EngineGroupType::maxEngineGroups; @@ -411,7 +423,6 @@ struct CommandList : _ze_command_list_handle_t { std::optional ordinal = std::nullopt; CommandListType cmdListType = CommandListType::typeRegular; - uint32_t commandListPerThreadScratchSize[2]{}; uint32_t partitionCount = 1; uint32_t defaultMocsIndex = 0; diff --git a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl index 3225df58ab..fbe03a47ce 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl +++ b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl @@ -360,7 +360,7 @@ inline ze_result_t CommandListCoreFamilyImmediate::executeCommand cmdQ->makeResidentAndMigrate(performMigration, this->commandContainer.getResidencyContainer()); - static_cast *>(this->cmdQImmediate)->patchCommands(*this, 0u); + static_cast *>(this->cmdQImmediate)->patchCommands(*this, 0u, 0, 0); if (performMigration) { this->migrateSharedAllocations(); diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.h b/level_zero/core/source/cmdqueue/cmdqueue_hw.h index bb9e8e69c5..b871d269f7 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw.h +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw.h @@ -57,7 +57,9 @@ struct CommandQueueHw : public CommandQueueImp { uint32_t perThreadScratchSpaceSlot1Size); bool getPreemptionCmdProgramming() override; - void patchCommands(CommandList &commandList, uint64_t scratchAddress); + void patchCommands(CommandList &commandList, uint64_t scratchAddress, + uint32_t perThreadScratchSpaceSlot0Size, + uint32_t perThreadScratchSpaceSlot1Size); protected: struct CommandListExecutionContext { diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl index ad6e287d43..241681baeb 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl @@ -1705,7 +1705,9 @@ void CommandQueueHw::patchCommands(CommandList &commandList, Comm if (this->heaplessModeEnabled && this->cmdListHeapAddressModel == NEO::HeapAddressModel::globalStateless) { scratchAddress += ctx.globalStatelessAllocation->getGpuAddress(); } - patchCommands(commandList, scratchAddress); + patchCommands(commandList, scratchAddress, + ctx.scratchSpaceController->getPerThreadScratchSpaceSizeSlot0(), + ctx.scratchSpaceController->getPerThreadScratchSizeSlot1()); } } // namespace L0 diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw_skl_to_tgllp.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw_skl_to_tgllp.inl index 15b6a11ef9..2c5cf3e416 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw_skl_to_tgllp.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw_skl_to_tgllp.inl @@ -133,7 +133,9 @@ void CommandQueueHw::handleScratchSpace(NEO::HeapContainer &heapC } template -void CommandQueueHw::patchCommands(CommandList &commandList, uint64_t scratchAddress) { +void CommandQueueHw::patchCommands(CommandList &commandList, uint64_t scratchAddress, + uint32_t perThreadScratchSpaceSlot0Size, + uint32_t perThreadScratchSpaceSlot1Size) { using MI_SEMAPHORE_WAIT = typename GfxFamily::MI_SEMAPHORE_WAIT; using COMPARE_OPERATION = typename GfxFamily::MI_SEMAPHORE_WAIT::COMPARE_OPERATION; diff --git a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl index e27cc937ee..4d43f8f6c4 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl @@ -163,11 +163,20 @@ void CommandQueueHw::handleScratchSpace(NEO::HeapContainer &sshHe } template -void CommandQueueHw::patchCommands(CommandList &commandList, uint64_t scratchAddress) { +void CommandQueueHw::patchCommands(CommandList &commandList, uint64_t scratchAddress, + uint32_t perThreadScratchSpaceSlot0Size, + uint32_t perThreadScratchSpaceSlot1Size) { using CFE_STATE = typename GfxFamily::CFE_STATE; using MI_SEMAPHORE_WAIT = typename GfxFamily::MI_SEMAPHORE_WAIT; using COMPARE_OPERATION = typename GfxFamily::MI_SEMAPHORE_WAIT::COMPARE_OPERATION; + bool patchNewInlineScratchAddress = false; + if (this->heaplessModeEnabled && + (commandList.getCommandListPatchedPerThreadScratchSize(0) < perThreadScratchSpaceSlot0Size || + commandList.getCommandListPatchedPerThreadScratchSize(1) < perThreadScratchSpaceSlot1Size)) { + patchNewInlineScratchAddress = true; + } + auto &commandsToPatch = commandList.getCommandsToPatch(); for (auto &commandToPatch : commandsToPatch) { switch (commandToPatch.type) { @@ -229,6 +238,9 @@ void CommandQueueHw::patchCommands(CommandList &commandList, uint break; } case CommandToPatch::ComputeWalkerInlineDataScratch: { + if (!patchNewInlineScratchAddress) { + continue; + } uint64_t fullScratchAddress = scratchAddress + commandToPatch.baseAddress; void *scratchAddressPatch = ptrOffset(commandToPatch.pDestination, commandToPatch.offset); std::memcpy(scratchAddressPatch, &fullScratchAddress, commandToPatch.patchSize); @@ -238,6 +250,11 @@ void CommandQueueHw::patchCommands(CommandList &commandList, uint UNRECOVERABLE_IF(true); } } + + if (patchNewInlineScratchAddress) { + commandList.setCommandListPatchedPerThreadScratchSize(0, perThreadScratchSpaceSlot0Size); + commandList.setCommandListPatchedPerThreadScratchSize(1, perThreadScratchSpaceSlot1Size); + } } } // namespace L0 diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp index 9208aa0296..445b9bffef 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp @@ -598,7 +598,7 @@ void CommandListScratchPatchFixtureInit::setUpParams(int32_t globalStatelessMode commandQueue->heaplessStateInitEnabled = !!heaplessStateInitEnabled; mockKernelImmData->kernelDescriptor->kernelAttributes.perThreadScratchSize[0] = 0x40; - mockKernelImmData->kernelDescriptor->payloadMappings.implicitArgs.scratchPointerAddress.pointerSize = 0x8; + mockKernelImmData->kernelDescriptor->payloadMappings.implicitArgs.scratchPointerAddress.pointerSize = scratchInlinePointerSize; mockKernelImmData->kernelDescriptor->payloadMappings.implicitArgs.scratchPointerAddress.offset = scratchInlineOffset; } diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h index 57daaea749..6aadb7cc06 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h @@ -371,8 +371,15 @@ struct CommandListScratchPatchFixtureInit : public ModuleMutableCommandListFixtu template void testScratchInline(bool useImmediate); + template + void testScratchGrowingPatching(); + + template + void testScratchSameNotPatching(); + int32_t fixtureGlobalStatelessMode = 0; uint32_t scratchInlineOffset = 8; + uint32_t scratchInlinePointerSize = sizeof(uint64_t); }; template diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl index b534cfb467..9fc902fa26 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl @@ -1493,5 +1493,152 @@ void CommandListScratchPatchFixtureInit::testScratchInline(bool useImmediate) { EXPECT_TRUE(scratchInResidency); } +template +void CommandListScratchPatchFixtureInit::testScratchGrowingPatching() { + auto csr = device->getNEODevice()->getDefaultEngine().commandStreamReceiver; + auto scratchController = csr->getScratchSpaceController(); + + NEO::EncodeDispatchKernelArgs dispatchKernelArgs = {}; + dispatchKernelArgs.isHeaplessModeEnabled = true; + + size_t inlineOffset = NEO::EncodeDispatchKernel::getInlineDataOffset(dispatchKernelArgs); + + uint64_t surfaceHeapGpuBase = getSurfStateGpuBase(false); + + auto cmdListStream = commandList->commandContainer.getCommandStream(); + + const ze_group_count_t groupCount{1, 1, 1}; + CmdListKernelLaunchParams launchParams = {}; + + auto result = ZE_RESULT_SUCCESS; + size_t usedBefore = cmdListStream->getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false); + size_t usedAfter = cmdListStream->getUsed(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + GenCmdList cmdList; + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(cmdListStream->getCpuBase(), usedBefore), + usedAfter - usedBefore)); + + auto walkerIterator = NEO::UnitTestHelper::findWalkerCmd(cmdList.begin(), cmdList.end(), true); + ASSERT_NE(cmdList.end(), walkerIterator); + void *walkerPtrWithScratch = *walkerIterator; + + result = commandList->close(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto commandListHandle = commandList->toHandle(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, 0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto scratchAddress = scratchController->getScratchPatchAddress(); + auto fullScratchAddress = surfaceHeapGpuBase + scratchAddress; + + uint64_t scratchInlineValue = 0; + + void *scratchInlinePtr = ptrOffset(walkerPtrWithScratch, (inlineOffset + scratchInlineOffset)); + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(fullScratchAddress, scratchInlineValue); + + commandList->reset(); + mockKernelImmData->kernelDescriptor->kernelAttributes.perThreadScratchSize[1] = 0x40; + + usedBefore = cmdListStream->getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false); + usedAfter = cmdListStream->getUsed(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + cmdList.clear(); + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(cmdListStream->getCpuBase(), usedBefore), + usedAfter - usedBefore)); + + walkerIterator = NEO::UnitTestHelper::findWalkerCmd(cmdList.begin(), cmdList.end(), true); + ASSERT_NE(cmdList.end(), walkerIterator); + void *walkerPtrWithSlot1Scratch = *walkerIterator; + + result = commandList->close(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, 0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + scratchAddress = scratchController->getScratchPatchAddress(); + auto fullScratchSlot1Address = surfaceHeapGpuBase + scratchAddress; + + scratchInlinePtr = ptrOffset(walkerPtrWithSlot1Scratch, (inlineOffset + scratchInlineOffset)); + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(fullScratchSlot1Address, scratchInlineValue); + + memset(scratchInlinePtr, 0, scratchInlinePointerSize); + + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, 0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(0u, scratchInlineValue); +} + +template +void CommandListScratchPatchFixtureInit::testScratchSameNotPatching() { + auto csr = device->getNEODevice()->getDefaultEngine().commandStreamReceiver; + auto scratchController = csr->getScratchSpaceController(); + + NEO::EncodeDispatchKernelArgs dispatchKernelArgs = {}; + dispatchKernelArgs.isHeaplessModeEnabled = true; + + size_t inlineOffset = NEO::EncodeDispatchKernel::getInlineDataOffset(dispatchKernelArgs); + + uint64_t surfaceHeapGpuBase = getSurfStateGpuBase(false); + + auto cmdListStream = commandList->commandContainer.getCommandStream(); + + const ze_group_count_t groupCount{1, 1, 1}; + CmdListKernelLaunchParams launchParams = {}; + + auto result = ZE_RESULT_SUCCESS; + size_t usedBefore = cmdListStream->getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false); + size_t usedAfter = cmdListStream->getUsed(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + GenCmdList cmdList; + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(cmdListStream->getCpuBase(), usedBefore), + usedAfter - usedBefore)); + + auto walkerIterator = NEO::UnitTestHelper::findWalkerCmd(cmdList.begin(), cmdList.end(), true); + ASSERT_NE(cmdList.end(), walkerIterator); + void *walkerPtrWithScratch = *walkerIterator; + + result = commandList->close(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto commandListHandle = commandList->toHandle(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, 0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto scratchAddress = scratchController->getScratchPatchAddress(); + auto fullScratchAddress = surfaceHeapGpuBase + scratchAddress; + + uint64_t scratchInlineValue = 0; + + void *scratchInlinePtr = ptrOffset(walkerPtrWithScratch, (inlineOffset + scratchInlineOffset)); + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(fullScratchAddress, scratchInlineValue); + + memset(scratchInlinePtr, 0, scratchInlinePointerSize); + + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, 0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(0u, scratchInlineValue); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp index fbe91597f8..8d3a0b5241 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp @@ -1564,20 +1564,60 @@ HWTEST2_F(CommandListScratchPatchPrivateHeapsTest, testScratchInline(false); } +HWTEST2_F(CommandListScratchPatchPrivateHeapsTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchTwiceThenCorrectAddressPatchedOnce, IsAtLeastXeHpcCore) { + testScratchSameNotPatching(); +} + +HWTEST2_F(CommandListScratchPatchPrivateHeapsTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithBiggerScratchSlot1ThenNewCorrectAddressPatched, IsAtLeastXeHpcCore) { + testScratchGrowingPatching(); +} + HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsTest, givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchThenExpectCorrectAddressPatched, IsAtLeastXeHpcCore) { testScratchInline(false); } +HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchTwiceThenCorrectAddressPatchedOnce, IsAtLeastXeHpcCore) { + testScratchSameNotPatching(); +} + +HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithBiggerScratchSlot1ThenNewCorrectAddressPatched, IsAtLeastXeHpcCore) { + testScratchGrowingPatching(); +} + HWTEST2_F(CommandListScratchPatchPrivateHeapsStateInitTest, givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchThenExpectCorrectAddressPatched, IsAtLeastXeHpcCore) { testScratchInline(false); } +HWTEST2_F(CommandListScratchPatchPrivateHeapsStateInitTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchTwiceThenCorrectAddressPatchedOnce, IsAtLeastXeHpcCore) { + testScratchSameNotPatching(); +} + +HWTEST2_F(CommandListScratchPatchPrivateHeapsStateInitTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithBiggerScratchSlot1ThenNewCorrectAddressPatched, IsAtLeastXeHpcCore) { + testScratchGrowingPatching(); +} + HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsStateInitTest, givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchThenExpectCorrectAddressPatched, IsAtLeastXeHpcCore) { testScratchInline(false); } +HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsStateInitTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithScratchTwiceThenCorrectAddressPatchedOnce, IsAtLeastXeHpcCore) { + testScratchSameNotPatching(); +} + +HWTEST2_F(CommandListScratchPatchGlobalStatelessHeapsStateInitTest, + givenHeaplessWithScratchPatchEnabledOnRegularCmdListWhenAppendingAndExecutingKernelWithBiggerScratchSlot1ThenNewCorrectAddressPatched, IsAtLeastXeHpcCore) { + testScratchGrowingPatching(); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp index a35b4deb3c..f330602236 100644 --- a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp @@ -948,9 +948,9 @@ HWTEST2_F(CommandQueueScratchTests, whenPatchCommandsIsCalledThenCommandsAreCorr auto commandQueue = std::make_unique>(device, csr, &desc); auto commandList = std::make_unique>>(); - EXPECT_NO_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_NO_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.push_back({}); - EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.clear(); CFE_STATE destinationCfeStates[4]; @@ -978,7 +978,7 @@ HWTEST2_F(CommandQueueScratchTests, whenPatchCommandsIsCalledThenCommandsAreCorr } uint64_t patchedScratchAddress = 0xABCD00; - commandQueue->patchCommands(*commandList, patchedScratchAddress); + commandQueue->patchCommands(*commandList, patchedScratchAddress, 0, 0); for (size_t i = 0; i < 4; i++) { EXPECT_EQ(patchedScratchAddress, destinationCfeStates[i].getScratchSpaceBuffer()); auto &sourceCfeState = *reinterpret_cast(commandList->commandsToPatch[i].pCommand); @@ -999,21 +999,21 @@ HWTEST2_F(CommandQueueScratchTests, givenCommandsToPatchToNotSupportedPlatformWh auto commandQueue = std::make_unique>(device, csr, &desc); auto commandList = std::make_unique>>(); - EXPECT_NO_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_NO_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.push_back({}); - EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.clear(); CommandToPatch commandToPatch; commandToPatch.type = CommandToPatch::FrontEndState; commandList->commandsToPatch.push_back(commandToPatch); - EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.clear(); commandToPatch.type = CommandToPatch::Invalid; commandList->commandsToPatch.push_back(commandToPatch); - EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0)); + EXPECT_ANY_THROW(commandQueue->patchCommands(*commandList, 0, 0, 0)); commandList->commandsToPatch.clear(); }