From 5ca78dfdd1cb6013b4eb152a94e03384d0911e1e Mon Sep 17 00:00:00 2001 From: Aravind Gopalakrishnan Date: Fri, 14 Mar 2025 22:01:17 +0000 Subject: [PATCH] fix: Parse CCS mode setting for non PVC platforms Related-To: GSD-8785 Signed-off-by: Aravind Gopalakrishnan --- .../execution_environment.cpp | 22 +-- .../root_device_environment.cpp | 2 +- .../root_device_environment.h | 2 +- shared/source/os_interface/product_helper.h | 3 + shared/source/os_interface/product_helper.inl | 10 ++ .../source/os_interface/product_helper_hw.h | 1 + .../pvc/os_agnostic_product_helper_pvc.inl | 20 +++ .../unit_test/device/neo_device_tests.cpp | 141 ++++++++++++++++-- 8 files changed, 171 insertions(+), 30 deletions(-) diff --git a/shared/source/execution_environment/execution_environment.cpp b/shared/source/execution_environment/execution_environment.cpp index db6df57324..a824f3ccac 100644 --- a/shared/source/execution_environment/execution_environment.cpp +++ b/shared/source/execution_environment/execution_environment.cpp @@ -371,7 +371,7 @@ void ExecutionEnvironment::adjustCcsCount(const uint32_t rootDeviceIndex) const auto &rootDeviceEnvironment = rootDeviceEnvironments[rootDeviceIndex]; UNRECOVERABLE_IF(!rootDeviceEnvironment); if (rootDeviceNumCcsMap.find(rootDeviceIndex) != rootDeviceNumCcsMap.end()) { - rootDeviceEnvironment->limitNumberOfCcs(rootDeviceNumCcsMap.at(rootDeviceIndex)); + rootDeviceEnvironment->setNumberOfCcs(rootDeviceNumCcsMap.at(rootDeviceIndex)); } else { adjustCcsCountImpl(rootDeviceEnvironment.get()); } @@ -385,21 +385,11 @@ void ExecutionEnvironment::parseCcsCountLimitations() { return; } - const uint32_t numRootDevices = static_cast(rootDeviceEnvironments.size()); - - auto numberOfCcsEntries = StringHelpers::split(numberOfCcsString, ","); - - for (const auto &entry : numberOfCcsEntries) { - auto subEntries = StringHelpers::split(entry, ":"); - uint32_t rootDeviceIndex = StringHelpers::toUint32t(subEntries[0]); - - if (rootDeviceIndex < numRootDevices) { - if (subEntries.size() > 1) { - uint32_t maxCcsCount = StringHelpers::toUint32t(subEntries[1]); - rootDeviceNumCcsMap.insert({rootDeviceIndex, maxCcsCount}); - rootDeviceEnvironments[rootDeviceIndex]->limitNumberOfCcs(maxCcsCount); - } - } + for (auto rootDeviceIndex = 0u; rootDeviceIndex < rootDeviceEnvironments.size(); rootDeviceIndex++) { + auto &rootDeviceEnvironment = rootDeviceEnvironments[rootDeviceIndex]; + UNRECOVERABLE_IF(!rootDeviceEnvironment); + auto &productHelper = rootDeviceEnvironment->getHelper(); + productHelper.parseCcsMode(numberOfCcsString, rootDeviceNumCcsMap, rootDeviceIndex, rootDeviceEnvironment.get()); } } diff --git a/shared/source/execution_environment/root_device_environment.cpp b/shared/source/execution_environment/root_device_environment.cpp index a567893171..a5227da1a0 100644 --- a/shared/source/execution_environment/root_device_environment.cpp +++ b/shared/source/execution_environment/root_device_environment.cpp @@ -225,7 +225,7 @@ BuiltIns *RootDeviceEnvironment::getBuiltIns() { return this->builtins.get(); } -void RootDeviceEnvironment::limitNumberOfCcs(uint32_t numberOfCcs) { +void RootDeviceEnvironment::setNumberOfCcs(uint32_t numberOfCcs) { hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = std::min(hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled, numberOfCcs); limitedNumberOfCcs = true; diff --git a/shared/source/execution_environment/root_device_environment.h b/shared/source/execution_environment/root_device_environment.h index a85bae2b98..b877dedf66 100644 --- a/shared/source/execution_environment/root_device_environment.h +++ b/shared/source/execution_environment/root_device_environment.h @@ -78,7 +78,7 @@ struct RootDeviceEnvironment : NonCopyableClass { BindlessHeapsHelper *getBindlessHeapsHelper() const; AssertHandler *getAssertHandler(Device *neoDevice); void createBindlessHeapsHelper(Device *rootDevice, bool availableDevices); - void limitNumberOfCcs(uint32_t numberOfCcs); + void setNumberOfCcs(uint32_t numberOfCcs); bool isNumberOfCcsLimited() const; void setRcsExposure(); void initProductHelper(); diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h index 6525db5b1d..d37248e5ed 100644 --- a/shared/source/os_interface/product_helper.h +++ b/shared/source/os_interface/product_helper.h @@ -16,6 +16,7 @@ #include #include #include +#include #include namespace aub_stream { @@ -228,6 +229,8 @@ class ProductHelper { virtual void fillPipelineSelectPropertiesSupportStructure(PipelineSelectPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const = 0; virtual void fillStateBaseAddressPropertiesSupportStructure(StateBaseAddressPropertiesSupport &propertiesSupport) const = 0; + virtual void parseCcsMode(std::string ccsModeString, std::unordered_map &rootDeviceNumCcsMap, uint32_t rootDeviceIndex, RootDeviceEnvironment *rootDeviceEnvironment) const = 0; + virtual bool isFusedEuDisabledForDpas(bool kernelHasDpasInstructions, const uint32_t *lws, const uint32_t *groupCount, const HardwareInfo &hwInfo) const = 0; virtual bool isCalculationForDisablingEuFusionWithDpasNeeded(const HardwareInfo &hwInfo) const = 0; virtual uint32_t getNumberOfPartsInTileForConcurrentKernel(uint32_t ccsCount) const = 0; diff --git a/shared/source/os_interface/product_helper.inl b/shared/source/os_interface/product_helper.inl index 257bf18ec7..58a42b5605 100644 --- a/shared/source/os_interface/product_helper.inl +++ b/shared/source/os_interface/product_helper.inl @@ -19,6 +19,7 @@ #include "shared/source/helpers/kernel_helpers.h" #include "shared/source/helpers/local_memory_access_modes.h" #include "shared/source/helpers/preamble.h" +#include "shared/source/helpers/string_helpers.h" #include "shared/source/kernel/kernel_descriptor.h" #include "shared/source/kernel/kernel_properties.h" #include "shared/source/memory_manager/allocation_properties.h" @@ -770,6 +771,15 @@ void ProductHelperHw::fillStateBaseAddressPropertiesSupportStructure propertiesSupport.bindingTablePoolBaseAddress = getStateBaseAddressPropertyBindingTablePoolBaseAddressSupport(); } +template +void ProductHelperHw::parseCcsMode(std::string ccsModeString, std::unordered_map &rootDeviceNumCcsMap, uint32_t rootDeviceIndex, RootDeviceEnvironment *rootDeviceEnvironment) const { + + auto ccsCount = StringHelpers::toUint32t(ccsModeString); + + rootDeviceNumCcsMap.insert({rootDeviceIndex, ccsCount}); + rootDeviceEnvironment->setNumberOfCcs(ccsCount); +} + template bool ProductHelperHw::getPreemptionDbgPropertyPreemptionModeSupport() const { using GfxProduct = typename HwMapper::GfxProduct; diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h index 53cb1ea084..4e092389f4 100644 --- a/shared/source/os_interface/product_helper_hw.h +++ b/shared/source/os_interface/product_helper_hw.h @@ -168,6 +168,7 @@ class ProductHelperHw : public ProductHelper { void fillFrontEndPropertiesSupportStructure(FrontEndPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const override; void fillPipelineSelectPropertiesSupportStructure(PipelineSelectPropertiesSupport &propertiesSupport, const HardwareInfo &hwInfo) const override; void fillStateBaseAddressPropertiesSupportStructure(StateBaseAddressPropertiesSupport &propertiesSupport) const override; + void parseCcsMode(std::string ccsModeString, std::unordered_map &rootDeviceNumCcsMap, uint32_t rootDeviceIndex, RootDeviceEnvironment *rootDeviceEnvironment) const override; bool isFusedEuDisabledForDpas(bool kernelHasDpasInstructions, const uint32_t *lws, const uint32_t *groupCount, const HardwareInfo &hwInfo) const override; bool isCalculationForDisablingEuFusionWithDpasNeeded(const HardwareInfo &hwInfo) const override; diff --git a/shared/source/xe_hpc_core/pvc/os_agnostic_product_helper_pvc.inl b/shared/source/xe_hpc_core/pvc/os_agnostic_product_helper_pvc.inl index 521f372d56..6ea08ad6a9 100644 --- a/shared/source/xe_hpc_core/pvc/os_agnostic_product_helper_pvc.inl +++ b/shared/source/xe_hpc_core/pvc/os_agnostic_product_helper_pvc.inl @@ -7,6 +7,7 @@ #include "shared/source/execution_environment/root_device_environment.h" #include "shared/source/helpers/definitions/indirect_detection_versions.h" +#include "shared/source/helpers/string_helpers.h" #include "shared/source/os_interface/product_helper_xe_hpg_and_xe_hpc.inl" #include "aubstream/product_family.h" @@ -144,6 +145,25 @@ bool ProductHelperHw::isBlitCopyRequiredForLocalMemory(const RootDev return false; } +template <> +void ProductHelperHw::parseCcsMode(std::string ccsModeString, std::unordered_map &rootDeviceNumCcsMap, uint32_t rootDeviceIndex, RootDeviceEnvironment *rootDeviceEnvironment) const { + + auto numberOfCcsEntries = StringHelpers::split(ccsModeString, ","); + + for (const auto &entry : numberOfCcsEntries) { + auto subEntries = StringHelpers::split(entry, ":"); + uint32_t rootDeviceIndexParsed = StringHelpers::toUint32t(subEntries[0]); + + if (rootDeviceIndexParsed == rootDeviceIndex) { + if (subEntries.size() > 1) { + uint32_t maxCcsCount = StringHelpers::toUint32t(subEntries[1]); + rootDeviceNumCcsMap.insert({rootDeviceIndex, maxCcsCount}); + rootDeviceEnvironment->setNumberOfCcs(maxCcsCount); + } + } + } +} + template <> bool ProductHelperHw::isTlbFlushRequired() const { bool tlbFlushRequired = false; diff --git a/shared/test/unit_test/device/neo_device_tests.cpp b/shared/test/unit_test/device/neo_device_tests.cpp index 23948a6223..bf071328cd 100644 --- a/shared/test/unit_test/device/neo_device_tests.cpp +++ b/shared/test/unit_test/device/neo_device_tests.cpp @@ -672,7 +672,59 @@ TEST_F(DeviceTests, givenPreemptionModeWhenOverridePreemptionModeThenProperlySet EXPECT_EQ(newPreemptionMode, device->getPreemptionMode()); } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableDefinedWhenDeviceIsCreatedThenCreateDevicesWithProperCcsCount) { +HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableDefinedForNonPvcWhenDeviceIsCreatedThenCreateDevicesWithProperCcsCount) { + VariableBackup backup(&ultHwConfig); + ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; + DebugManagerStateRestore restorer; + + debugManager.flags.ZEX_NUMBER_OF_CCS.set("1"); + debugManager.flags.SetCommandStreamReceiver.set(1); + + auto hwInfo = *defaultHwInfo; + + MockExecutionEnvironment executionEnvironment(&hwInfo, false, 1); + executionEnvironment.incRefInternal(); + UltDeviceFactory deviceFactory{1, 0, executionEnvironment}; + + { + auto hardwareInfo = executionEnvironment.rootDeviceEnvironments[0]->getMutableHardwareInfo(); + hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled; + + executionEnvironment.adjustCcsCount(); + EXPECT_EQ(std::min(1u, defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled), hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled); + } +} + +HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenDeviceIsCreatedWithEmptyZexNumberOfCssEnvVariableAndHwInfoCcsCountIsModifiedWhenAdjustCcsCountForSpecificDeviceIsInvokedThenVerifyCcsCountIsAdjustedToOne) { + VariableBackup backup(&ultHwConfig); + ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; + DebugManagerStateRestore restorer; + debugManager.flags.SetCommandStreamReceiver.set(1); + debugManager.flags.ZEX_NUMBER_OF_CCS.set(""); + debugManager.flags.SetCommandStreamReceiver.set(1); + + auto hwInfo = *defaultHwInfo; + + MockExecutionEnvironment executionEnvironment(&hwInfo); + executionEnvironment.incRefInternal(); + + UltDeviceFactory deviceFactory{1, 0, executionEnvironment}; + + auto device = deviceFactory.rootDevices[0]; + + auto computeEngineGroupIndex = device->getEngineGroupIndexFromEngineGroupType(EngineGroupType::compute); + auto computeEngineGroup = device->getRegularEngineGroups()[computeEngineGroupIndex]; + EXPECT_EQ(1u, computeEngineGroup.engines.size()); + + auto hardwareInfo = executionEnvironment.rootDeviceEnvironments[0]->getMutableHardwareInfo(); + hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled; + + executionEnvironment.adjustCcsCount(); + EXPECT_EQ(1u, hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled); +} + +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZexNumberOfCssEnvVariableDefinedWhenDeviceIsCreatedThenCreateDevicesWithProperCcsCount) { + VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -718,7 +770,32 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableDefinedW } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenDeviceIsCreatedWithZexNumberOfCssEnvVariableDefinedAndHwInfoCcsCountIsSetToDefaultWhenAdjustCcsCountForSpecificRootDeviceIsInvokedThenVerifyHwInfoCcsCountIsRestored) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenDeviceIsCreatedWithMalformedZexNumberOfCssEnvVariableDefinedAndHwInfoCcsCountIsSetToDefaultWhenAdjustCcsCountForSpecificRootDeviceIsInvokedThenVerifyHwInfoCcsCountIsSet) { + + VariableBackup backup(&ultHwConfig); + ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; + DebugManagerStateRestore restorer; + + debugManager.flags.ZEX_NUMBER_OF_CCS.set("0:"); + debugManager.flags.SetCommandStreamReceiver.set(1); + + auto hwInfo = *defaultHwInfo; + + MockExecutionEnvironment executionEnvironment(&hwInfo, false, 1); + executionEnvironment.incRefInternal(); + + UltDeviceFactory deviceFactory{1, 0, executionEnvironment}; + { + auto hardwareInfo = executionEnvironment.rootDeviceEnvironments[0]->getMutableHardwareInfo(); + hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled; + + executionEnvironment.adjustCcsCount(0); + EXPECT_EQ(1u, hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled); + } +} + +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenDeviceIsCreatedWithZexNumberOfCssEnvVariableDefinedAndHwInfoCcsCountIsSetToDefaultWhenAdjustCcsCountForSpecificRootDeviceIsInvokedThenVerifyHwInfoCcsCountIsRestored) { + VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -731,7 +808,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenDeviceIsCreatedWithZexNumberOfCss MockExecutionEnvironment executionEnvironment(&hwInfo, false, 2); executionEnvironment.incRefInternal(); - UltDeviceFactory deviceFactory{1, 0, executionEnvironment}; + UltDeviceFactory deviceFactory{2, 0, executionEnvironment}; { auto hardwareInfo = executionEnvironment.rootDeviceEnvironments[0]->getMutableHardwareInfo(); hardwareInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled; @@ -749,7 +826,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenDeviceIsCreatedWithZexNumberOfCss } } -HWTEST2_F(DeviceTests, givenDeviceIsCreatedWithAmbiguousZexNumberOfCssEnvVariableAndHwInfoCcsCountIsModifiedWhenAdjustCcsCountForSpecificDeviceIsInvokedThenVerifyCcsCountIsAdjustedToOne, IsPVC) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenDeviceIsCreatedWithAmbiguousZexNumberOfCssEnvVariableAndHwInfoCcsCountIsModifiedWhenAdjustCcsCountForSpecificDeviceIsInvokedThenVerifyCcsCountIsAdjustedToOne) { VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -779,7 +856,8 @@ HWTEST2_F(DeviceTests, givenDeviceIsCreatedWithAmbiguousZexNumberOfCssEnvVariabl } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssAndZeAffinityMaskSetWhenDeviceIsCreatedThenProperNumberOfCcsIsExposed) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZexNumberOfCssAndZeAffinityMaskSetWhenDeviceIsCreatedThenProperNumberOfCcsIsExposed) { + VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -806,7 +884,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssAndZeAffinityMaskSe } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetAndTilesAsDevicesModelThenProperSubDeviceHierarchyMapisSet) { +HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetAndTilesAsDevicesModelForXeHpThenProperSubDeviceHierarchyMapisSet) { std::unordered_map mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "FLAT"}}; VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); VariableBackup backup(&ultHwConfig); @@ -845,7 +923,46 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetAndTilesAsDevice } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetThenProperSubDeviceHierarchyMapIsSet) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZeAffinityMaskSetAndTilesAsDevicesModelThenProperSubDeviceHierarchyMapisSet) { + std::unordered_map mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "FLAT"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + VariableBackup backup(&ultHwConfig); + ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; + DebugManagerStateRestore restorer; + + uint32_t numRootDevices = 4; + uint32_t numSubDevices = 4; + + debugManager.flags.CreateMultipleRootDevices.set(numRootDevices); + debugManager.flags.CreateMultipleSubDevices.set(numSubDevices); + + uint32_t expectedRootDevices = 4; + debugManager.flags.ZE_AFFINITY_MASK.set("0,3,4,1.1,9,15,25"); + + debugManager.flags.SetCommandStreamReceiver.set(1); + + auto hwInfo = *defaultHwInfo; + + MockExecutionEnvironment executionEnvironment(&hwInfo, false, numRootDevices); + executionEnvironment.incRefInternal(); + + auto devices = DeviceFactory::createDevices(executionEnvironment); + EXPECT_EQ(devices.size(), expectedRootDevices); + std::vector expectedRootDeviceIndices = {0, 0, 1, 2}; + std::vector expectedSubDeviceIndices = {0, 3, 0, 1}; + for (uint32_t i = 0u; i < devices.size(); i++) { + std::tuple subDeviceMap; + EXPECT_TRUE(executionEnvironment.getSubDeviceHierarchy(i, &subDeviceMap)); + auto hwRootDeviceIndex = std::get<0>(subDeviceMap); + auto hwSubDeviceIndex = std::get<1>(subDeviceMap); + auto hwSubDevicesCount = std::get<2>(subDeviceMap); + EXPECT_EQ(hwRootDeviceIndex, expectedRootDeviceIndices[i]); + EXPECT_EQ(hwSubDeviceIndex, expectedSubDeviceIndices[i]); + EXPECT_EQ(hwSubDevicesCount, numSubDevices); + } +} + +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZeAffinityMaskSetThenProperSubDeviceHierarchyMapIsSet) { std::unordered_map mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMPOSITE"}}; VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); @@ -885,7 +1002,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetThenProperSubDev } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetWithoutTilesThenProperSubDeviceHierarchyMapisUnset) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZeAffinityMaskSetWithoutTilesThenProperSubDeviceHierarchyMapisUnset) { std::unordered_map mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMPOSITE"}}; VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); @@ -917,7 +1034,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetWithoutTilesThen } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZeAffinityMaskSetWhenAllocateRTDispatchGlobalsIsCalledThenRTDispatchGlobalsIsAllocated) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZeAffinityMaskSetWhenAllocateRTDispatchGlobalsIsCalledThenRTDispatchGlobalsIsAllocated) { std::unordered_map mockableEnvs = {{"ZE_FLAT_DEVICE_HIERARCHY", "COMPOSITE"}}; VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); @@ -975,7 +1092,7 @@ TEST_F(DeviceTests, givenDifferentHierarchiesWithoutSubDevicesThenNumSubDevicesI } } -TEST_F(DeviceTests, givenZeAffinityMaskSetWithDifferentHierarchiesThenNumSubDevicesIsCorrect) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZeAffinityMaskSetWithDifferentHierarchiesThenNumSubDevicesIsCorrect) { VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -1015,7 +1132,7 @@ TEST_F(DeviceTests, givenZeAffinityMaskSetWithDifferentHierarchiesThenNumSubDevi } } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableIsLargerThanNumberOfAvailableCcsCountWhenDeviceIsCreatedThenCreateDevicesWithAvailableCcsCount) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZexNumberOfCssEnvVariableIsLargerThanNumberOfAvailableCcsCountWhenDeviceIsCreatedThenCreateDevicesWithAvailableCcsCount) { VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer; @@ -1037,7 +1154,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableIsLarger EXPECT_EQ(defaultHwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled, computeEngineGroup.engines.size()); } -HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTests, givenZexNumberOfCssEnvVariableSetAmbigouslyWhenDeviceIsCreatedThenDontApplyAnyLimitations) { +HWCMDTEST_F(IGFX_XE_HPC_CORE, DeviceTests, givenZexNumberOfCssEnvVariableSetAmbigouslyWhenDeviceIsCreatedThenDontApplyAnyLimitations) { VariableBackup backup(&ultHwConfig); ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false; DebugManagerStateRestore restorer;