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

Limit cooperative dispatch support to platforms supporting cooperative engine 

By default, cooperative dispatch is not supported
for platforms not supporting cooperative engine.

Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski 2022-11-20 22:36:09 +00:00 committed by Compute-Runtime-Automation
parent 6c7ca96f28
commit c124bfbc6c
11 changed files with 193 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp
View File

@ -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<Module>(new Mock<Module>(device, nullptr));
kernel.module = pMockModule.get();

3
level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp
View File

@ -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();

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

@ -34,6 +34,9 @@ using CommandListAppendLaunchKernelXeHpcCore = Test<LocalMemoryModuleFixture>;
HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore, givenKernelUsingSyncBufferWhenAppendLaunchCooperativeKernelIsCalledThenCorrectValueIsReturned, IsXeHpcCore) {
auto &hwInfo = *device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = *NEO::ProductHelper::get(hwInfo.platform.eProductFamily);
VariableBackup<unsigned short> hwRevId{&hwInfo.platform.usRevId};
hwRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hwInfo);
Mock<::L0::Kernel> kernel;
auto pMockModule = std::unique_ptr<Module>(new Mock<Module>(device, nullptr));
kernel.module = pMockModule.get();
@ -54,9 +57,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore, givenKernelUsingSyncBufferWhen
{
VariableBackup<EngineGroupType> engineGroupType{&pCommandList->engineGroupType};
VariableBackup<unsigned short> 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);

4
opencl/source/api/api.cpp
View File

@ -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;
}

90
opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
View File

@ -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 <typename FamilyType>
struct MockGfxCoreHelperCooperativeDispatchSupportedOverride : GfxCoreHelperHw<FamilyType> {
bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const override {
return isCooperativeDispatchSupportedValue;
}
bool isCooperativeDispatchSupportedValue = false;
};
HWTEST_F(EnqueueKernelTest, GivenCommandQueueNotSupportingCooperativeDispatchWhenCallingClEnqueueNDCountKernelINTELWithConcurrenteKernelThenCorrectReturnValueIsReturned) {
MockGfxCoreHelperCooperativeDispatchSupportedOverride<FamilyType> gfxCoreHelper{};
VariableBackup<GfxCoreHelper *> gfxCoreHelperFactoryBackup{&NEO::gfxCoreHelperFactory[static_cast<size_t>(hardwareInfo.platform.eRenderCoreFamily)]};
gfxCoreHelperFactoryBackup = &gfxCoreHelper;
auto pMockCommandQueueHw = std::make_unique<MockCommandQueue>(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();

4
opencl/test/unit_test/command_queue/sync_buffer_handler_tests.cpp
View File

@ -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 <typename FamilyType>
void setUpT() {
NEO::DebugManager.flags.ForceTheoreticalMaxWorkGroupCount.set(true);
SyncBufferEnqueueHandlerTest::SetUp();
kernelInternals = std::make_unique<MockKernelWithInternals>(*pClDevice, context);
kernelInternals->kernelInfo.kernelDescriptor.kernelAttributes.bufferAddressingMode = KernelDescriptor::Stateless;
@ -112,6 +115,7 @@ class SyncBufferHandlerTest : public SyncBufferEnqueueHandlerTest {
std::unique_ptr<MockKernelWithInternals> kernelInternals;
MockKernel *kernel;
MockCommandQueue *commandQueue;
DebugManagerStateRestore restorer;
};
HWTEST_TEMPLATED_F(SyncBufferHandlerTest, GivenAllocateSyncBufferPatchAndConcurrentKernelWhenEnqueuingKernelThenSyncBufferIsUsed) {

8
shared/source/helpers/hw_helper_base.inl
View File

@ -595,13 +595,17 @@ bool GfxCoreHelperHw<GfxFamily>::isRcsAvailable(const HardwareInfo &hwInfo) cons
template <typename GfxFamily>
bool GfxCoreHelperHw<GfxFamily>::isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const {
return true;
return false;
}
template <typename GfxFamily>
uint32_t GfxCoreHelperHw<GfxFamily>::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 <typename GfxFamily>

6
shared/source/helpers/hw_helper_pvc_and_later.inl
View File

@ -44,7 +44,7 @@ bool GfxCoreHelperHw<Family>::isCooperativeDispatchSupported(const EngineGroupTy
return !isRcsAvailable(hwInfo) || isExclusiveContextUsed;
}
return true;
return false;
}
template <>
@ -57,9 +57,7 @@ uint32_t GfxCoreHelperHw<Family>::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;

85
shared/test/unit_test/helpers/hw_helper_tests.cpp
View File

@ -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 <typename FamilyType>
struct MockGfxCoreHelper : GfxCoreHelperHw<FamilyType> {
bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType, const HardwareInfo &hwInfo) const override {
return isCooperativeDispatchSupportedValue;
}
bool isCooperativeDispatchSupportedValue = true;
};
HWTEST_F(GfxCoreHelperAdjustMaxWorkGroupCountTests, GivenDebugTogglesInfluencingMaxWorkGroupCountSetWhenAdjustMaxWorkGroupCountIsCalledThenDontChangeResult) {
MockGfxCoreHelper<FamilyType> 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));
}
}
}

2
shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp
View File

@ -160,7 +160,7 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, WhenIsCooperativeDispatchSupportedThenCo
EXPECT_TRUE(isCooperativeDispatchSupported);
}
} else {
EXPECT_TRUE(isCooperativeDispatchSupported);
EXPECT_FALSE(isCooperativeDispatchSupported);
}
}
}

6
shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp
View File

@ -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);