diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp index efc120e68d..a2a680dd60 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp @@ -298,6 +298,9 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenImmediateCommandListWhenAppendingL } HWTEST2_F(CommandListAppendLaunchKernel, givenKernelUsingSyncBufferWhenAppendLaunchCooperativeKernelIsCalledThenCorrectValueIsReturned, IsAtLeastSkl) { + DebugManagerStateRestore restore; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + Mock<::L0::Kernel> kernel; auto pMockModule = std::unique_ptr(new Mock(device, nullptr)); kernel.module = pMockModule.get(); diff --git a/level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp b/level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp index fd6702c744..ceacd496e3 100644 --- a/level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp +++ b/level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp @@ -363,8 +363,11 @@ class KernelImpSuggestMaxCooperativeGroupCountTests : public KernelImp { uint32_t maxBarrierCount; WhiteBox<::L0::KernelImmutableData> kernelInfo; NEO::KernelDescriptor kernelDescriptor; + DebugManagerStateRestore restorer; void SetUp() override { + NEO::DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + KernelImp::SetUp(); kernelInfo.kernelDescriptor = &kernelDescriptor; auto &hardwareInfo = device->getHwInfo(); diff --git a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp index e606fd0c83..0f66e62a7c 100644 --- a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp +++ b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp @@ -34,6 +34,9 @@ using CommandListAppendLaunchKernelXeHpcCore = Test; HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore, givenKernelUsingSyncBufferWhenAppendLaunchCooperativeKernelIsCalledThenCorrectValueIsReturned, IsXeHpcCore) { auto &hwInfo = *device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo(); auto &productHelper = *NEO::ProductHelper::get(hwInfo.platform.eProductFamily); + VariableBackup hwRevId{&hwInfo.platform.usRevId}; + hwRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hwInfo); + Mock<::L0::Kernel> kernel; auto pMockModule = std::unique_ptr(new Mock(device, nullptr)); kernel.module = pMockModule.get(); @@ -54,9 +57,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore, givenKernelUsingSyncBufferWhen { VariableBackup engineGroupType{&pCommandList->engineGroupType}; - VariableBackup hwRevId{&hwInfo.platform.usRevId}; engineGroupType = EngineGroupType::RenderCompute; - hwRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hwInfo); result = pCommandList->appendLaunchKernelWithParams(&kernel, &groupCount, nullptr, launchParams); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result); diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp index 22aca931e0..7692eb4291 100644 --- a/opencl/source/api/api.cpp +++ b/opencl/source/api/api.cpp @@ -6047,7 +6047,9 @@ cl_int CL_API_CALL clEnqueueNDCountKernelINTEL(cl_command_queue commandQueue, auto &gfxCoreHelper = device.getGfxCoreHelper(); auto engineGroupType = gfxCoreHelper.getEngineGroupType(pCommandQueue->getGpgpuEngine().getEngineType(), pCommandQueue->getGpgpuEngine().getEngineUsage(), hardwareInfo); - if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { + if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo) && + (DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.get() == false) && + (DebugManager.flags.OverrideMaxWorkGroupCount.get() == -1)) { retVal = CL_INVALID_COMMAND_QUEUE; return retVal; } diff --git a/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp index 1dc29d5906..9d11550f26 100644 --- a/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp @@ -10,6 +10,7 @@ #include "shared/source/helpers/preamble.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/kernel_binary_helper.h" +#include "shared/test/common/helpers/raii_hw_helper.h" #include "shared/test/common/helpers/unit_test_helper.h" #include "shared/test/common/mocks/mock_csr.h" #include "shared/test/common/mocks/mock_submissions_aggregator.h" @@ -175,6 +176,9 @@ TEST(EnqueueMultiDeviceKernelTest, givenMultiDeviceKernelWhenSetArgDeviceUSMThen } TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalledTwiceThenClEnqueueNDRangeKernelReturnsError) { + DebugManagerStateRestore stateRestore; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + const size_t n = 512; size_t globalWorkSize[3] = {n, 1, 1}; size_t localWorkSize[3] = {256, 1, 1}; @@ -310,13 +314,6 @@ TEST_F(EnqueueKernelTest, GivenNullKernelWhenEnqueuingNDCountKernelINTELThenInva using clEnqueueNDCountKernelTests = api_tests; TEST_F(clEnqueueNDCountKernelTests, GivenQueueIncapableWhenEnqueuingNDCountKernelINTELThenInvalidOperationIsReturned) { - auto &gfxCoreHelper = GfxCoreHelper::get(::defaultHwInfo->platform.eRenderCoreFamily); - auto engineGroupType = gfxCoreHelper.getEngineGroupType(pCommandQueue->getGpgpuEngine().getEngineType(), - pCommandQueue->getGpgpuEngine().getEngineUsage(), *::defaultHwInfo); - if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, *::defaultHwInfo)) { - GTEST_SKIP(); - } - cl_uint workDim = 1; size_t globalWorkOffset[3] = {0, 0, 0}; size_t workgroupCount[3] = {1, 1, 1}; @@ -338,6 +335,9 @@ TEST_F(clEnqueueNDCountKernelTests, GivenQueueIncapableWhenEnqueuingNDCountKerne } TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDCountKernelINTELReturnsSuccess) { + DebugManagerStateRestore stateRestore; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + const size_t n = 512; size_t workgroupCount[3] = {2, 1, 1}; size_t localWorkSize[3] = {64, 1, 1}; @@ -345,9 +345,11 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDCountKernel CommandQueue *pCmdQ2 = createCommandQueue(pClDevice); GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily); + auto &productHelper = *ProductHelper::get(hardwareInfo.platform.eProductFamily); auto engineGroupType = gfxCoreHelper.getEngineGroupType(pCmdQ2->getGpgpuEngine().getEngineType(), pCmdQ2->getGpgpuEngine().getEngineUsage(), hardwareInfo); - if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { + if (productHelper.isCooperativeEngineSupported(hardwareInfo) && + !gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, EngineUsage::LowPriority).osContext; } @@ -386,6 +388,9 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDCountKernel } TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalledTwiceThenClEnqueueNDCountKernelINTELReturnsError) { + DebugManagerStateRestore stateRestore; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + const size_t n = 512; size_t workgroupCount[3] = {2, 1, 1}; size_t localWorkSize[3] = {256, 1, 1}; @@ -393,9 +398,11 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled CommandQueue *pCmdQ2 = createCommandQueue(pClDevice); GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily); + auto &productHelper = *ProductHelper::get(hardwareInfo.platform.eProductFamily); auto engineGroupType = gfxCoreHelper.getEngineGroupType(pCmdQ2->getGpgpuEngine().getEngineType(), pCmdQ2->getGpgpuEngine().getEngineUsage(), hardwareInfo); - if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { + if (productHelper.isCooperativeEngineSupported(hardwareInfo) && + !gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, EngineUsage::LowPriority).osContext; } @@ -434,6 +441,9 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled } TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeastFailsThenClEnqueueNDCountKernelINTELReturnsError) { + DebugManagerStateRestore stateRestore; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + const size_t n = 512; size_t workgroupCount[3] = {2, 1, 1}; size_t localWorkSize[3] = {256, 1, 1}; @@ -441,9 +451,11 @@ TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeas CommandQueue *pCmdQ2 = createCommandQueue(pClDevice); GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily); + auto &productHelper = *ProductHelper::get(hardwareInfo.platform.eProductFamily); auto engineGroupType = gfxCoreHelper.getEngineGroupType(pCmdQ2->getGpgpuEngine().getEngineType(), pCmdQ2->getGpgpuEngine().getEngineUsage(), hardwareInfo); - if (!gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { + if (productHelper.isCooperativeEngineSupported(hardwareInfo) && + !gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hardwareInfo)) { pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, EngineUsage::LowPriority).osContext; } @@ -498,6 +510,64 @@ TEST_F(EnqueueKernelTest, GivenInvalidEventListCountWhenEnqueuingNDCountKernelIN EXPECT_EQ(CL_INVALID_EVENT_WAIT_LIST, retVal); } +template +struct MockGfxCoreHelperCooperativeDispatchSupportedOverride : GfxCoreHelperHw { + bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const override { + return isCooperativeDispatchSupportedValue; + } + bool isCooperativeDispatchSupportedValue = false; +}; + +HWTEST_F(EnqueueKernelTest, GivenCommandQueueNotSupportingCooperativeDispatchWhenCallingClEnqueueNDCountKernelINTELWithConcurrenteKernelThenCorrectReturnValueIsReturned) { + MockGfxCoreHelperCooperativeDispatchSupportedOverride gfxCoreHelper{}; + VariableBackup gfxCoreHelperFactoryBackup{&NEO::gfxCoreHelperFactory[static_cast(hardwareInfo.platform.eRenderCoreFamily)]}; + gfxCoreHelperFactoryBackup = &gfxCoreHelper; + auto pMockCommandQueueHw = std::make_unique(context, pClDevice, nullptr, false); + + MockKernelWithInternals mockKernel(*pClDevice, context); + mockKernel.kernelInfo.kernelDescriptor.kernelAttributes.flags.usesSyncBuffer = true; + mockKernel.mockMultiDeviceKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL); + + auto getClEnqueueNDCountKernelINTELResult = [&pMockCommandQueueHw, &mockKernel]() -> cl_int { + size_t workgroupCount[3] = {1, 1, 1}; + size_t localWorkSize[3] = {1, 1, 1}; + + return clEnqueueNDCountKernelINTEL( + pMockCommandQueueHw.get(), + mockKernel.mockMultiDeviceKernel, + 1, + nullptr, + workgroupCount, + localWorkSize, + 0, + nullptr, + nullptr); + }; + + for (auto useDebugFlagForceTheoreticalMaxWgCount : ::testing::Bool()) { + DebugManagerStateRestore stateRestore; + if (useDebugFlagForceTheoreticalMaxWgCount) { + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + } + + for (auto useDebugFlagOverrideMaxWgCount : ::testing::Bool()) { + if (useDebugFlagOverrideMaxWgCount) { + DebugManager.flags.OverrideMaxWorkGroupCount.set(1); + } + + for (auto isCooperativeDispatchSupported : ::testing::Bool()) { + gfxCoreHelper.isCooperativeDispatchSupportedValue = isCooperativeDispatchSupported; + + if (isCooperativeDispatchSupported || useDebugFlagForceTheoreticalMaxWgCount || useDebugFlagOverrideMaxWgCount) { + EXPECT_EQ(CL_SUCCESS, getClEnqueueNDCountKernelINTELResult()); + } else { + EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, getClEnqueueNDCountKernelINTELResult()); + } + } + } + } +} + HWTEST_F(EnqueueKernelTest, WhenEnqueingKernelThenTaskLevelIsIncremented) { auto taskLevelBefore = pCmdQ->taskLevel; callOneWorkItemNDRKernel(); diff --git a/opencl/test/unit_test/command_queue/sync_buffer_handler_tests.cpp b/opencl/test/unit_test/command_queue/sync_buffer_handler_tests.cpp index 65c79195d3..05ab2b1a8b 100644 --- a/opencl/test/unit_test/command_queue/sync_buffer_handler_tests.cpp +++ b/opencl/test/unit_test/command_queue/sync_buffer_handler_tests.cpp @@ -6,6 +6,7 @@ */ #include "shared/source/program/sync_buffer_handler.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/mocks/ult_device_factory.h" #include "shared/test/common/test_macros/hw_test.h" @@ -65,6 +66,8 @@ class SyncBufferHandlerTest : public SyncBufferEnqueueHandlerTest { template void setUpT() { + NEO::DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + SyncBufferEnqueueHandlerTest::SetUp(); kernelInternals = std::make_unique(*pClDevice, context); kernelInternals->kernelInfo.kernelDescriptor.kernelAttributes.bufferAddressingMode = KernelDescriptor::Stateless; @@ -112,6 +115,7 @@ class SyncBufferHandlerTest : public SyncBufferEnqueueHandlerTest { std::unique_ptr kernelInternals; MockKernel *kernel; MockCommandQueue *commandQueue; + DebugManagerStateRestore restorer; }; HWTEST_TEMPLATED_F(SyncBufferHandlerTest, GivenAllocateSyncBufferPatchAndConcurrentKernelWhenEnqueuingKernelThenSyncBufferIsUsed) { diff --git a/shared/source/helpers/hw_helper_base.inl b/shared/source/helpers/hw_helper_base.inl index 6a9992045a..d9bc7c0f65 100644 --- a/shared/source/helpers/hw_helper_base.inl +++ b/shared/source/helpers/hw_helper_base.inl @@ -595,13 +595,17 @@ bool GfxCoreHelperHw::isRcsAvailable(const HardwareInfo &hwInfo) cons template bool GfxCoreHelperHw::isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const { - return true; + return false; } template uint32_t GfxCoreHelperHw::adjustMaxWorkGroupCount(uint32_t maxWorkGroupCount, const EngineGroupType engineGroupType, const HardwareInfo &hwInfo, bool isEngineInstanced) const { - return maxWorkGroupCount; + if ((DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.get()) || + (DebugManager.flags.OverrideMaxWorkGroupCount.get() != -1)) { + return maxWorkGroupCount; + } + return 1u; } template diff --git a/shared/source/helpers/hw_helper_pvc_and_later.inl b/shared/source/helpers/hw_helper_pvc_and_later.inl index 86c0c4508c..0cc1f060d2 100644 --- a/shared/source/helpers/hw_helper_pvc_and_later.inl +++ b/shared/source/helpers/hw_helper_pvc_and_later.inl @@ -44,7 +44,7 @@ bool GfxCoreHelperHw::isCooperativeDispatchSupported(const EngineGroupTy return !isRcsAvailable(hwInfo) || isExclusiveContextUsed; } - return true; + return false; } template <> @@ -57,9 +57,7 @@ uint32_t GfxCoreHelperHw::adjustMaxWorkGroupCount(uint32_t maxWorkGroupC if (!isCooperativeDispatchSupported(engineGroupType, hwInfo)) { return 1u; } - auto &productHelper = *ProductHelper::get(hwInfo.platform.eProductFamily); - bool requiresLimitation = productHelper.isCooperativeEngineSupported(hwInfo) && - (engineGroupType != EngineGroupType::CooperativeCompute) && + bool requiresLimitation = (engineGroupType != EngineGroupType::CooperativeCompute) && (!isEngineInstanced); if (requiresLimitation) { auto ccsCount = hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled; diff --git a/shared/test/unit_test/helpers/hw_helper_tests.cpp b/shared/test/unit_test/helpers/hw_helper_tests.cpp index d5889d1c2b..522a3d6e4c 100644 --- a/shared/test/unit_test/helpers/hw_helper_tests.cpp +++ b/shared/test/unit_test/helpers/hw_helper_tests.cpp @@ -1433,3 +1433,88 @@ TEST(GfxCoreHelperTests, whenIsDynamicallyPopulatedisTrueThengetHighestEnabledSl auto maxSlice = gfxCoreHelper.getHighestEnabledSlice(hwInfo); EXPECT_EQ(maxSlice, 7u); } + +HWTEST2_F(GfxCoreHelperTest, WhenIsRcsAvailableIsCalledThenTrueIsReturned, IsAtMostXeHpgCore) { + auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily); + EXPECT_TRUE(gfxCoreHelper.isRcsAvailable(*defaultHwInfo)); +} + +using GfxCoreHelperAdjustMaxWorkGroupCountTests = ::testing::Test; + +HWTEST_F(GfxCoreHelperAdjustMaxWorkGroupCountTests, GivenCooperativeEngineSupportedAndNotUsedWhenAdjustMaxWorkGroupCountIsCalledThenSmallerValueIsReturned) { + auto hwInfo = *defaultHwInfo; + auto &gfxCoreHelper = NEO::GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily); + auto &productHelper = *NEO::ProductHelper::get(hwInfo.platform.eProductFamily); + + hwInfo.capabilityTable.defaultEngineType = aub_stream::EngineType::ENGINE_CCS; + hwInfo.featureTable.flags.ftrRcsNode = false; + + uint32_t revisions[] = {REVISION_A0, REVISION_B}; + for (auto &revision : revisions) { + auto hwRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo); + if (hwRevId == CommonConstants::invalidStepping) { + continue; + } + hwInfo.platform.usRevId = hwRevId; + + for (auto isEngineInstanced : ::testing::Bool()) { + for (auto isRcsEnabled : ::testing::Bool()) { + hwInfo.featureTable.flags.ftrRcsNode = isRcsEnabled; + for (auto engineGroupType : {EngineGroupType::RenderCompute, EngineGroupType::Compute, EngineGroupType::CooperativeCompute}) { + if (productHelper.isCooperativeEngineSupported(hwInfo)) { + bool disallowDispatch = (engineGroupType == EngineGroupType::RenderCompute) || + ((engineGroupType == EngineGroupType::Compute) && isRcsEnabled); + bool applyLimitation = !isEngineInstanced && + (engineGroupType != EngineGroupType::CooperativeCompute); + if (disallowDispatch) { + EXPECT_EQ(1u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, engineGroupType, hwInfo, isEngineInstanced)); + EXPECT_EQ(1u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, engineGroupType, hwInfo, isEngineInstanced)); + } else if (applyLimitation) { + hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 4; + EXPECT_EQ(1u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, engineGroupType, hwInfo, isEngineInstanced)); + EXPECT_EQ(256u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, engineGroupType, hwInfo, isEngineInstanced)); + hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 2; + EXPECT_EQ(2u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, engineGroupType, hwInfo, isEngineInstanced)); + EXPECT_EQ(512u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, engineGroupType, hwInfo, isEngineInstanced)); + } else { + EXPECT_EQ(4u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, engineGroupType, hwInfo, isEngineInstanced)); + EXPECT_EQ(1024u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, engineGroupType, hwInfo, isEngineInstanced)); + } + } else { + EXPECT_EQ(1u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, engineGroupType, hwInfo, isEngineInstanced)); + EXPECT_EQ(1u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, engineGroupType, hwInfo, isEngineInstanced)); + } + } + } + } + } +} + +template +struct MockGfxCoreHelper : GfxCoreHelperHw { + bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const override { + return isCooperativeDispatchSupportedValue; + } + bool isCooperativeDispatchSupportedValue = true; +}; +HWTEST_F(GfxCoreHelperAdjustMaxWorkGroupCountTests, GivenDebugTogglesInfluencingMaxWorkGroupCountSetWhenAdjustMaxWorkGroupCountIsCalledThenDontChangeResult) { + MockGfxCoreHelper gfxCoreHelper{}; + auto hwInfo = *defaultHwInfo; + hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 2; + + for (auto isCooperativeDispatchSupported : ::testing::Bool()) { + gfxCoreHelper.isCooperativeDispatchSupportedValue = isCooperativeDispatchSupported; + { + DebugManagerStateRestore dbgRestorer; + DebugManager.flags.OverrideMaxWorkGroupCount.set(1); + EXPECT_EQ(4u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, EngineGroupType::RenderCompute, hwInfo, false)); + EXPECT_EQ(1024u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, EngineGroupType::RenderCompute, hwInfo, false)); + } + { + DebugManagerStateRestore dbgRestorer; + DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true); + EXPECT_EQ(4u, gfxCoreHelper.adjustMaxWorkGroupCount(4u, EngineGroupType::RenderCompute, hwInfo, false)); + EXPECT_EQ(1024u, gfxCoreHelper.adjustMaxWorkGroupCount(1024u, EngineGroupType::RenderCompute, hwInfo, false)); + } + } +} diff --git a/shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp b/shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp index f0b36b88f9..7dde9ad9f0 100644 --- a/shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp +++ b/shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp @@ -160,7 +160,7 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, WhenIsCooperativeDispatchSupportedThenCo EXPECT_TRUE(isCooperativeDispatchSupported); } } else { - EXPECT_TRUE(isCooperativeDispatchSupported); + EXPECT_FALSE(isCooperativeDispatchSupported); } } } diff --git a/shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp b/shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp index f85cd53faf..838790ada6 100644 --- a/shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp +++ b/shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp @@ -149,7 +149,7 @@ PVCTEST_F(EngineNodeHelperPvcTests, givenCccsDisabledWhenGetGpgpuEnginesCalledTh EXPECT_EQ(aub_stream::ENGINE_BCS, engines[7].first); } -PVCTEST_F(EngineNodeHelperPvcTests, givenCCSEngineWhenCallingIsCooperativeDispatchSupportedThenTrueIsReturned) { +PVCTEST_F(EngineNodeHelperPvcTests, givenCCSEngineWhenCallingIsCooperativeDispatchSupportedThenFalseIsReturned) { const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily); auto hwInfo = *defaultHwInfo; hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCS; @@ -157,7 +157,7 @@ PVCTEST_F(EngineNodeHelperPvcTests, givenCCSEngineWhenCallingIsCooperativeDispat auto engineGroupType = gfxCoreHelper.getEngineGroupType(pDevice->getDefaultEngine().getEngineType(), pDevice->getDefaultEngine().getEngineUsage(), hwInfo); auto retVal = gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hwInfo); - EXPECT_TRUE(retVal); + EXPECT_FALSE(retVal); } PVCTEST_F(EngineNodeHelperPvcTests, givenCCCSEngineAndRevisionBWhenCallingIsCooperativeDispatchSupportedThenFalseIsReturned) { @@ -169,7 +169,7 @@ PVCTEST_F(EngineNodeHelperPvcTests, givenCCCSEngineAndRevisionBWhenCallingIsCoop auto engineGroupType = gfxCoreHelper.getEngineGroupType(pDevice->getDefaultEngine().getEngineType(), pDevice->getDefaultEngine().getEngineUsage(), hwInfo); auto retVal = gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hwInfo); - EXPECT_TRUE(retVal); + EXPECT_FALSE(retVal); hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hwInfo); retVal = gfxCoreHelper.isCooperativeDispatchSupported(engineGroupType, hwInfo);