Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-20 13:11:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "feature: Add extensions to expose dot product capabilities"

Browse Source 
This reverts commit e988fe66e3.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2023-10-31 04:46:41 +01:00
committed by Compute-Runtime-Automation
parent 060fc40938
commit c9d6615231
23 changed files with 24 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
level_zero/api/core/ze_core_loader.cpp
View File

@ -20,22 +20,13 @@
#include "level_zero/experimental/source/tracing/tracing_module_imp.h"
#include "level_zero/experimental/source/tracing/tracing_residency_imp.h"
#include "level_zero/experimental/source/tracing/tracing_sampler_imp.h"
#include "level_zero/source/inc/ze_intel_gpu.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include "ze_core_all_api_entrypoints.h"
#include "ze_ddi_tables.h"
#include <stdlib.h>
#include <string.h>
inline bool getEnvToBool(const char *name) {
const char *env = getenv(name);
if ((nullptr == env) || (0 == strcmp("0", env)))
return false;
return (0 == strcmp("1", env));
}
ze_gpu_driver_dditable_t driverDdiTable;
ZE_APIEXPORT ze_result_t ZE_APICALL

1
level_zero/api/sysman/ze_sysman_loader.cpp
View File

@ -5,6 +5,7 @@
*
*/
#include "level_zero/source/inc/ze_intel_gpu.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include <level_zero/zes_api.h>

1
level_zero/api/tools/ze_tools_loader.cpp
View File

@ -7,6 +7,7 @@
#include "level_zero/api/driver_experimental/tracing/zet_tracing.h"
#include "level_zero/api/extensions/public/ze_exp_ext.h"
#include "level_zero/source/inc/ze_intel_gpu.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
#include <level_zero/zes_api.h>

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

@ -53,7 +53,6 @@
#include "level_zero/core/source/printf_handler/printf_handler.h"
#include "level_zero/core/source/rtas/rtas.h"
#include "level_zero/core/source/sampler/sampler.h"
#include "level_zero/include/ze_intel_gpu.h"
#include "level_zero/tools/source/debug/debug_session.h"
#include "level_zero/tools/source/debug/debug_session_imp.h"
#include "level_zero/tools/source/metrics/metric.h"
@ -785,17 +784,6 @@ ze_result_t DeviceImp::getKernelProperties(ze_device_module_properties_t *pKerne
rtProperties->flags = 0;
rtProperties->maxBVHLevels = 0;
}
} else if (extendedProperties->stype == ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES) {
ze_intel_device_module_dp_exp_properties_t *dpProperties =
reinterpret_cast<ze_intel_device_module_dp_exp_properties_t *>(extendedProperties);
dpProperties->flags = 0u;
if (productHelper.isPlatformDp4aSupported()) {
dpProperties->flags |= ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A;
}
if (productHelper.isPlatformDpasSupported()) {
dpProperties->flags |= ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS;
}
}
getExtendedDeviceModuleProperties(extendedProperties);

6
level_zero/core/source/driver/driver_handle_imp.h
View File

@ -14,7 +14,6 @@
#include "level_zero/api/extensions/public/ze_exp_ext.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/get_extension_function_lookup_map.h"
#include "level_zero/include/ze_intel_gpu.h"
#include <map>
#include <mutex>
@ -157,10 +156,7 @@ struct DriverHandleImp : public DriverHandle {
{ZE_IMAGE_VIEW_EXT_NAME, ZE_IMAGE_VIEW_EXP_VERSION_CURRENT},
{ZE_IMAGE_VIEW_PLANAR_EXT_NAME, ZE_IMAGE_VIEW_PLANAR_EXP_VERSION_CURRENT},
{ZE_EVENT_QUERY_KERNEL_TIMESTAMPS_EXT_NAME, ZE_EVENT_QUERY_KERNEL_TIMESTAMPS_EXT_VERSION_CURRENT},
{ZE_RTAS_BUILDER_EXP_NAME, ZE_RTAS_BUILDER_EXP_VERSION_CURRENT},
// Driver experimental extensions
{ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME, ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_CURRENT}};
{ZE_RTAS_BUILDER_EXP_NAME, ZE_RTAS_BUILDER_EXP_VERSION_CURRENT}};
uint64_t uuidTimestamp = 0u;

1
level_zero/core/test/black_box_tests/CMakeLists.txt
View File

@ -37,7 +37,6 @@ set(TEST_TARGETS
zello_bindless_kernel
zello_commandlist_immediate
zello_copy
zello_dp_support
zello_copy_fence
zello_copy_image
zello_copy_kernel_printf

50
level_zero/core/test/black_box_tests/zello_dp_support.cpp
View File

@ -1,50 +0,0 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "../../../include/ze_intel_gpu.h"
#include "zello_common.h"
#include <cstring>
#include <iomanip>
int main(int argc, char *argv[]) {
const std::string blackBoxName = "Zello DP Support";
verbose = isVerbose(argc, argv);
bool aubMode = isAubMode(argc, argv);
ze_context_handle_t context = {};
ze_driver_handle_t driverHandle = {};
auto devices = zelloInitContextAndGetDevices(context, driverHandle);
auto device = devices[0];
bool outputValidationSuccessful = true;
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
SUCCESS_OR_TERMINATE(zeDeviceGetProperties(device, &deviceProperties));
printDeviceProperties(deviceProperties);
// Gather Dot Product (DP) support from driver
ze_device_module_properties_t deviceModProps = {ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES};
ze_intel_device_module_dp_exp_properties_t moduleDpProps = {ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES};
deviceModProps.pNext = &moduleDpProps;
SUCCESS_OR_TERMINATE(zeDeviceGetModuleProperties(device, &deviceModProps));
if (moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A) {
printf("DP4A supported\n");
}
if (moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS) {
printf("DPAS supported\n");
}
SUCCESS_OR_TERMINATE(zeContextDestroy(context));
printResult(aubMode, outputValidationSuccessful, blackBoxName);
outputValidationSuccessful = aubMode ? true : outputValidationSuccessful;
return (outputValidationSuccessful ? 0 : 1);
}

16
level_zero/core/test/unit_tests/gen12lp/test_device_gen12lp.cpp
View File

@ -10,7 +10,6 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/include/ze_intel_gpu.h"
namespace L0 {
namespace ult {
@ -26,21 +25,6 @@ HWTEST2_F(DeviceFixtureGen12LP, GivenTargetGen12LPaWhenGettingMemoryPropertiesTh
EXPECT_EQ(0u, memProperties.maxClockRate);
}
HWTEST2_F(DeviceFixtureGen12LP, GivenTargetGen12LPWhenGettingDpSupportThenReturnsTrue, IsXeLpg) {
ze_device_module_properties_t deviceModProps = {ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES};
ze_intel_device_module_dp_exp_properties_t moduleDpProps = {ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES};
moduleDpProps.flags = 0u;
deviceModProps.pNext = &moduleDpProps;
ze_result_t res = device->getKernelProperties(&deviceModProps);
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
bool dp4a = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A;
bool dpas = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS;
EXPECT_TRUE(dp4a);
EXPECT_TRUE(dpas);
}
using CommandQueueGroupTest = Test<DeviceFixture>;
HWTEST2_F(CommandQueueGroupTest,

18
level_zero/core/test/unit_tests/gen9/test_device_gen9.cpp
View File

@ -9,7 +9,6 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/include/ze_intel_gpu.h"
namespace L0 {
namespace ult {
@ -26,23 +25,6 @@ HWTEST2_F(DevicePropertyTest, givenReturnedDevicePropertiesThenExpectedPropertie
EXPECT_EQ(ZE_DEVICE_PROPERTY_FLAG_INTEGRATED, deviceProps.flags & ZE_DEVICE_PROPERTY_FLAG_INTEGRATED);
}
using DeviceTestGen9 = Test<DeviceFixture>;
HWTEST2_F(DeviceTestGen9, GivenTargetGen9WhenGettingDpSupportThenReturnsFalseAndFlagsSetCorrectly, IsAtMostGen9) {
ze_device_module_properties_t deviceModProps = {ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES};
ze_intel_device_module_dp_exp_properties_t moduleDpProps = {ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES};
moduleDpProps.flags = 0u;
deviceModProps.pNext = &moduleDpProps;
ze_result_t res = device->getKernelProperties(&deviceModProps);
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
bool dp4a = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A;
bool dpas = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS;
EXPECT_FALSE(dp4a);
EXPECT_FALSE(dpas);
}
using CommandQueueGroupTest = Test<DeviceFixture>;
HWTEST2_F(CommandQueueGroupTest, givenCommandQueuePropertiesCallThenCorrectNumberOfGroupsIsReturned, IsGen9) {

16
level_zero/core/test/unit_tests/xe_hpc_core/test_device_xe_hpc_core.cpp
View File

@ -16,7 +16,6 @@
#include "level_zero/core/source/cmdqueue/cmdqueue.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/include/ze_intel_gpu.h"
namespace L0 {
namespace ult {
@ -91,21 +90,6 @@ HWTEST2_F(DeviceTestXeHpc, givenXeHpcBStepWhenCreatingMultiTileDeviceThenExpectI
delete device;
}
HWTEST2_F(DeviceTestXeHpc, GivenTargetXeHPCWhenGettingDpSupportThenReturnsTrue, IsXeHpcCore) {
ze_device_module_properties_t deviceModProps = {ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES};
ze_intel_device_module_dp_exp_properties_t moduleDpProps = {ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES};
moduleDpProps.flags = 0u;
deviceModProps.pNext = &moduleDpProps;
ze_result_t res = device->getKernelProperties(&deviceModProps);
EXPECT_EQ(res, ZE_RESULT_SUCCESS);
bool dp4a = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A;
bool dpas = moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS;
EXPECT_TRUE(dp4a);
EXPECT_TRUE(dpas);
}
using MultiDeviceCommandQueueGroupWithNineCopyEnginesTest = Test<SingleRootMultiSubDeviceFixtureWithImplicitScaling<9, 1>>;
HWTEST2_F(MultiDeviceCommandQueueGroupWithNineCopyEnginesTest, givenMainAndLinkCopyEngineSupportAndCCSAndImplicitScalingThenExpectedQueueGroupsAreReturned, IsXeHpcCore) {

73
level_zero/doc/experimental_extensions/MODULE_DP_SUPPORT.md
View File

@ -1,73 +0,0 @@
<!---
Copyright (C) 2023 Intel Corporation
SPDX-License-Identifier: MIT
-->
# Device Module Dot Product Properties Extension
* [Overview](#Overview)
* [Definitions](#Definitions)
* [Known Issues and Limitations](#Known-Issues-and-Limitations)
# Overview
Users often need information regarding Dot Product (DP) support available in platform prior to adding reliable GPU support. This extension provides a new property to gather the required platform support information from driver.
# Definitions
## Interfaces
```cpp
///////////////////////////////////////////////////////////////////////////////
/// @brief Supported Dot Product flags
typedef uint32_t ze_intel_device_module_dp_exp_flags_t;
typedef enum _ze_intel_device_module_dp_exp_flag_t {
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A = ZE_BIT(0), ///< Supports DP4A operation
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS = ZE_BIT(1), ///< Supports DPAS operation
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_FORCE_UINT32 = 0x7fffffff
} ze_intel_device_module_dp_exp_flag_t;
///////////////////////////////////////////////////////////////////////////////
#define ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES (ze_structure_type_t)0x00030013
///////////////////////////////////////////////////////////////////////////////
/// @brief Device Module dot product properties queried using
/// ::zeDeviceGetModuleProperties
///
/// @details
/// - This structure may be passed to ::zeDeviceGetModuleProperties, via
/// `pNext` member of ::ze_device_module_properties_t.
/// @brief Device module dot product properties
typedef struct _ze_intel_device_module_dp_exp_properties_t {
ze_structure_type_t stype = ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES; ///< [in] type of this structure
void *pNext; ///< [in,out][optional] must be null or a pointer to an extension-specific
///< structure (i.e. contains sType and pNext).
ze_intel_device_module_dp_exp_flags_t flags; ///< [out] 0 (none) or a valid combination of ::ze_intel_device_module_dp_flag_t
} ze_intel_device_module_dp_exp_properties_t;
```
## Programming example
```cpp
ze_device_module_properties_t deviceModProps = {ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES};
ze_intel_device_module_dp_exp_properties_t moduleDpProps = {ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES};
deviceModProps.pNext = &moduleDpProps;
SUCCESS_OR_TERMINATE(zeDeviceGetModuleProperties(device, &deviceModProps));
if (moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A) {
printf("DP4A supported\n");
}
if (moduleDpProps.flags & ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS) {
printf("DPAS supported\n");
}
```
# Known Issues and Limitations

69
level_zero/include/ze_intel_gpu.h
View File

@ -1,69 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#ifndef _ZE_INTEL_GPU_H
#define _ZE_INTEL_GPU_H
#include <level_zero/ze_api.h>
#if defined(__cplusplus)
#pragma once
extern "C" {
#endif
#include <stdint.h>
#define ZE_INTEL_GPU_VERSION_MAJOR 0
#define ZE_INTEL_GPU_VERSION_MINOR 1
///////////////////////////////////////////////////////////////////////////////
#ifndef ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME
/// @brief Module DP properties driver extension name
#define ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME "ZE_intel_experimental_device_module_dp_properties"
#endif // ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME
///////////////////////////////////////////////////////////////////////////////
/// @brief Module DP properties driver extension Version(s)
typedef enum _ze_intel_device_module_dp_properties_exp_version_t {
ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0), ///< version 1.0
ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
} ze_intel_device_module_dp_properties_exp_version_t;
///////////////////////////////////////////////////////////////////////////////
/// @brief Supported Dot Product flags
typedef uint32_t ze_intel_device_module_dp_exp_flags_t;
typedef enum _ze_intel_device_module_dp_exp_flag_t {
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A = ZE_BIT(0), ///< Supports DP4A operation
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS = ZE_BIT(1), ///< Supports DPAS operation
ZE_INTEL_DEVICE_MODULE_EXP_FLAG_FORCE_UINT32 = 0x7fffffff
} ze_intel_device_module_dp_exp_flag_t;
///////////////////////////////////////////////////////////////////////////////
#define ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES (ze_structure_type_t)0x00030013
///////////////////////////////////////////////////////////////////////////////
/// @brief Device Module dot product properties queried using
/// ::zeDeviceGetModuleProperties
///
/// @details
/// - This structure may be passed to ::zeDeviceGetModuleProperties, via
/// `pNext` member of ::ze_device_module_properties_t.
/// @brief Device module dot product properties
typedef struct _ze_intel_device_module_dp_exp_properties_t {
ze_structure_type_t stype = ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES; ///< [in] type of this structure
void *pNext; ///< [in,out][optional] must be null or a pointer to an extension-specific
///< structure (i.e. contains sType and pNext).
ze_intel_device_module_dp_exp_flags_t flags; ///< [out] 0 (none) or a valid combination of ::ze_intel_device_module_dp_flag_t
} ze_intel_device_module_dp_exp_properties_t;
#if defined(__cplusplus)
} // extern "C"
#endif
#endif // _ZE_INTEL_GPU_H

19
level_zero/source/inc/ze_intel_gpu.h Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <assert.h>
#include <stdlib.h>
#include <string.h>
inline bool getEnvToBool(const char *name) {
const char *env = getenv(name);
if ((nullptr == env) || (0 == strcmp("0", env)))
return false;
return (0 == strcmp("1", env));
}

1
level_zero/tools/source/metrics/metric.cpp
View File

@ -14,6 +14,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/source/inc/ze_intel_gpu.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"

2
shared/source/os_interface/product_helper.h
View File

@ -166,8 +166,6 @@ class ProductHelper {
virtual bool isTranslationExceptionSupported() const = 0;
virtual uint32_t getMaxNumSamplers() const = 0;
virtual uint32_t getCommandBuffersPreallocatedPerCommandQueue() const = 0;
virtual bool isPlatformDpasSupported() const = 0;
virtual bool isPlatformDp4aSupported() const = 0;
virtual bool getFrontEndPropertyScratchSizeSupport() const = 0;
virtual bool getFrontEndPropertyPrivateScratchSizeSupport() const = 0;

10
shared/source/os_interface/product_helper.inl
View File

@ -166,16 +166,6 @@ uint64_t ProductHelperHw<gfxProduct>::getDeviceMemoryMaxBandWidthInBytesPerSecon
return 0;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isPlatformDpasSupported() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isPlatformDp4aSupported() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isAdditionalStateBaseAddressWARequired(const HardwareInfo &hwInfo) const {
return false;

2
shared/source/os_interface/product_helper_hw.h
View File

@ -120,8 +120,6 @@ class ProductHelperHw : public ProductHelper {
bool isTranslationExceptionSupported() const override;
uint32_t getMaxNumSamplers() const override;
uint32_t getCommandBuffersPreallocatedPerCommandQueue() const override;
bool isPlatformDpasSupported() const override;
bool isPlatformDp4aSupported() const override;
bool getFrontEndPropertyScratchSizeSupport() const override;
bool getFrontEndPropertyPrivateScratchSizeSupport() const override;

10
shared/source/xe_hpc_core/os_agnostic_product_helper_xe_hpc_core.inl
View File

@ -51,14 +51,4 @@ uint32_t ProductHelperHw<gfxProduct>::getMaxNumSamplers() const {
return 0u;
}
template <>
bool ProductHelperHw<gfxProduct>::isPlatformDpasSupported() const {
return true;
}
template <>
bool ProductHelperHw<gfxProduct>::isPlatformDp4aSupported() const {
return true;
}
} // namespace NEO

10
shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl
View File

@ -81,14 +81,4 @@ uint64_t ProductHelperHw<gfxProduct>::overridePatIndex(bool isUncachedType, uint
return patIndex;
}
template <>
bool ProductHelperHw<gfxProduct>::isPlatformDpasSupported() const {
return true;
}
template <>
bool ProductHelperHw<gfxProduct>::isPlatformDp4aSupported() const {
return true;
}
} // namespace NEO

10
shared/test/common/mocks/mock_product_helper.cpp
View File

@ -337,16 +337,6 @@ bool ProductHelperHw<IGFX_UNKNOWN>::isTimestampWaitSupportedForEvents() const {
return false;
}
template <>
bool ProductHelperHw<IGFX_UNKNOWN>::isPlatformDpasSupported() const {
return false;
}
template <>
bool ProductHelperHw<IGFX_UNKNOWN>::isPlatformDp4aSupported() const {
return false;
}
template <>
uint64_t ProductHelperHw<IGFX_UNKNOWN>::getHostMemCapabilitiesValue() const {
return 0;

6
shared/test/unit_test/os_interface/product_helper_tests.cpp
View File

@ -380,12 +380,6 @@ HWTEST2_F(ProductHelperTest, givenProductHelperWhenSettingCapabilityCoherencyFla
EXPECT_TRUE(coherency);
}
HWTEST2_F(ProductHelperTest, givenProductHelperWhenDotProductSupportThenReturnsFalse, IsAtMostGen11) {
EXPECT_FALSE(productHelper->isPlatformDp4aSupported());
EXPECT_FALSE(productHelper->isPlatformDpasSupported());
}
HWTEST_F(ProductHelperTest, givenProductHelperWhenAskedIfAdditionalMediaSamplerProgrammingIsRequiredThenFalseIsReturned) {
EXPECT_FALSE(productHelper->isAdditionalMediaSamplerProgrammingRequired());

10
shared/test/unit_test/xe_hpc_core/gfx_core_helper_xe_hpc_core_tests.cpp
View File

@ -74,16 +74,6 @@ XE_HPC_CORETEST_F(ProductHelperTestXeHpcCore, givenProductHelperWhenCheckTimesta
EXPECT_TRUE(helper.isTimestampWaitSupportedForEvents());
}
XE_HPC_CORETEST_F(ProductHelperTestXeHpcCore, givenProductHelperWhenCheckDpasSupportThenReturnTrue) {
auto &helper = getHelper<ProductHelper>();
EXPECT_TRUE(helper.isPlatformDpasSupported());
}
XE_HPC_CORETEST_F(ProductHelperTestXeHpcCore, givenProductHelperWhenCheckDp4aSupportThenReturnTrue) {
auto &helper = getHelper<ProductHelper>();
EXPECT_TRUE(helper.isPlatformDp4aSupported());
}
XE_HPC_CORETEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCallCopyThroughLockedPtrEnabledThenReturnTrue) {
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
const auto &productHelper = getHelper<ProductHelper>();

8
shared/test/unit_test/xe_hpg_core/os_agnostic_product_helper_xe_lpg_tests.cpp
View File

@ -205,14 +205,6 @@ HWTEST2_F(XeLpgProductHelperTests, givenProductHelperWhenCheckBlitEnqueueAllowed
EXPECT_FALSE(productHelper->blitEnqueueAllowed());
}
HWTEST2_F(XeLpgProductHelperTests, givenProductHelperWhenCheckDpasSupportedThenReturnTrue, IsXeLpg) {
EXPECT_TRUE(productHelper->isPlatformDpasSupported());
}
HWTEST2_F(XeLpgProductHelperTests, givenProductHelperWhenCheckDp4aSupportedThenReturnTrue, IsXeLpg) {
EXPECT_TRUE(productHelper->isPlatformDp4aSupported());
}
HWTEST2_F(XeLpgProductHelperTests, givenProductHelperWhenGetCommandsStreamPropertiesSupportThenExpectCorrectValues, IsXeLpg) {
EXPECT_FALSE(productHelper->getScmPropertyThreadArbitrationPolicySupport());