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

fix: using releaseHelper to determine MTP enablement 

Related-To: NEO-12466

Signed-off-by: Andrzej Koska <andrzej.koska@intel.com>
This commit is contained in:
Andrzej Koska 2024-10-01 13:56:05 +00:00 committed by Compute-Runtime-Automation
parent e4be88dff0
commit 6abc5eb1a1
26 changed files with 144 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -36,6 +36,7 @@
#include "shared/source/memory_manager/unified_memory_manager.h"
#include "shared/source/program/kernel_info.h"
#include "shared/source/program/work_size_info.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/source/utilities/arrayref.h"
#include "level_zero/api/driver_experimental/public/zex_module.h"
@ -1036,7 +1037,10 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
auto deviceBitfield = neoDevice->getDeviceBitfield();
const auto &gfxHelper = rootDeviceEnvironment.getHelper<NEO::GfxCoreHelper>();
this->midThreadPreemptionDisallowedForRayTracingKernels = productHelper.isMidThreadPreemptionDisallowedForRayTracingKernels();
auto releaseHelper = neoDevice->getRootDeviceEnvironment().getReleaseHelper();
if (releaseHelper) {
this->midThreadPreemptionDisallowedForRayTracingKernels = releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels();
}
this->heaplessEnabled = rootDeviceEnvironment.getHelper<NEO::CompilerProductHelper>().isHeaplessModeEnabled();
this->localDispatchSupport = productHelper.getSupportedLocalDispatchSizes(hwInfo).size() > 0;

57
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -19,6 +19,7 @@
#include "shared/source/kernel/kernel_descriptor.h"
#include "shared/source/program/kernel_info.h"
#include "shared/source/program/kernel_info_from_patchtokens.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/source/utilities/stackvec.h"
#include "shared/test/common/compiler_interface/linker_mock.h"
#include "shared/test/common/device_binary_format/patchtokens_tests.h"
@ -29,6 +30,7 @@
#include "shared/test/common/mocks/mock_bindless_heaps_helper.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "shared/test/common/mocks/mock_release_helper.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test_checks_shared.h"
@ -104,7 +106,60 @@ TEST_F(KernelInitTest, givenKernelToInitWhenItHasUnknownArgThenUnknowKernelArgHa
kernel->initialize(&desc);
EXPECT_EQ(kernel->kernelArgHandlers[0], &KernelImp::setArgUnknown);
EXPECT_EQ(mockKernelImmData->getDescriptor().payloadMappings.explicitArgs[0].type, NEO::ArgDescriptor::argTUnknown);
EXPECT_EQ(getHelper<ProductHelper>().isMidThreadPreemptionDisallowedForRayTracingKernels(), kernel->isMidThreadPreemptionDisallowedForRayTracingKernels());
auto releaseHelper = neoDevice->getRootDeviceEnvironment().getReleaseHelper();
if (releaseHelper) {
EXPECT_EQ(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels(), kernel->isMidThreadPreemptionDisallowedForRayTracingKernels());
} else {
EXPECT_FALSE(kernel->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}
TEST_F(KernelInitTest, givenKernelToInitAndPreemptionEnabledWhenItHasUnknownArgThenUnknowKernelArgHandlerAssigned) {
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
std::unique_ptr<MockImmutableData> mockKernelImmData =
std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
createModuleFromMockBinary(perHwThreadPrivateMemorySizeRequested, false, mockKernelImmData.get());
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
auto releaseHelper = std::make_unique<MockReleaseHelper>();
releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernelsResult = true;
module.get()->getDevice()->getNEODevice()->getRootDeviceEnvironmentRef().releaseHelper = std::move(releaseHelper);
ze_kernel_desc_t desc = {};
desc.pKernelName = kernelName.c_str();
mockKernelImmData->resizeExplicitArgs(1);
kernel->initialize(&desc);
EXPECT_EQ(kernel->kernelArgHandlers[0], &KernelImp::setArgUnknown);
EXPECT_EQ(mockKernelImmData->getDescriptor().payloadMappings.explicitArgs[0].type, NEO::ArgDescriptor::argTUnknown);
EXPECT_TRUE(kernel->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
TEST_F(KernelInitTest, givenKernelToInitAndPreemptionDisabledWhenItHasUnknownArgThenUnknowKernelArgHandlerAssigned) {
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
std::unique_ptr<MockImmutableData> mockKernelImmData =
std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
createModuleFromMockBinary(perHwThreadPrivateMemorySizeRequested, false, mockKernelImmData.get());
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
auto releaseHelper = std::make_unique<MockReleaseHelper>();
releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernelsResult = false;
module.get()->getDevice()->getNEODevice()->getRootDeviceEnvironmentRef().releaseHelper = std::move(releaseHelper);
ze_kernel_desc_t desc = {};
desc.pKernelName = kernelName.c_str();
mockKernelImmData->resizeExplicitArgs(1);
kernel->initialize(&desc);
EXPECT_EQ(kernel->kernelArgHandlers[0], &KernelImp::setArgUnknown);
EXPECT_EQ(mockKernelImmData->getDescriptor().payloadMappings.explicitArgs[0].type, NEO::ArgDescriptor::argTUnknown);
EXPECT_FALSE(kernel->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
TEST_F(KernelInitTest, givenKernelToInitWhenItHasTooBigPrivateSizeThenOutOfMemoryIsRetutned) {

9
shared/source/command_stream/preemption.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2023 Intel Corporation
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,6 +15,7 @@
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/string.h"
#include "shared/source/kernel/kernel_descriptor.h"
#include "shared/source/release_helper/release_helper.h"
namespace NEO {
@ -83,13 +84,15 @@ PreemptionMode PreemptionHelper::getDefaultPreemptionMode(const HardwareInfo &hw
PreemptionFlags PreemptionHelper::createPreemptionLevelFlags(Device &device, const KernelDescriptor *kernelDescriptor) {
PreemptionFlags flags = {};
auto &productHelper = device.getRootDeviceEnvironment().getHelper<ProductHelper>();
NEO::ReleaseHelper *releaseHelper = device.getRootDeviceEnvironment().getReleaseHelper();
if (kernelDescriptor) {
flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor->kernelAttributes.flags.requiresDisabledMidThreadPreemption;
flags.flags.vmeKernel = kernelDescriptor->kernelAttributes.flags.usesVme;
flags.flags.usesFencesForReadWriteImages = kernelDescriptor->kernelAttributes.flags.usesFencesForReadWriteImages;
flags.flags.disabledMidThreadPreemptionKernel |= kernelDescriptor->kernelAttributes.flags.hasRTCalls && productHelper.isMidThreadPreemptionDisallowedForRayTracingKernels();
if (releaseHelper) {
flags.flags.disabledMidThreadPreemptionKernel |= kernelDescriptor->kernelAttributes.flags.hasRTCalls && releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels();
}
}
flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption;
flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl;

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

@ -177,7 +177,6 @@ class ProductHelper {
virtual bool isPlatformQuerySupported() const = 0;
virtual bool isNonBlockingGpuSubmissionSupported() const = 0;
virtual bool isResolveDependenciesByPipeControlsSupported(const HardwareInfo &hwInfo, bool isOOQ, TaskCountType queueTaskCount, const CommandStreamReceiver &queueCsr) const = 0;
virtual bool isMidThreadPreemptionDisallowedForRayTracingKernels() const = 0;
virtual bool isBufferPoolAllocatorSupported() const = 0;
virtual bool isUsmPoolAllocatorSupported() const = 0;
virtual bool isDeviceUsmAllocationReuseSupported() const = 0;

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

@ -669,11 +669,6 @@ bool ProductHelperHw<gfxProduct>::isResolveDependenciesByPipeControlsSupported(c
return enabled;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
void ProductHelperHw<gfxProduct>::fillScmPropertiesSupportStructureBase(StateComputeModePropertiesSupport &propertiesSupport) const {
propertiesSupport.coherencyRequired = getScmPropertyCoherencyRequiredSupport();

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

@ -120,7 +120,6 @@ class ProductHelperHw : public ProductHelper {
bool isPlatformQuerySupported() const override;
bool isNonBlockingGpuSubmissionSupported() const override;
bool isResolveDependenciesByPipeControlsSupported(const HardwareInfo &hwInfo, bool isOOQ, TaskCountType queueTaskCount, const CommandStreamReceiver &queueCsr) const override;
bool isMidThreadPreemptionDisallowedForRayTracingKernels() const override;
bool isBufferPoolAllocatorSupported() const override;
bool isUsmPoolAllocatorSupported() const override;
bool isDeviceUsmAllocationReuseSupported() const override;

2
shared/source/release_helper/release_helper.h
View File

@ -59,6 +59,7 @@ class ReleaseHelper {
virtual uint32_t getAdditionalFp16Caps() const = 0;
virtual uint32_t getAdditionalExtraCaps() const = 0;
virtual bool isLocalOnlyAllowed() const = 0;
virtual bool isMidThreadPreemptionDisallowedForRayTracingKernels() const = 0;
protected:
ReleaseHelper(HardwareIpVersion hardwareIpVersion) : hardwareIpVersion(hardwareIpVersion) {}
@ -100,6 +101,7 @@ class ReleaseHelperHw : public ReleaseHelper {
uint32_t getAdditionalFp16Caps() const override;
uint32_t getAdditionalExtraCaps() const override;
bool isLocalOnlyAllowed() const override;
bool isMidThreadPreemptionDisallowedForRayTracingKernels() const override;
protected:
ReleaseHelperHw(HardwareIpVersion hardwareIpVersion) : ReleaseHelper(hardwareIpVersion) {}

5
shared/source/release_helper/release_helper_2001.cpp
View File

@ -33,6 +33,11 @@ bool ReleaseHelperHw<release>::isBindlessAddressingDisabled() const {
return false;
}
template <>
bool ReleaseHelperHw<release>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return true;
}
} // namespace NEO
#include "shared/source/release_helper/release_helper_common_xe2_hpg.inl"

5
shared/source/release_helper/release_helper_2004.cpp
View File

@ -43,6 +43,11 @@ bool ReleaseHelperHw<release>::isBindlessAddressingDisabled() const {
return false;
}
template <>
bool ReleaseHelperHw<release>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return true;
}
} // namespace NEO
#include "shared/source/release_helper/release_helper_common_xe2_hpg.inl"

6
shared/source/release_helper/release_helper_base.inl
View File

@ -156,4 +156,10 @@ template <ReleaseType releaseType>
bool ReleaseHelperHw<releaseType>::isLocalOnlyAllowed() const {
return true;
}
template <ReleaseType releaseType>
bool ReleaseHelperHw<releaseType>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return false;
}
} // namespace NEO

5
shared/source/xe2_hpg_core/bmg/os_agnostic_product_helper_bmg.inl
View File

@ -20,11 +20,6 @@ bool ProductHelperHw<gfxProduct>::isResolveDependenciesByPipeControlsSupported(c
return enabled;
}
template <>
bool ProductHelperHw<gfxProduct>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return true;
}
template <>
bool ProductHelperHw<gfxProduct>::isBufferPoolAllocatorSupported() const {
return true;

5
shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl
View File

@ -25,11 +25,6 @@ bool ProductHelperHw<gfxProduct>::isResolveDependenciesByPipeControlsSupported(c
return enabled;
}
template <>
bool ProductHelperHw<gfxProduct>::isMidThreadPreemptionDisallowedForRayTracingKernels() const {
return true;
}
template <>
std::optional<aub_stream::ProductFamily> ProductHelperHw<gfxProduct>::getAubStreamProductFamily() const {
return aub_stream::ProductFamily::Lnl;

1
shared/test/common/mocks/mock_release_helper.h
View File

@ -42,5 +42,6 @@ class MockReleaseHelper : public ReleaseHelper {
ADDMETHOD_CONST_NOBASE(getAdditionalFp16Caps, uint32_t, {}, ());
ADDMETHOD_CONST_NOBASE(getAdditionalExtraCaps, uint32_t, {}, ());
ADDMETHOD_CONST_NOBASE(isLocalOnlyAllowed, bool, {}, ());
ADDMETHOD_CONST_NOBASE(isMidThreadPreemptionDisallowedForRayTracingKernels, bool, false, ());
};
} // namespace NEO

66
shared/test/unit_test/preemption/preemption_tests.cpp
View File

@ -11,6 +11,7 @@
#include "shared/source/memory_manager/allocation_properties.h"
#include "shared/source/memory_manager/os_agnostic_memory_manager.h"
#include "shared/source/os_interface/product_helper_hw.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/dispatch_flags_helper.h"
@ -19,6 +20,7 @@
#include "shared/test/common/mocks/mock_builtins.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "shared/test/common/mocks/mock_release_helper.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/unit_test/fixtures/preemption_fixture.h"
@ -603,35 +605,55 @@ HWTEST_F(MidThreadPreemptionTests, givenKernelWithRayTracingWhenGettingPreemptio
kernelDescriptor.kernelAttributes.flags.hasRTCalls = true;
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_FALSE(flags.flags.disabledMidThreadPreemptionKernel);
NEO::ReleaseHelper *releaseHelper = device->getRootDeviceEnvironment().getReleaseHelper();
if (releaseHelper) {
EXPECT_EQ(flags.flags.disabledMidThreadPreemptionKernel, releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
} else {
EXPECT_FALSE(flags.flags.disabledMidThreadPreemptionKernel);
}
}
class MockProductHelperForRtKernels : public ProductHelperHw<IGFX_UNKNOWN> {
public:
bool isMidThreadPreemptionDisallowedForRayTracingKernels() const override {
return !midThreadPreemptionAllowedForRayTracing;
}
bool midThreadPreemptionAllowedForRayTracing = true;
};
HWTEST_F(MidThreadPreemptionTests, givenKernelWithRayTracingAndMidThreadPreemptionIsDisabledWhenGettingPreemptionFlagsThenMidThreadPreemptionIsDisabled) {
HWTEST_F(MidThreadPreemptionTests, givenKernelWithRayTracingWhenGettingPreemptionFlagsThenMidThreadPreemptionIsEnabledBasedOnProductHelperCapability) {
MockExecutionEnvironment mockExecutionEnvironment{};
RAIIProductHelperFactory<MockProductHelperForRtKernels> productHelperBackup{*mockExecutionEnvironment.rootDeviceEnvironments[0]};
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
KernelDescriptor kernelDescriptor{};
kernelDescriptor.kernelAttributes.flags.hasRTCalls = true;
auto &productHelper = static_cast<MockProductHelperForRtKernels &>(device->getRootDeviceEnvironment().getHelper<ProductHelper>());
{
productHelper.midThreadPreemptionAllowedForRayTracing = true;
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
auto releaseHelper = std::make_unique<MockReleaseHelper>();
releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernelsResult = true;
device->getRootDeviceEnvironmentRef().releaseHelper = std::move(releaseHelper);
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_TRUE(flags.flags.disabledMidThreadPreemptionKernel);
}
HWTEST_F(MidThreadPreemptionTests, givenKernelWithRayTracingAndMidThreadPreemptionIsEnabledWhenGettingPreemptionFlagsThenMidThreadPreemptionIsEnabled) {
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
KernelDescriptor kernelDescriptor{};
kernelDescriptor.kernelAttributes.flags.hasRTCalls = true;
auto releaseHelper = std::make_unique<MockReleaseHelper>();
releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernelsResult = false;
device->getRootDeviceEnvironmentRef().releaseHelper = std::move(releaseHelper);
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_FALSE(flags.flags.disabledMidThreadPreemptionKernel);
}
HWTEST_F(MidThreadPreemptionTests, givenKernelWithRayTracingWhenGettingPreemptionFlagsThenMidThreadPreemptionIsEnabledBasedOnReleaseHelperCapability) {
MockExecutionEnvironment mockExecutionEnvironment{};
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
KernelDescriptor kernelDescriptor{};
kernelDescriptor.kernelAttributes.flags.hasRTCalls = true;
NEO::ReleaseHelper *releaseHelper = device->getRootDeviceEnvironment().getReleaseHelper();
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
if (releaseHelper) {
EXPECT_EQ(flags.flags.disabledMidThreadPreemptionKernel, releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
} else {
EXPECT_FALSE(flags.flags.disabledMidThreadPreemptionKernel);
}
{
productHelper.midThreadPreemptionAllowedForRayTracing = false;
auto flags = PreemptionHelper::createPreemptionLevelFlags(*device, &kernelDescriptor);
EXPECT_TRUE(flags.flags.disabledMidThreadPreemptionKernel);
}
}
}

1
shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp
View File

@ -40,6 +40,7 @@ TEST_F(ReleaseHelper1255Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isGlobalBindlessAllocatorEnabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp
View File

@ -40,6 +40,7 @@ TEST_F(ReleaseHelper1256Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isGlobalBindlessAllocatorEnabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp
View File

@ -40,6 +40,7 @@ TEST_F(ReleaseHelper1257Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isGlobalBindlessAllocatorEnabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_60_tests.cpp
View File

@ -37,6 +37,7 @@ TEST_F(ReleaseHelper1260Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isBindlessAddressingDisabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_61_tests.cpp
View File

@ -36,6 +36,7 @@ TEST_F(ReleaseHelper1261Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isBindlessAddressingDisabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp
View File

@ -41,6 +41,7 @@ TEST_F(ReleaseHelper1270Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isGlobalBindlessAllocatorEnabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp
View File

@ -41,6 +41,7 @@ TEST_F(ReleaseHelper1271Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isGlobalBindlessAllocatorEnabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_12_74_tests.cpp
View File

@ -39,6 +39,7 @@ TEST_F(ReleaseHelper1274Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_TRUE(releaseHelper->isBindlessAddressingDisabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_FALSE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_20_01_tests.cpp
View File

@ -39,6 +39,7 @@ TEST_F(ReleaseHelper2001Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_FALSE(releaseHelper->isBindlessAddressingDisabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_TRUE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

1
shared/test/unit_test/release_helper/release_helper_20_04_tests.cpp
View File

@ -40,6 +40,7 @@ TEST_F(ReleaseHelper2004Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
EXPECT_FALSE(releaseHelper->isBindlessAddressingDisabled());
EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
EXPECT_TRUE(releaseHelper->isRayTracingSupported());
EXPECT_TRUE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
}

3
shared/test/unit_test/xe2_hpg_core/bmg/product_helper_tests_bmg.cpp
View File

@ -11,6 +11,7 @@
#include "shared/source/xe2_hpg_core/hw_cmds_bmg.h"
#include "shared/source/xe2_hpg_core/hw_info_xe2_hpg_core.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/mocks/mock_release_helper.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/unit_test/os_interface/product_helper_tests.h"
@ -34,7 +35,7 @@ BMGTEST_F(BmgProductHelper, givenProductHelperWhenGettingEvictIfNecessaryFlagSup
BMGTEST_F(BmgProductHelper, whenGettingMidThreadPreemptionSupportForRtKernelsThenExpectNoSupport) {
EXPECT_TRUE(productHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
EXPECT_TRUE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
BMGTEST_F(BmgProductHelper, givenBmgProductHelperWhenIsInitBuiltinAsyncSupportedThenReturnFalse) {

3
shared/test/unit_test/xe2_hpg_core/lnl/product_helper_tests_lnl.cpp
View File

@ -14,6 +14,7 @@
#include "shared/source/xe2_hpg_core/hw_info_xe2_hpg_core.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/mocks/mock_release_helper.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/unit_test/os_interface/product_helper_tests.h"
@ -36,7 +37,7 @@ LNLTEST_F(LnlProductHelper, givenProductHelperWhenGettingEvictIfNecessaryFlagSup
LNLTEST_F(LnlProductHelper, whenGettingMidThreadPreemptionSupportForRtKernelsThenExpectNoSupport) {
EXPECT_TRUE(productHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
EXPECT_TRUE(releaseHelper->isMidThreadPreemptionDisallowedForRayTracingKernels());
}
LNLTEST_F(LnlProductHelper, givenProductHelperWhenGetCommandsStreamPropertiesSupportThenExpectCorrectValues) {