intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 14:02:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove always true variable - ftrSupportsInteger64BitAtomics

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-10-01 15:14:35 +00:00
committed by Compute-Runtime-Automation
parent 1e8309f4c1
commit 165305090b
32 changed files with 60 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -877,10 +877,7 @@ ze_result_t DeviceImp::getKernelProperties(ze_device_module_properties_t *pKerne
return ZE_RESULT_ERROR_UNKNOWN;
}
pKernelProperties->flags = ZE_DEVICE_MODULE_FLAG_FP16;
if (hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS;
}
pKernelProperties->flags = ZE_DEVICE_MODULE_FLAG_FP16 | ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS;
pKernelProperties->fp16flags = defaultFpFlags;
pKernelProperties->fp32flags = defaultFpFlags;

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

@@ -1166,8 +1166,6 @@ HWTEST_F(DeviceTest, givenSetMaxBVHLevelsWhenPassingRaytracingExpStructToGetProp
}
TEST_F(DeviceTest, givenKernelPropertiesStructureWhenKernelPropertiesCalledThenAllPropertiesAreAssigned) {
const auto &hardwareInfo = this->neoDevice->getHardwareInfo();
ze_device_module_properties_t kernelProperties = {};
ze_device_module_properties_t kernelPropertiesBefore = {};
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_module_properties_t));
@@ -1181,9 +1179,7 @@ TEST_F(DeviceTest, givenKernelPropertiesStructureWhenKernelPropertiesCalledThenA
EXPECT_NE(nativeKernelSupportedIdPointerBefore, nativeKernelSupportedIdPointerNow);
EXPECT_TRUE(kernelPropertiesBefore.flags & ZE_DEVICE_MODULE_FLAG_FP16);
if (hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
EXPECT_TRUE(kernelPropertiesBefore.flags & ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS);
}
EXPECT_TRUE(kernelPropertiesBefore.flags & ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS);
EXPECT_NE(kernelPropertiesBefore.maxArgumentsSize, kernelProperties.maxArgumentsSize);
EXPECT_NE(kernelPropertiesBefore.printfBufferSize, kernelProperties.printfBufferSize);
@@ -2433,62 +2429,6 @@ TEST_F(DeviceHasFp64ButNoBitMathTest, givenDeviceWithFp64ButNoBitMathThenReportC
EXPECT_TRUE(kernelProperties.fp32flags & ZE_DEVICE_FP_FLAG_FMA);
}
struct DeviceHasNo64BitAtomicTest : public ::testing::Test {
void SetUp() override {
HardwareInfo nonFp64Device = *defaultHwInfo;
nonFp64Device.capabilityTable.ftrSupportsInteger64BitAtomics = false;
neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&nonFp64Device, rootDeviceIndex);
NEO::DeviceVector devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
driverHandle->initialize(std::move(devices));
device = driverHandle->devices[rootDeviceIndex];
}
std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
NEO::Device *neoDevice = nullptr;
L0::Device *device = nullptr;
const uint32_t rootDeviceIndex = 0u;
};
TEST_F(DeviceHasNo64BitAtomicTest, givenDeviceWithNoSupportForInteger64BitAtomicsThenFlagsAreSetCorrectly) {
ze_device_module_properties_t kernelProperties = {};
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_module_properties_t));
kernelProperties.pNext = nullptr;
device->getKernelProperties(&kernelProperties);
EXPECT_TRUE(kernelProperties.flags & ZE_DEVICE_MODULE_FLAG_FP16);
EXPECT_FALSE(kernelProperties.flags & ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS);
}
struct DeviceHas64BitAtomicTest : public ::testing::Test {
void SetUp() override {
HardwareInfo nonFp64Device = *defaultHwInfo;
nonFp64Device.capabilityTable.ftrSupportsInteger64BitAtomics = true;
neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&nonFp64Device, rootDeviceIndex);
NEO::DeviceVector devices;
devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
driverHandle->initialize(std::move(devices));
device = driverHandle->devices[rootDeviceIndex];
}
std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
NEO::Device *neoDevice = nullptr;
L0::Device *device = nullptr;
const uint32_t rootDeviceIndex = 0u;
};
TEST_F(DeviceHas64BitAtomicTest, givenDeviceWithSupportForInteger64BitAtomicsThenFlagsAreSetCorrectly) {
ze_device_module_properties_t kernelProperties = {};
memset(&kernelProperties, std::numeric_limits<int>::max(), sizeof(ze_device_module_properties_t));
kernelProperties.pNext = nullptr;
device->getKernelProperties(&kernelProperties);
EXPECT_TRUE(kernelProperties.flags & ZE_DEVICE_MODULE_FLAG_FP16);
EXPECT_TRUE(kernelProperties.flags & ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS);
}
struct MockMemoryManagerMultiDevice : public MemoryManagerMock {
MockMemoryManagerMultiDevice(NEO::ExecutionEnvironment &executionEnvironment) : MemoryManagerMock(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment)) {}

106
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@@ -688,13 +688,8 @@ TEST_F(DeviceGetCapsTest, WhenCheckingFp64ThenResultIsConsistentWithHardwareCapa
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
const auto &caps = device->getDeviceInfo();
if (hwInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
EXPECT_TRUE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_base_atomics "));
EXPECT_TRUE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_extended_atomics "));
} else {
EXPECT_FALSE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_base_atomics "));
EXPECT_FALSE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_extended_atomics "));
}
EXPECT_TRUE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_base_atomics "));
EXPECT_TRUE(hasSubstr(caps.deviceExtensions, "cl_khr_int64_extended_atomics "));
}
TEST_F(DeviceGetCapsTest, WhenDeviceDoesNotSupportOcl21FeaturesThenDeviceEnqueueAndPipeAreNotSupported) {
@@ -949,62 +944,59 @@ TEST_F(DeviceGetCapsTest, givenFp64SupportForcedWhenCheckingFp64SupportThenFp64I
auto hwInfo = *defaultHwInfo;
for (auto isFp64SupportedByHw : ::testing::Bool()) {
for (auto isInteger64BitAtomicsSupportedByHw : ::testing::Bool()) {
hwInfo.capabilityTable.ftrSupportsInteger64BitAtomics = isInteger64BitAtomicsSupportedByHw;
hwInfo.capabilityTable.ftrSupportsFP64 = isFp64SupportedByHw;
hwInfo.capabilityTable.ftrSupports64BitMath = isFp64SupportedByHw;
hwInfo.capabilityTable.ftrSupportsFP64 = isFp64SupportedByHw;
hwInfo.capabilityTable.ftrSupports64BitMath = isFp64SupportedByHw;
for (auto overrideDefaultFP64Settings : overrideDefaultFP64SettingsValues) {
debugManager.flags.OverrideDefaultFP64Settings.set(overrideDefaultFP64Settings);
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto &caps = pClDevice->getDeviceInfo();
std::string extensionString = pClDevice->getDeviceInfo().deviceExtensions;
for (auto overrideDefaultFP64Settings : overrideDefaultFP64SettingsValues) {
debugManager.flags.OverrideDefaultFP64Settings.set(overrideDefaultFP64Settings);
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto &caps = pClDevice->getDeviceInfo();
std::string extensionString = pClDevice->getDeviceInfo().deviceExtensions;
size_t fp64FeaturesCount = 0;
for (auto &openclCFeature : caps.openclCFeatures) {
if (0 == strcmp(openclCFeature.name, "__opencl_c_fp64")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_global_atomic_add")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_local_atomic_add")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_global_atomic_min_max")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_local_atomic_min_max")) {
fp64FeaturesCount++;
}
size_t fp64FeaturesCount = 0;
for (auto &openclCFeature : caps.openclCFeatures) {
if (0 == strcmp(openclCFeature.name, "__opencl_c_fp64")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_global_atomic_add")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_local_atomic_add")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_global_atomic_min_max")) {
fp64FeaturesCount++;
}
if (0 == strcmp(openclCFeature.name, "__opencl_c_ext_fp64_local_atomic_min_max")) {
fp64FeaturesCount++;
}
}
bool expectedFp64Support = ((overrideDefaultFP64Settings == -1) ? isFp64SupportedByHw : overrideDefaultFP64Settings);
if (expectedFp64Support) {
const size_t expectedFp64FeaturesCount = hwInfo.capabilityTable.supportsOcl21Features ? 5u : 1u;
EXPECT_NE(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));
EXPECT_NE(0u, caps.doubleFpConfig);
if (hwInfo.capabilityTable.supportsOcl21Features) {
const cl_device_fp_atomic_capabilities_ext expectedFpCaps = static_cast<cl_device_fp_atomic_capabilities_ext>(CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT | CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT |
CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT);
EXPECT_EQ(expectedFpCaps, caps.doubleFpAtomicCapabilities);
} else {
const cl_device_fp_atomic_capabilities_ext expectedFpCaps = static_cast<cl_device_fp_atomic_capabilities_ext>(CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT);
EXPECT_EQ(expectedFpCaps, caps.doubleFpAtomicCapabilities);
}
EXPECT_EQ(expectedFp64FeaturesCount, fp64FeaturesCount);
EXPECT_NE(0u, caps.nativeVectorWidthDouble);
EXPECT_NE(0u, caps.preferredVectorWidthDouble);
EXPECT_TRUE(isValueSet(caps.singleFpConfig, CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT));
bool expectedFp64Support = ((overrideDefaultFP64Settings == -1) ? isFp64SupportedByHw : overrideDefaultFP64Settings);
if (expectedFp64Support) {
const size_t expectedFp64FeaturesCount = hwInfo.capabilityTable.supportsOcl21Features ? 5u : 1u;
EXPECT_NE(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));
EXPECT_NE(0u, caps.doubleFpConfig);
if (hwInfo.capabilityTable.supportsOcl21Features) {
const cl_device_fp_atomic_capabilities_ext expectedFpCaps = static_cast<cl_device_fp_atomic_capabilities_ext>(CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT | CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT |
CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT);
EXPECT_EQ(expectedFpCaps, caps.doubleFpAtomicCapabilities);
} else {
EXPECT_EQ(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));
EXPECT_EQ(0u, caps.doubleFpConfig);
EXPECT_EQ(0u, caps.doubleFpAtomicCapabilities);
EXPECT_EQ(0u, fp64FeaturesCount);
EXPECT_EQ(0u, caps.nativeVectorWidthDouble);
EXPECT_EQ(0u, caps.preferredVectorWidthDouble);
EXPECT_FALSE(isValueSet(caps.singleFpConfig, CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT));
const cl_device_fp_atomic_capabilities_ext expectedFpCaps = static_cast<cl_device_fp_atomic_capabilities_ext>(CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT | CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT);
EXPECT_EQ(expectedFpCaps, caps.doubleFpAtomicCapabilities);
}
EXPECT_EQ(expectedFp64FeaturesCount, fp64FeaturesCount);
EXPECT_NE(0u, caps.nativeVectorWidthDouble);
EXPECT_NE(0u, caps.preferredVectorWidthDouble);
EXPECT_TRUE(isValueSet(caps.singleFpConfig, CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT));
} else {
EXPECT_EQ(std::string::npos, extensionString.find(std::string("cl_khr_fp64")));
EXPECT_EQ(0u, caps.doubleFpConfig);
EXPECT_EQ(0u, caps.doubleFpAtomicCapabilities);
EXPECT_EQ(0u, fp64FeaturesCount);
EXPECT_EQ(0u, caps.nativeVectorWidthDouble);
EXPECT_EQ(0u, caps.preferredVectorWidthDouble);
EXPECT_FALSE(isValueSet(caps.singleFpConfig, CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT));
}
}
}

9
opencl/test/unit_test/platform/platform_tests.cpp
View File

@@ -323,13 +323,8 @@ TEST_F(PlatformTest, givenFtrSupportAtomicsWhenCreateExtentionsListThenGetMatchi
getOpenclCFeaturesList(*hwInfo, features, *compilerProductHelper.get(), releaseHelper.get());
std::string compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(extensionsList.c_str(), features);
if (hwInfo->capabilityTable.ftrSupportsInteger64BitAtomics) {
EXPECT_TRUE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_base_atomics")));
EXPECT_TRUE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_extended_atomics")));
} else {
EXPECT_FALSE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_base_atomics")));
EXPECT_FALSE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_extended_atomics")));
}
EXPECT_TRUE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_base_atomics")));
EXPECT_TRUE(hasSubstr(compilerExtensions, std::string("cl_khr_int64_extended_atomics")));
}
TEST_F(PlatformTest, givenSupportedMediaBlockAndClVersion21WhenCreateExtentionsListThenDeviceReportsSpritvMediaBlockIoExtension) {

1
shared/source/gen12lp/hw_info_adln.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable ADLN::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

1
shared/source/gen12lp/hw_info_adlp.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable ADLP::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

1
shared/source/gen12lp/hw_info_adls.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable ADLS::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

1
shared/source/gen12lp/hw_info_dg1.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable DG1::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

1
shared/source/gen12lp/hw_info_rkl.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable RKL::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

1
shared/source/gen12lp/hw_info_tgllp.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable TGLLP::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = false,

9
shared/source/helpers/compiler_product_helper_base.inl
View File

@@ -88,7 +88,9 @@ std::string CompilerProductHelperHw<gfxProduct>::getDeviceExtensions(const Hardw
"cl_khr_expect_assume "
"cl_khr_extended_bit_ops "
"cl_khr_suggested_local_work_size "
"cl_intel_split_work_group_barrier ";
"cl_intel_split_work_group_barrier "
"cl_khr_int64_base_atomics "
"cl_khr_int64_extended_atomics ";
auto supportsFp64 = hwInfo.capabilityTable.ftrSupportsFP64;
if (debugManager.flags.OverrideDefaultFP64Settings.get() != -1) {
@@ -139,11 +141,6 @@ std::string CompilerProductHelperHw<gfxProduct>::getDeviceExtensions(const Hardw
extensions += "cl_intel_packed_yuv ";
}
if (hwInfo.capabilityTable.ftrSupportsInteger64BitAtomics) {
extensions += "cl_khr_int64_base_atomics ";
extensions += "cl_khr_int64_extended_atomics ";
}
if (hwInfo.capabilityTable.supportsImages) {
extensions += "cl_khr_image2d_from_buffer ";
extensions += "cl_khr_depth_images ";

1
shared/source/helpers/hw_info.h
View File

@@ -37,7 +37,6 @@ struct RuntimeCapabilityTable {
uint32_t timestampValidBits;
uint32_t kernelTimestampValidBits;
bool blitterOperationsSupported;
bool ftrSupportsInteger64BitAtomics;
bool ftrSupportsFP64;
bool ftrSupportsFP64Emulation;
bool ftrSupports64BitMath;

1
shared/source/xe2_hpg_core/hw_info_bmg.cpp
View File

@@ -53,7 +53,6 @@ const RuntimeCapabilityTable BMG::capabilityTable{
.timestampValidBits = 64,
.kernelTimestampValidBits = 64,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

1
shared/source/xe2_hpg_core/hw_info_lnl.cpp
View File

@@ -51,7 +51,6 @@ const RuntimeCapabilityTable LNL::capabilityTable{
.timestampValidBits = 64,
.kernelTimestampValidBits = 64,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

1
shared/source/xe3_core/hw_info_ptl.cpp
View File

@@ -52,7 +52,6 @@ const RuntimeCapabilityTable PTL::capabilityTable{
.timestampValidBits = 64,
.kernelTimestampValidBits = 64,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

1
shared/source/xe_hpc_core/hw_info_pvc.cpp
View File

@@ -63,7 +63,6 @@ const RuntimeCapabilityTable PVC::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

1
shared/source/xe_hpg_core/hw_info_arl.cpp
View File

@@ -48,7 +48,6 @@ const RuntimeCapabilityTable ARL::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

1
shared/source/xe_hpg_core/hw_info_dg2.cpp
View File

@@ -54,7 +54,6 @@ const RuntimeCapabilityTable DG2::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = false,
.ftrSupportsFP64Emulation = true,
.ftrSupports64BitMath = true,

1
shared/source/xe_hpg_core/hw_info_mtl.cpp
View File

@@ -50,7 +50,6 @@ const RuntimeCapabilityTable MTL::capabilityTable{
.timestampValidBits = 36u,
.kernelTimestampValidBits = 32u,
.blitterOperationsSupported = false,
.ftrSupportsInteger64BitAtomics = true,
.ftrSupportsFP64 = true,
.ftrSupportsFP64Emulation = false,
.ftrSupports64BitMath = true,

5
shared/test/unit_test/gen12lp/adln/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2022-2023 Intel Corporation
# Copyright (C) 2022-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -11,9 +11,8 @@ if(TESTS_ADLN)
target_sources(neo_shared_tests PRIVATE
${NEO_CORE_tests_gen12lp_adln_excludes}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_adln.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_product_helper_adln.cpp
)
add_subdirectories()
endif()
endif()

21
shared/test/unit_test/gen12lp/adln/test_device_caps_adln.cpp
View File

@@ -1,21 +0,0 @@
/*
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/gen12lp/hw_cmds_adln.h"
#include "shared/source/gen12lp/hw_info_adln.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using AdlnUsDeviceIdTest = Test<DeviceFixture>;
ADLNTEST_F(AdlnUsDeviceIdTest, givenAdlnWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}

3
shared/test/unit_test/gen12lp/adlp/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2021-2023 Intel Corporation
# Copyright (C) 2021-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -13,7 +13,6 @@ if(TESTS_ADLP)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_tests_adlp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/preamble_helper_tests_adlp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_adlp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_product_helper_adlp.cpp
)

21
shared/test/unit_test/gen12lp/adlp/test_device_caps_adlp.cpp
View File

@@ -1,21 +0,0 @@
/*
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/gen12lp/hw_cmds_adlp.h"
#include "shared/source/gen12lp/hw_info_adlp.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using AdlpUsDeviceIdTest = Test<DeviceFixture>;
ADLPTEST_F(AdlpUsDeviceIdTest, givenADLPWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}

3
shared/test/unit_test/gen12lp/adls/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2021-2023 Intel Corporation
# Copyright (C) 2021-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -11,7 +11,6 @@ if(TESTS_ADLS)
target_sources(neo_shared_tests PRIVATE
${NEO_CORE_tests_gen12lp_adls_excludes}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_adls.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_product_helper_adls.cpp
)

21
shared/test/unit_test/gen12lp/adls/test_device_caps_adls.cpp
View File

@@ -1,21 +0,0 @@
/*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/gen12lp/hw_cmds_adls.h"
#include "shared/source/gen12lp/hw_info_adls.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using AdlsUsDeviceIdTest = Test<DeviceFixture>;
ADLSTEST_F(AdlsUsDeviceIdTest, givenAdlsWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}

4
shared/test/unit_test/gen12lp/dg1/test_device_caps_dg1.cpp
View File

@@ -20,10 +20,6 @@ DG1TEST_F(Dg1DeviceCaps, givenDg1WhenCheckSupportCacheFlushAfterWalkerThenFalse)
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.supportCacheFlushAfterWalker);
}
DG1TEST_F(Dg1DeviceCaps, givenDg1WhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
DG1TEST_F(Dg1DeviceCaps, givenDg1WhenCheckGpuAddressSpaceThenReturn47bits) {
EXPECT_EQ(MemoryConstants::max64BitAppAddress, pDevice->getHardwareInfo().capabilityTable.gpuAddressSpace);
}

5
shared/test/unit_test/gen12lp/rkl/test_product_helper_rkl.cpp
View File

@@ -64,11 +64,6 @@ RKLTEST_F(RklHwInfo, givenBoolWhenCallRklHardwareInfoSetupThenFeatureTableAndWor
}
}
RKLTEST_F(RklHwInfo, givenRklWhenCheckFtrSupportsInteger64BitAtomicsThenReturnFalse) {
const HardwareInfo &hardwareInfo = RKL::hwInfo;
EXPECT_TRUE(hardwareInfo.capabilityTable.ftrSupportsInteger64BitAtomics);
}
using RklProductHelper = ProductHelperTest;
RKLTEST_F(RklProductHelper, givenCompilerProductHelperWhenGetProductConfigThenCorrectMatchIsFound) {

4
shared/test/unit_test/gen12lp/test_device_caps_gen12lp.inl
View File

@@ -68,10 +68,6 @@ HWTEST2_F(Gen12LpDeviceCaps, givenTglLpWhenCheckSupportCacheFlushAfterWalkerThen
EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.supportCacheFlushAfterWalker);
}
HWTEST2_F(Gen12LpDeviceCaps, givenGen12lpWhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue, IsTGLLP) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
GEN12LPTEST_F(Gen12LpDeviceCaps, givenGen12LpWhenCheckingCxlTypeThenReturnZero) {
EXPECT_EQ(0u, pDevice->getHardwareInfo().capabilityTable.cxlType);
}

4
shared/test/unit_test/xe2_hpg_core/test_device_caps_xe2_hpg_core.cpp
View File

@@ -16,10 +16,6 @@ using namespace NEO;
using Xe2HpgCoreDeviceCaps = Test<DeviceFixture>;
XE2_HPG_CORETEST_F(Xe2HpgCoreDeviceCaps, givenXe2HpgCoreWhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
XE2_HPG_CORETEST_F(Xe2HpgCoreDeviceCaps, givenXe2HpgCoreWhenCheckingImageSupportThenReturnFalse) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.supportsImages);
}

4
shared/test/unit_test/xe3_core/test_device_caps_xe3_core.cpp
View File

@@ -32,10 +32,6 @@ XE3_CORETEST_F(Xe3CoreDeviceCaps, givenXe3CoreProductWhenCheckingCapabilitiesThe
EXPECT_EQ(64u, pDevice->getHardwareInfo().capabilityTable.timestampValidBits);
}
XE3_CORETEST_F(Xe3CoreDeviceCaps, givenXe3CoreWhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
XE3_CORETEST_F(Xe3CoreDeviceCaps, givenXe3CoreWhenCheckingMediaBlockSupportThenReturnFalse) {
EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.supportsMediaBlock);
}

4
shared/test/unit_test/xe_hpc_core/test_device_caps_xe_hpc_core.cpp
View File

@@ -17,10 +17,6 @@ using namespace NEO;
using XeHpcCoreDeviceCaps = Test<DeviceFixture>;
XE_HPC_CORETEST_F(XeHpcCoreDeviceCaps, givenXeHpcCoreWhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
XE_HPC_CORETEST_F(XeHpcCoreDeviceCaps, givenXeHpcCoreWhenCheckingImageSupportThenReturnFalse) {
EXPECT_FALSE(pDevice->getHardwareInfo().capabilityTable.supportsImages);
}

4
shared/test/unit_test/xe_hpg_core/test_device_caps_xe_hpg_core.cpp
View File

@@ -17,10 +17,6 @@ using namespace NEO;
using XeHpgCoreDeviceCaps = Test<DeviceFixture>;
XE_HPG_CORETEST_F(XeHpgCoreDeviceCaps, givenXeHpgCoreWhenCheckFtrSupportsInteger64BitAtomicsThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.ftrSupportsInteger64BitAtomics);
}
XE_HPG_CORETEST_F(XeHpgCoreDeviceCaps, givenXeHpgCoreWhenCheckingImageSupportThenReturnTrue) {
EXPECT_TRUE(pDevice->getHardwareInfo().capabilityTable.supportsImages);
}