Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move L0HwHelper ownership to RootDeviceEnvironment 5/n

Browse Source 
Related-To: NEO-6853
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>

Use RootDeviceEnvironment getHelper<L0CoreHelper> for
- enableFrontEndStateTracking
- enablePipelineSelectStateTracking
- enableStateComputeModeTracking
- enableImmediateCmdListHeapSharing
- platformSupportsCmdListHeapSharing
- platformSupportsStateComputeModeTracking
- platformSupportsFrontEndTracking
- platformSupportsPipelineSelectTracking
This commit is contained in:
Kamil Kopryk
2022-11-18 12:30:40 +00:00
committed by Compute-Runtime-Automation
parent 5c23d05312
commit 08d4e57cb3
16 changed files with 101 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@ -133,14 +133,15 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::initialize(Device *device, NEO
this->flags = flags;
auto &hwInfo = device->getHwInfo();
auto &rootDeviceEnvironment = device->getNEODevice()->getRootDeviceEnvironment();
this->dcFlushSupport = NEO::MemorySynchronizationCommands<GfxFamily>::getDcFlushEnable(true, hwInfo);
this->systolicModeSupport = NEO::PreambleHelper<GfxFamily>::isSystolicModeConfigurable(hwInfo);
this->stateComputeModeTracking = L0HwHelper::enableStateComputeModeTracking(hwInfo);
this->frontEndStateTracking = L0HwHelper::enableFrontEndStateTracking(hwInfo);
this->pipelineSelectStateTracking = L0HwHelper::enablePipelineSelectStateTracking(hwInfo);
this->pipeControlMultiKernelEventSync = L0HwHelper::usePipeControlMultiKernelEventSync(hwInfo);
this->compactL3FlushEventPacket = L0HwHelper::useCompactL3FlushEventPacket(hwInfo);
this->signalAllEventPackets = L0HwHelper::useSignalAllEventPackets(hwInfo);
this->stateComputeModeTracking = L0CoreHelper::enableStateComputeModeTracking(rootDeviceEnvironment);
this->frontEndStateTracking = L0CoreHelper::enableFrontEndStateTracking(rootDeviceEnvironment);
this->pipelineSelectStateTracking = L0CoreHelper::enablePipelineSelectStateTracking(rootDeviceEnvironment);
this->pipeControlMultiKernelEventSync = L0CoreHelper::usePipeControlMultiKernelEventSync(hwInfo);
this->compactL3FlushEventPacket = L0CoreHelper::useCompactL3FlushEventPacket(hwInfo);
this->signalAllEventPackets = L0CoreHelper::useSignalAllEventPackets(hwInfo);
if (device->isImplicitScalingCapable() && !this->internalUsage && !isCopyOnly()) {
this->partitionCount = static_cast<uint32_t>(this->device->getNEODevice()->getDeviceBitfield().count());

4
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@ -139,7 +139,9 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
commandList->isFlushTaskSubmissionEnabled = !!NEO::DebugManager.flags.EnableFlushTaskSubmission.get();
}
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Flush Task for Immediate command list : %s\n", commandList->isFlushTaskSubmissionEnabled ? "Enabled" : "Disabled");
commandList->immediateCmdListHeapSharing = L0HwHelper::enableImmediateCmdListHeapSharing(hwInfo, commandList->isFlushTaskSubmissionEnabled);
auto &rootDeviceEnvironment = device->getNEODevice()->getRootDeviceEnvironment();
commandList->immediateCmdListHeapSharing = L0CoreHelper::enableImmediateCmdListHeapSharing(rootDeviceEnvironment, commandList->isFlushTaskSubmissionEnabled);
}
returnValue = commandList->initialize(device, engineGroupType, desc->flags);
if (returnValue != ZE_RESULT_SUCCESS) {

8
level_zero/core/source/cmdqueue/cmdqueue.cpp
View File

@ -70,10 +70,10 @@ ze_result_t CommandQueueImp::initialize(bool copyOnly, bool isInternal) {
if (NEO::Debugger::isDebugEnabled(internalUsage) && device->getL0Debugger()) {
device->getL0Debugger()->notifyCommandQueueCreated(device->getNEODevice());
}
auto &hwInfo = device->getHwInfo();
this->stateComputeModeTracking = L0HwHelper::enableStateComputeModeTracking(hwInfo);
this->frontEndStateTracking = L0HwHelper::enableFrontEndStateTracking(hwInfo);
this->pipelineSelectStateTracking = L0HwHelper::enablePipelineSelectStateTracking(hwInfo);
auto &rootDeviceEnvironment = device->getNEODevice()->getRootDeviceEnvironment();
this->stateComputeModeTracking = L0CoreHelper::enableStateComputeModeTracking(rootDeviceEnvironment);
this->frontEndStateTracking = L0CoreHelper::enableFrontEndStateTracking(rootDeviceEnvironment);
this->pipelineSelectStateTracking = L0CoreHelper::enablePipelineSelectStateTracking(rootDeviceEnvironment);
}
return returnValue;
}

23
level_zero/core/source/hw_helpers/l0_hw_helper.cpp
View File

@ -10,6 +10,9 @@
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/hw_info.h"
template <>
L0::L0HwHelper &NEO::RootDeviceEnvironment::getHelper<L0::L0HwHelper>() const;
namespace L0 {
L0HwHelper *l0HwHelperFactory[IGFX_MAX_CORE] = {};
@ -18,32 +21,36 @@ L0HwHelper &L0HwHelper::get(GFXCORE_FAMILY gfxCore) {
return *l0HwHelperFactory[gfxCore];
}
bool L0HwHelper::enableFrontEndStateTracking(const NEO::HardwareInfo &hwInfo) {
bool L0HwHelper::enableFrontEndStateTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) {
if (NEO::DebugManager.flags.EnableFrontEndTracking.get() != -1) {
return !!NEO::DebugManager.flags.EnableFrontEndTracking.get();
}
return get(hwInfo.platform.eRenderCoreFamily).platformSupportsFrontEndTracking(hwInfo);
auto &l0CoreHelper = rootDeviceEnvironment.getHelper<L0CoreHelper>();
return l0CoreHelper.platformSupportsFrontEndTracking();
}
bool L0HwHelper::enablePipelineSelectStateTracking(const NEO::HardwareInfo &hwInfo) {
bool L0HwHelper::enablePipelineSelectStateTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) {
if (NEO::DebugManager.flags.EnablePipelineSelectTracking.get() != -1) {
return !!NEO::DebugManager.flags.EnablePipelineSelectTracking.get();
}
return get(hwInfo.platform.eRenderCoreFamily).platformSupportsPipelineSelectTracking(hwInfo);
auto &l0CoreHelper = rootDeviceEnvironment.getHelper<L0CoreHelper>();
return l0CoreHelper.platformSupportsPipelineSelectTracking();
}
bool L0HwHelper::enableStateComputeModeTracking(const NEO::HardwareInfo &hwInfo) {
bool L0HwHelper::enableStateComputeModeTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) {
if (NEO::DebugManager.flags.EnableStateComputeModeTracking.get() != -1) {
return !!NEO::DebugManager.flags.EnableStateComputeModeTracking.get();
}
return get(hwInfo.platform.eRenderCoreFamily).platformSupportsStateComputeModeTracking(hwInfo);
auto &l0CoreHelper = rootDeviceEnvironment.getHelper<L0CoreHelper>();
return l0CoreHelper.platformSupportsStateComputeModeTracking();
}
bool L0HwHelper::enableImmediateCmdListHeapSharing(const NEO::HardwareInfo &hwInfo, bool cmdlistSupport) {
bool L0HwHelper::enableImmediateCmdListHeapSharing(const NEO::RootDeviceEnvironment &rootDeviceEnvironment, bool cmdlistSupport) {
if (NEO::DebugManager.flags.EnableImmediateCmdListHeapSharing.get() != -1) {
return !!NEO::DebugManager.flags.EnableImmediateCmdListHeapSharing.get();
}
bool platformSupport = get(hwInfo.platform.eRenderCoreFamily).platformSupportsCmdListHeapSharing(hwInfo);
auto &l0CoreHelper = rootDeviceEnvironment.getHelper<L0CoreHelper>();
bool platformSupport = l0CoreHelper.platformSupportsCmdListHeapSharing();
return platformSupport && cmdlistSupport;
}

25
level_zero/core/source/hw_helpers/l0_hw_helper.h
View File

@ -19,6 +19,7 @@ namespace NEO {
enum class EngineGroupType : uint32_t;
struct HardwareInfo;
struct EngineGroupT;
struct RootDeviceEnvironment;
} // namespace NEO
namespace L0 {
@ -33,10 +34,10 @@ using L0CoreHelper = L0HwHelper;
class L0HwHelper {
public:
static L0HwHelper &get(GFXCORE_FAMILY gfxCore);
static bool enableFrontEndStateTracking(const NEO::HardwareInfo &hwInfo);
static bool enablePipelineSelectStateTracking(const NEO::HardwareInfo &hwInfo);
static bool enableStateComputeModeTracking(const NEO::HardwareInfo &hwInfo);
static bool enableImmediateCmdListHeapSharing(const NEO::HardwareInfo &hwInfo, bool cmdlistSupport);
static bool enableFrontEndStateTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment);
static bool enablePipelineSelectStateTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment);
static bool enableStateComputeModeTracking(const NEO::RootDeviceEnvironment &rootDeviceEnvironment);
static bool enableImmediateCmdListHeapSharing(const NEO::RootDeviceEnvironment &rootDeviceEnvironment, bool cmdlistSupport);
static bool usePipeControlMultiKernelEventSync(const NEO::HardwareInfo &hwInfo);
static bool useCompactL3FlushEventPacket(const NEO::HardwareInfo &hwInfo);
static bool useDynamicEventPacketsCount(const NEO::HardwareInfo &hwInfo);
@ -53,10 +54,10 @@ class L0HwHelper {
virtual std::vector<EuThread::ThreadId> getThreadsFromAttentionBitmask(const NEO::HardwareInfo &hwInfo, uint32_t tile, const uint8_t *bitmask, const size_t bitmaskSize) const = 0;
virtual bool multiTileCapablePlatform() const = 0;
virtual bool alwaysAllocateEventInLocalMem() const = 0;
virtual bool platformSupportsCmdListHeapSharing(const NEO::HardwareInfo &hwInfo) const = 0;
virtual bool platformSupportsStateComputeModeTracking(const NEO::HardwareInfo &hwInfo) const = 0;
virtual bool platformSupportsFrontEndTracking(const NEO::HardwareInfo &hwInfo) const = 0;
virtual bool platformSupportsPipelineSelectTracking(const NEO::HardwareInfo &hwInfo) const = 0;
virtual bool platformSupportsCmdListHeapSharing() const = 0;
virtual bool platformSupportsStateComputeModeTracking() const = 0;
virtual bool platformSupportsFrontEndTracking() const = 0;
virtual bool platformSupportsPipelineSelectTracking() const = 0;
virtual uint32_t getEventMaxKernelCount(const NEO::HardwareInfo &hwInfo) const = 0;
virtual uint32_t getEventBaseMaxPacketCount(const NEO::HardwareInfo &hwInfo) const = 0;
@ -84,10 +85,10 @@ class L0HwHelperHw : public L0HwHelper {
std::vector<EuThread::ThreadId> getThreadsFromAttentionBitmask(const NEO::HardwareInfo &hwInfo, uint32_t tile, const uint8_t *bitmask, const size_t bitmaskSize) const override;
bool multiTileCapablePlatform() const override;
bool alwaysAllocateEventInLocalMem() const override;
bool platformSupportsCmdListHeapSharing(const NEO::HardwareInfo &hwInfo) const override;
bool platformSupportsStateComputeModeTracking(const NEO::HardwareInfo &hwInfo) const override;
bool platformSupportsFrontEndTracking(const NEO::HardwareInfo &hwInfo) const override;
bool platformSupportsPipelineSelectTracking(const NEO::HardwareInfo &hwInfo) const override;
bool platformSupportsCmdListHeapSharing() const override;
bool platformSupportsStateComputeModeTracking() const override;
bool platformSupportsFrontEndTracking() const override;
bool platformSupportsPipelineSelectTracking() const override;
uint32_t getEventMaxKernelCount(const NEO::HardwareInfo &hwInfo) const override;
uint32_t getEventBaseMaxPacketCount(const NEO::HardwareInfo &hwInfo) const override;

8
level_zero/core/source/hw_helpers/l0_hw_helper_skl_and_later.inl
View File

@ -19,22 +19,22 @@ bool L0HwHelperHw<Family>::multiTileCapablePlatform() const {
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsCmdListHeapSharing(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsCmdListHeapSharing() const {
return false;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsStateComputeModeTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsStateComputeModeTracking() const {
return false;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsFrontEndTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsFrontEndTracking() const {
return false;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsPipelineSelectTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsPipelineSelectTracking() const {
return false;
}

8
level_zero/core/source/hw_helpers/l0_hw_helper_xehp_and_later.inl
View File

@ -17,22 +17,22 @@ bool L0HwHelperHw<Family>::multiTileCapablePlatform() const {
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsCmdListHeapSharing(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsCmdListHeapSharing() const {
return true;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsStateComputeModeTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsStateComputeModeTracking() const {
return true;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsFrontEndTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsFrontEndTracking() const {
return true;
}
template <typename Family>
bool L0HwHelperHw<Family>::platformSupportsPipelineSelectTracking(const NEO::HardwareInfo &hwInfo) const {
bool L0HwHelperHw<Family>::platformSupportsPipelineSelectTracking() const {
return true;
}

19
level_zero/core/test/unit_tests/gen11/test_l0_hw_helper_gen11.cpp
View File

@ -9,30 +9,31 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
namespace L0 {
namespace ult {
using L0HwHelperTestGen11 = ::testing::Test;
using L0HwHelperTestGen11 = Test<DeviceFixture>;
GEN11TEST_F(L0HwHelperTestGen11, GivenGen11WhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsCmdListHeapSharing(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
GEN11TEST_F(L0HwHelperTestGen11, GivenGen11WhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsStateComputeModeTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
GEN11TEST_F(L0HwHelperTestGen11, GivenGen11WhenCheckingL0HelperForFrontEndTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsFrontEndTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsFrontEndTracking());
}
GEN11TEST_F(L0HwHelperTestGen11, GivenGen11WhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsPipelineSelectTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult

18
level_zero/core/test/unit_tests/gen12lp/test_l0_hw_helper_gen12lp.cpp
View File

@ -20,26 +20,26 @@ HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForAllEUsWhe
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenEu0To1Threads0To3BitmaskWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_GEN12LP_CORE);
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForHalfOfThreadsWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_GEN12LP_CORE);
using L0HwHelperTestGen12Lp = ::testing::Test;
using L0HwHelperTestGen12Lp = Test<DeviceFixture>;
GEN12LPTEST_F(L0HwHelperTestGen12Lp, GivenGen12LpWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsCmdListHeapSharing(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
GEN12LPTEST_F(L0HwHelperTestGen12Lp, GivenGen12LpWhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsStateComputeModeTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
GEN12LPTEST_F(L0HwHelperTestGen12Lp, GivenGen12LpWhenCheckingL0HelperForFrontEndTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsFrontEndTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsFrontEndTracking());
}
GEN12LPTEST_F(L0HwHelperTestGen12Lp, GivenGen12LpWhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsPipelineSelectTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult

19
level_zero/core/test/unit_tests/gen9/test_l0_hw_helper_gen9.cpp
View File

@ -9,30 +9,31 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
namespace L0 {
namespace ult {
using L0HwHelperTestGen9 = ::testing::Test;
using L0HwHelperTestGen9 = Test<DeviceFixture>;
GEN9TEST_F(L0HwHelperTestGen9, GivenGen9WhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsCmdListHeapSharing(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
GEN9TEST_F(L0HwHelperTestGen9, GivenGen9WhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsStateComputeModeTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
GEN9TEST_F(L0HwHelperTestGen9, GivenGen9WhenCheckingL0HelperForFrontEndTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsFrontEndTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsFrontEndTracking());
}
GEN9TEST_F(L0HwHelperTestGen9, GivenGen9WhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnFalse) {
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().platformSupportsPipelineSelectTracking(hwInfo));
auto &l0CoreHelper = getHelper<L0CoreHelper>();
EXPECT_FALSE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult

9
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@ -2121,20 +2121,19 @@ HWTEST2_F(CommandListCreate, givenNullEventWhenAppendEventAfterWalkerThenNothing
}
TEST_F(CommandListCreate, givenCreatedCommandListWhenGettingTrackingFlagsThenDefaultValuseIsHwSupported) {
auto &hwInfo = device->getHwInfo();
auto &l0HwHelper = L0HwHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &l0CoreHelper = device->getNEODevice()->getRootDeviceEnvironment().getHelper<L0CoreHelper>();
ze_result_t returnValue;
std::unique_ptr<L0::ult::CommandList> commandList(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
ASSERT_NE(nullptr, commandList.get());
bool expectedStateComputeModeTracking = l0HwHelper.platformSupportsStateComputeModeTracking(hwInfo);
bool expectedStateComputeModeTracking = l0CoreHelper.platformSupportsStateComputeModeTracking();
EXPECT_EQ(expectedStateComputeModeTracking, commandList->stateComputeModeTracking);
bool expectedPipelineSelectTracking = l0HwHelper.platformSupportsPipelineSelectTracking(hwInfo);
bool expectedPipelineSelectTracking = l0CoreHelper.platformSupportsPipelineSelectTracking();
EXPECT_EQ(expectedPipelineSelectTracking, commandList->pipelineSelectStateTracking);
bool expectedFrontEndTracking = l0HwHelper.platformSupportsFrontEndTracking(hwInfo);
bool expectedFrontEndTracking = l0CoreHelper.platformSupportsFrontEndTracking();
EXPECT_EQ(expectedFrontEndTracking, commandList->frontEndStateTracking);
}

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
View File

@ -1355,7 +1355,7 @@ HWTEST2_F(CommandListAppendMemoryCopyBlit, whenAppendMemoryCopyBlitIsAppendedAnd
template <typename GfxFamily>
struct MockL0HwHelperSupportsCmdListHeapSharingHw : L0::L0HwHelperHw<GfxFamily> {
bool platformSupportsCmdListHeapSharing(const HardwareInfo &hwInfo) const override { return true; }
bool platformSupportsCmdListHeapSharing() const override { return true; }
};
HWTEST2_F(CommandListCreate, givenPlatformSupportsSharedHeapsWhenImmediateCmdListCreatedWithFlushTaskSetThenSharedHeapsFollowsTheSameSetting, IsAtLeastSkl) {
@ -1385,7 +1385,7 @@ HWTEST2_F(CommandListCreate, givenPlatformSupportsSharedHeapsWhenImmediateCmdLis
template <typename GfxFamily>
struct MockL0HwHelperNoSupportsCmdListHeapSharingHw : L0::L0HwHelperHw<GfxFamily> {
bool platformSupportsCmdListHeapSharing(const HardwareInfo &hwInfo) const override { return false; }
bool platformSupportsCmdListHeapSharing() const override { return false; }
};
HWTEST2_F(CommandListCreate, givenPlatformNotSupportsSharedHeapsWhenImmediateCmdListCreatedWithFlushTaskSetThenSharedHeapsIsNotEnabled, IsAtLeastSkl) {

9
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp
View File

@ -1824,8 +1824,7 @@ TEST_F(CommandQueueCreate, givenOverrideCmdQueueSyncModeToSynchronousWhenCommand
}
TEST_F(CommandQueueCreate, givenCreatedCommandQueueWhenGettingTrackingFlagsThenDefaultValuseIsHwSupported) {
auto &hwInfo = device->getHwInfo();
auto &l0HwHelper = L0HwHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &l0CoreHelper = device->getNEODevice()->getRootDeviceEnvironment().getHelper<L0CoreHelper>();
const ze_command_queue_desc_t desc{};
ze_result_t returnValue;
auto commandQueue = whiteboxCast(CommandQueue::create(productFamily,
@ -1839,13 +1838,13 @@ TEST_F(CommandQueueCreate, givenCreatedCommandQueueWhenGettingTrackingFlagsThenD
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, commandQueue);
bool expectedStateComputeModeTracking = l0HwHelper.platformSupportsStateComputeModeTracking(hwInfo);
bool expectedStateComputeModeTracking = l0CoreHelper.platformSupportsStateComputeModeTracking();
EXPECT_EQ(expectedStateComputeModeTracking, commandQueue->stateComputeModeTracking);
bool expectedPipelineSelectTracking = l0HwHelper.platformSupportsPipelineSelectTracking(hwInfo);
bool expectedPipelineSelectTracking = l0CoreHelper.platformSupportsPipelineSelectTracking();
EXPECT_EQ(expectedPipelineSelectTracking, commandQueue->pipelineSelectStateTracking);
bool expectedFrontEndTracking = l0HwHelper.platformSupportsFrontEndTracking(hwInfo);
bool expectedFrontEndTracking = l0CoreHelper.platformSupportsFrontEndTracking();
EXPECT_EQ(expectedFrontEndTracking, commandQueue->frontEndStateTracking);
commandQueue->destroy();

12
level_zero/core/test/unit_tests/xe_hp_core/test_l0_hw_helper_xe_hp_core.cpp
View File

@ -30,26 +30,22 @@ XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForMultiTileCapableP
XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForFrontEndTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking());
}
XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult

12
level_zero/core/test/unit_tests/xe_hpc_core/test_l0_hw_helper_xe_hpc_core.cpp
View File

@ -31,26 +31,22 @@ XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenHpcPlatformsWhenAlwaysAllocateEventI
XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForFrontEndTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking());
}
XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult

12
level_zero/core/test/unit_tests/xe_hpg_core/test_l0_hw_helper_xe_hpg_core.cpp
View File

@ -32,26 +32,22 @@ XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForMultiTil
XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsCmdListHeapSharing());
}
XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgcWhenCheckingL0HelperForStateComputeModeTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsStateComputeModeTracking());
}
XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForFrontEndTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsFrontEndTracking());
}
XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForPipelineSelectTrackingSupportThenReturnTrue) {
auto &l0CoreHelper = getHelper<L0CoreHelper>();
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking(hwInfo));
EXPECT_TRUE(l0CoreHelper.platformSupportsPipelineSelectTracking());
}
} // namespace ult