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

Rename Plus in source code to AndLater

Browse Source 
Related-To: NEO-5920

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2021-08-13 09:47:42 +00:00
committed by Compute-Runtime-Automation
parent 3e532d9f4c
commit 274fe055e9
38 changed files with 473 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl
View File

@@ -78,7 +78,7 @@ void CommandStreamReceiverHw<GfxFamily>::programPipelineSelect(LinearStream &com
template <typename GfxFamily>
void CommandStreamReceiverHw<GfxFamily>::createScratchSpaceController() {
scratchSpaceController = std::make_unique<ScratchSpaceControllerXeHPPlus>(this->rootDeviceIndex, executionEnvironment, *internalAllocationStorage.get());
scratchSpaceController = std::make_unique<ScratchSpaceControllerXeHPAndLater>(this->rootDeviceIndex, executionEnvironment, *internalAllocationStorage.get());
}
template <typename GfxFamily>

84
shared/source/command_stream/scratch_space_controller_xehp_and_later.cpp
View File

@@ -21,9 +21,9 @@
#include "shared/source/os_interface/os_context.h"
namespace NEO {
ScratchSpaceControllerXeHPPlus::ScratchSpaceControllerXeHPPlus(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage)
ScratchSpaceControllerXeHPAndLater::ScratchSpaceControllerXeHPAndLater(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage)
: ScratchSpaceController(rootDeviceIndex, environment, allocationStorage) {
auto &hwHelper = HwHelper::get(environment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);
singleSurfaceStateSize = hwHelper.getRenderSurfaceStateSize();
@@ -31,11 +31,11 @@ ScratchSpaceControllerXeHPPlus::ScratchSpaceControllerXeHPPlus(uint32_t rootDevi
privateScratchSpaceSupported = !!DebugManager.flags.EnablePrivateScratchSlot1.get();
}
if (privateScratchSpaceSupported) {
ScratchSpaceControllerXeHPPlus::stateSlotsCount *= 2;
ScratchSpaceControllerXeHPAndLater::stateSlotsCount *= 2;
}
}
void ScratchSpaceControllerXeHPPlus::setNewSshPtr(void *newSsh, bool &cfeDirty, bool changeId) {
void ScratchSpaceControllerXeHPAndLater::setNewSshPtr(void *newSsh, bool &cfeDirty, bool changeId) {
if (surfaceStateHeap != newSsh) {
surfaceStateHeap = static_cast<char *>(newSsh);
if (scratchAllocation == nullptr) {
@@ -50,14 +50,14 @@ void ScratchSpaceControllerXeHPPlus::setNewSshPtr(void *newSsh, bool &cfeDirty,
}
}
void ScratchSpaceControllerXeHPPlus::setRequiredScratchSpace(void *sshBaseAddress,
uint32_t offset,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
void ScratchSpaceControllerXeHPAndLater::setRequiredScratchSpace(void *sshBaseAddress,
uint32_t offset,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
setNewSshPtr(sshBaseAddress, vfeStateDirty, offset == 0 ? true : false);
bool scratchSurfaceDirty;
prepareScratchAllocation(requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, scratchSurfaceDirty, vfeStateDirty);
@@ -68,7 +68,7 @@ void ScratchSpaceControllerXeHPPlus::setRequiredScratchSpace(void *sshBaseAddres
}
}
void ScratchSpaceControllerXeHPPlus::programSurfaceState() {
void ScratchSpaceControllerXeHPAndLater::programSurfaceState() {
if (updateSlots) {
slotId++;
}
@@ -79,7 +79,7 @@ void ScratchSpaceControllerXeHPPlus::programSurfaceState() {
programSurfaceStateAtPtr(surfaceStateForScratchAllocation);
}
void ScratchSpaceControllerXeHPPlus::programSurfaceStateAtPtr(void *surfaceStateForScratchAllocation) {
void ScratchSpaceControllerXeHPAndLater::programSurfaceStateAtPtr(void *surfaceStateForScratchAllocation) {
auto &hwHelper = HwHelper::get(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);
uint64_t scratchAllocationAddress = 0u;
if (scratchAllocation) {
@@ -103,10 +103,10 @@ void ScratchSpaceControllerXeHPPlus::programSurfaceStateAtPtr(void *surfaceState
}
}
uint64_t ScratchSpaceControllerXeHPPlus::calculateNewGSH() {
uint64_t ScratchSpaceControllerXeHPAndLater::calculateNewGSH() {
return 0u;
}
uint64_t ScratchSpaceControllerXeHPPlus::getScratchPatchAddress() {
uint64_t ScratchSpaceControllerXeHPAndLater::getScratchPatchAddress() {
uint64_t scratchAddress = 0u;
if (scratchAllocation || privateScratchAllocation) {
if (ApiSpecificConfig::getBindlessConfiguration()) {
@@ -118,7 +118,7 @@ uint64_t ScratchSpaceControllerXeHPPlus::getScratchPatchAddress() {
return scratchAddress;
}
size_t ScratchSpaceControllerXeHPPlus::getOffsetToSurfaceState(uint32_t requiredSlotCount) const {
size_t ScratchSpaceControllerXeHPAndLater::getOffsetToSurfaceState(uint32_t requiredSlotCount) const {
auto offset = requiredSlotCount * singleSurfaceStateSize;
if (privateScratchSpaceSupported) {
offset *= 2;
@@ -126,19 +126,19 @@ size_t ScratchSpaceControllerXeHPPlus::getOffsetToSurfaceState(uint32_t required
return offset;
}
void ScratchSpaceControllerXeHPPlus::reserveHeap(IndirectHeap::Type heapType, IndirectHeap *&indirectHeap) {
void ScratchSpaceControllerXeHPAndLater::reserveHeap(IndirectHeap::Type heapType, IndirectHeap *&indirectHeap) {
if (heapType == IndirectHeap::SURFACE_STATE) {
indirectHeap->getSpace(getOffsetToSurfaceState(stateSlotsCount));
}
}
void ScratchSpaceControllerXeHPPlus::programBindlessSurfaceStateForScratch(BindlessHeapsHelper *heapsHelper,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty,
NEO::CommandStreamReceiver *csr) {
void ScratchSpaceControllerXeHPAndLater::programBindlessSurfaceStateForScratch(BindlessHeapsHelper *heapsHelper,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty,
NEO::CommandStreamReceiver *csr) {
bool scratchSurfaceDirty;
prepareScratchAllocation(requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, scratchSurfaceDirty, vfeStateDirty);
if (scratchSurfaceDirty) {
@@ -149,13 +149,13 @@ void ScratchSpaceControllerXeHPPlus::programBindlessSurfaceStateForScratch(Bindl
csr->makeResident(*bindlessSS.heapAllocation);
}
void ScratchSpaceControllerXeHPPlus::prepareScratchAllocation(uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &scratchSurfaceDirty,
bool &vfeStateDirty) {
void ScratchSpaceControllerXeHPAndLater::prepareScratchAllocation(uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &scratchSurfaceDirty,
bool &vfeStateDirty) {
uint32_t requiredPerThreadScratchSizeAlignedUp = alignUp(requiredPerThreadScratchSize, 64);
size_t requiredScratchSizeInBytes = requiredPerThreadScratchSizeAlignedUp * computeUnitsUsedForScratch;
scratchSurfaceDirty = false;
@@ -188,14 +188,14 @@ void ScratchSpaceControllerXeHPPlus::prepareScratchAllocation(uint32_t requiredP
}
}
void ScratchSpaceControllerXeHPPlus::programHeaps(HeapContainer &heapContainer,
uint32_t scratchSlot,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
void ScratchSpaceControllerXeHPAndLater::programHeaps(HeapContainer &heapContainer,
uint32_t scratchSlot,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
sshOffset = scratchSlot;
updateSlots = false;
setRequiredScratchSpace(heapContainer[0]->getUnderlyingBuffer(), sshOffset, requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, vfeStateDirty);

8
shared/source/command_stream/scratch_space_controller_xehp_and_later.h
View File

@@ -13,11 +13,11 @@
namespace NEO {
class ScratchSpaceControllerXeHPPlus : public ScratchSpaceController {
class ScratchSpaceControllerXeHPAndLater : public ScratchSpaceController {
public:
ScratchSpaceControllerXeHPPlus(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage);
ScratchSpaceControllerXeHPAndLater(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage);
void setNewSshPtr(void *newSsh, bool &cfeDirty, bool changeId);
void setRequiredScratchSpace(void *sshBaseAddress,

2
shared/source/helpers/hw_helper_xehp_and_later.inl
View File

@@ -30,7 +30,7 @@ uint32_t HwHelperHw<GfxFamily>::getComputeUnitsUsedForScratch(const HardwareInfo
return static_cast<uint32_t>(DebugManager.flags.OverrideNumComputeUnitsForScratch.get());
}
// XeHP plus products return physical threads
// XeHP and later products return physical threads
return pHwInfo->gtSystemInfo.MaxSubSlicesSupported * pHwInfo->gtSystemInfo.MaxEuPerSubSlice * (pHwInfo->gtSystemInfo.ThreadCount / pHwInfo->gtSystemInfo.EUCount);
}

2
shared/source/xe_hp_core/hw_helper_xe_hp_core.cpp
View File

@@ -33,7 +33,7 @@ uint32_t HwHelperHw<Family>::getComputeUnitsUsedForScratch(const HardwareInfo *p
return static_cast<uint32_t>(DebugManager.flags.OverrideNumComputeUnitsForScratch.get());
}
// XeHP plus products return physical threads
// XeHP and later products return physical threads
return std::max(pHwInfo->gtSystemInfo.MaxSubSlicesSupported, static_cast<uint32_t>(32)) * pHwInfo->gtSystemInfo.MaxEuPerSubSlice * (pHwInfo->gtSystemInfo.ThreadCount / pHwInfo->gtSystemInfo.EUCount);
}

2
shared/test/common/xe_hp_core/test_preemption_xe_hp_core.cpp
View File

@@ -10,7 +10,7 @@
using namespace NEO;
HWTEST_EXCLUDE_PRODUCT(XeHPPlusPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded, IGFX_XE_HP_CORE);
HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded, IGFX_XE_HP_CORE);
template <>
PreemptionTestHwDetails GetPreemptionTestHwDetails<XeHpFamily>() {

14
shared/test/unit_test/encoders/command_encoder_tests_xehp_and_later.cpp
View File

@@ -13,13 +13,13 @@
using namespace NEO;
using XeHPPlusHardwareCommandsTest = testing::Test;
using XeHPAndLaterHardwareCommandsTest = testing::Test;
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusHardwareCommandsTest, givenXeHPPlusPlatformWhenDoBindingTablePrefetchIsCalledThenReturnsFalse) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterHardwareCommandsTest, givenXeHPAndLaterPlatformWhenDoBindingTablePrefetchIsCalledThenReturnsFalse) {
EXPECT_FALSE(EncodeSurfaceState<FamilyType>::doBindingTablePrefetch());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusHardwareCommandsTest, GivenXeHPPlusPlatformWhenSetCoherencyTypeIsCalledThenOnlyEncodingSupportedIsSingleGpuCoherent) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterHardwareCommandsTest, GivenXeHPAndLaterPlatformWhenSetCoherencyTypeIsCalledThenOnlyEncodingSupportedIsSingleGpuCoherent) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using COHERENCY_TYPE = typename RENDER_SURFACE_STATE::COHERENCY_TYPE;
@@ -30,20 +30,20 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusHardwareCommandsTest, GivenXeHPPlusPlatform
}
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusHardwareCommandsTest, givenXeHPPlusPlatformWhenGetAdditionalPipelineSelectSizeIsCalledThenZeroIsReturned) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterHardwareCommandsTest, givenXeHPAndLaterPlatformWhenGetAdditionalPipelineSelectSizeIsCalledThenZeroIsReturned) {
MockDevice device;
EXPECT_EQ(0u, EncodeWA<FamilyType>::getAdditionalPipelineSelectSize(device));
}
using XeHPPlusCommandEncoderTest = Test<DeviceFixture>;
using XeHPAndLaterCommandEncoderTest = Test<DeviceFixture>;
HWTEST2_F(XeHPPlusCommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsAtLeastXeHpCore) {
HWTEST2_F(XeHPAndLaterCommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsAtLeastXeHpCore) {
auto container = CommandContainer();
size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
EXPECT_EQ(size, 104ul);
}
HWTEST2_F(XeHPPlusCommandEncoderTest, givenCommandContainerWithDirtyHeapWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsAtLeastXeHpCore) {
HWTEST2_F(XeHPAndLaterCommandEncoderTest, givenCommandContainerWithDirtyHeapWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsAtLeastXeHpCore) {
auto container = CommandContainer();
container.setHeapDirty(HeapType::SURFACE_STATE);
size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);

18
shared/test/unit_test/encoders/test_encode_dispatch_kernel_xehp_and_later.cpp
View File

@@ -604,9 +604,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTest, givenInterfaceDescriptorDa
EXPECT_EQ(forceThreadGroupDispatchSize, iddArg.getThreadGroupDispatchSize());
}
using WalkerThreadTestXeHPPlus = WalkerThreadTest;
using WalkerThreadTestXeHPAndLater = WalkerThreadTest;
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenStartWorkGroupWhenIndirectIsFalseThenExpectStartGroupAndThreadDimensionsProgramming) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenStartWorkGroupWhenIndirectIsFalseThenExpectStartGroupAndThreadDimensionsProgramming) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -640,7 +640,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenStartWorkGroupWhenIn
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenNoStartWorkGroupWhenIndirectIsTrueThenExpectNoStartGroupAndThreadDimensionsProgramming) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenNoStartWorkGroupWhenIndirectIsTrueThenExpectNoStartGroupAndThreadDimensionsProgramming) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -674,7 +674,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenNoStartWorkGroupWhen
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenSimdSizeOneWhenWorkGroupSmallerThanSimdThenExpectSimdSizeAsMaxAndExecutionMaskFull) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenSimdSizeOneWhenWorkGroupSmallerThanSimdThenExpectSimdSizeAsMaxAndExecutionMaskFull) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -710,7 +710,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenSimdSizeOneWhenWorkG
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenStartWorkGroupWhenWorkGroupSmallerThanSimdThenExpectStartGroupAndExecutionMaskNotFull) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenStartWorkGroupWhenWorkGroupSmallerThanSimdThenExpectStartGroupAndExecutionMaskNotFull) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -745,7 +745,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenStartWorkGroupWhenWo
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenLocalIdGenerationByHwWhenNoLocalIdsPresentThenExpectNoEmitAndGenerateLocalIds) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenLocalIdGenerationByHwWhenNoLocalIdsPresentThenExpectNoEmitAndGenerateLocalIds) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -778,7 +778,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenLocalIdGenerationByH
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenLocalIdGenerationByHwWhenLocalIdsPresentThenExpectEmitAndGenerateLocalIds) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, givenLocalIdGenerationByHwWhenLocalIdsPresentThenExpectEmitAndGenerateLocalIds) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -813,7 +813,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, givenLocalIdGenerationByH
EXPECT_FALSE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, WhenInlineDataIsTrueThenExpectInlineDataProgramming) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, WhenInlineDataIsTrueThenExpectInlineDataProgramming) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;
@@ -847,7 +847,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, WhenInlineDataIsTrueThenE
EXPECT_TRUE(walkerCmd.getEmitInlineParameter());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPPlus, WhenExecutionMaskNotZeroThenExpectOverrideExecutionMaskCalculation) {
HWCMDTEST_F(IGFX_XE_HP_CORE, WalkerThreadTestXeHPAndLater, WhenExecutionMaskNotZeroThenExpectOverrideExecutionMaskCalculation) {
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
WALKER_TYPE walkerCmd = FamilyType::cmdInitGpgpuWalker;

4
shared/test/unit_test/encoders/test_encode_math_xehp_and_later.cpp
View File

@@ -14,9 +14,9 @@
using namespace NEO;
using XeHPPlusCommandEncoderMathTest = Test<DeviceFixture>;
using XeHPAndLaterCommandEncoderMathTest = Test<DeviceFixture>;
HWTEST2_F(XeHPPlusCommandEncoderMathTest, WhenAppendsAGreaterThanThenPredicateCorrectlySetAndRemapEnabled, IsAtLeastXeHpCore) {
HWTEST2_F(XeHPAndLaterCommandEncoderMathTest, WhenAppendsAGreaterThanThenPredicateCorrectlySetAndRemapEnabled, IsAtLeastXeHpCore) {
using MI_LOAD_REGISTER_MEM = typename FamilyType::MI_LOAD_REGISTER_MEM;
using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
using MI_LOAD_REGISTER_REG = typename FamilyType::MI_LOAD_REGISTER_REG;

4
shared/test/unit_test/encoders/test_encode_mi_flush_dw_xehp_and_later.cpp
View File

@@ -10,9 +10,9 @@
using namespace NEO;
using XeHPPlusEncodeMiFlushDWTest = Test<CommandEncodeStatesFixture>;
using XeHPAndLaterEncodeMiFlushDWTest = Test<CommandEncodeStatesFixture>;
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusEncodeMiFlushDWTest, whenMiFlushDwIsProgrammedThenSetFlushCcsAndLlc) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterEncodeMiFlushDWTest, whenMiFlushDwIsProgrammedThenSetFlushCcsAndLlc) {
using MI_FLUSH_DW = typename FamilyType::MI_FLUSH_DW;
uint8_t buffer[2 * sizeof(MI_FLUSH_DW)] = {};
LinearStream linearStream(buffer, sizeof(buffer));

16
shared/test/unit_test/preemption/test_preemption_xehp_and_later.cpp
View File

@@ -17,9 +17,9 @@
using namespace NEO;
using XeHPPlusPreemptionTests = DevicePreemptionTests;
using XeHPAndLaterPreemptionTests = DevicePreemptionTests;
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, whenProgramStateSipIsCalledThenStateSipCmdIsNotAddedToStream) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, whenProgramStateSipIsCalledThenStateSipCmdIsNotAddedToStream) {
size_t requiredSize = PreemptionHelper::getRequiredStateSipCmdSize<FamilyType>(*device);
EXPECT_EQ(0U, requiredSize);
@@ -28,12 +28,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, whenProgramStateSipIsCalle
EXPECT_EQ(0U, cmdStream.getUsed());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, WhenProgrammingThenWaHasExpectedSize) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, WhenProgrammingThenWaHasExpectedSize) {
size_t expectedSize = 0;
EXPECT_EQ(expectedSize, PreemptionHelper::getPreemptionWaCsSize<FamilyType>(*device));
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, WhenProgrammingThenWaNotApplied) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, WhenProgrammingThenWaNotApplied) {
size_t usedSize = 0;
auto requiredSize = PreemptionHelper::getRequiredStateSipCmdSize<FamilyType>(*device);
@@ -46,7 +46,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, WhenProgrammingThenWaNotAp
EXPECT_EQ(usedSize, cmdStream.getUsed());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, givenInterfaceDescriptorDataWhenMidThreadPreemptionModeThenSetDisableThreadPreemptionBitToDisable) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, givenInterfaceDescriptorDataWhenMidThreadPreemptionModeThenSetDisableThreadPreemptionBitToDisable) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
INTERFACE_DESCRIPTOR_DATA iddArg;
@@ -58,7 +58,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, givenInterfaceDescriptorDa
EXPECT_EQ(INTERFACE_DESCRIPTOR_DATA::THREAD_PREEMPTION_DISABLE_DISABLE, iddArg.getThreadPreemptionDisable());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, givenInterfaceDescriptorDataWhenNoMidThreadPreemptionModeThenSetDisableThreadPreemptionBitToEnable) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, givenInterfaceDescriptorDataWhenNoMidThreadPreemptionModeThenSetDisableThreadPreemptionBitToEnable) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
INTERFACE_DESCRIPTOR_DATA iddArg;
@@ -80,7 +80,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, givenInterfaceDescriptorDa
EXPECT_EQ(INTERFACE_DESCRIPTOR_DATA::THREAD_PREEMPTION_DISABLE_ENABLE, iddArg.getThreadPreemptionDisable());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, WhenProgrammingPreemptionThenExpectLoadRegisterCommandRemapFlagEnabled) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, WhenProgrammingPreemptionThenExpectLoadRegisterCommandRemapFlagEnabled) {
using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
const size_t bufferSize = 128;
@@ -93,7 +93,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, WhenProgrammingPreemptionT
EXPECT_TRUE(lriCommand->getMmioRemapEnable());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPPlusPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded) {
HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded) {
using STATE_SIP = typename FamilyType::STATE_SIP;
device->executionEnvironment->rootDeviceEnvironments[0]->debugger.reset(new MockDebugger);

46
shared/test/unit_test/scratch_space_controler/scratch_space_controler_xehp_and_later_tests.cpp
View File

@@ -16,18 +16,18 @@
using namespace NEO;
class MockScratchSpaceControllerXeHPPlus : public ScratchSpaceControllerXeHPPlus {
class MockScratchSpaceControllerXeHPAndLater : public ScratchSpaceControllerXeHPAndLater {
public:
using ScratchSpaceControllerXeHPPlus::bindlessSS;
using ScratchSpaceControllerXeHPPlus::scratchAllocation;
using ScratchSpaceControllerXeHPPlus::singleSurfaceStateSize;
using ScratchSpaceControllerXeHPAndLater::bindlessSS;
using ScratchSpaceControllerXeHPAndLater::scratchAllocation;
using ScratchSpaceControllerXeHPAndLater::singleSurfaceStateSize;
MockScratchSpaceControllerXeHPPlus(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage) : ScratchSpaceControllerXeHPPlus(rootDeviceIndex, environment, allocationStorage) {
MockScratchSpaceControllerXeHPAndLater(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage) : ScratchSpaceControllerXeHPAndLater(rootDeviceIndex, environment, allocationStorage) {
scratchAllocation = &alloc;
}
~MockScratchSpaceControllerXeHPPlus() override {
~MockScratchSpaceControllerXeHPAndLater() override {
scratchAllocation = nullptr;
}
void programSurfaceStateAtPtr(void *surfaceStateForScratchAllocation) override {
@@ -58,9 +58,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ScratchComtrolerTests, givenBindlessModeOnWhenGetPa
csr.setupContext(*pDevice->getDefaultEngine().osContext);
ExecutionEnvironment *execEnv = static_cast<ExecutionEnvironment *>(pDevice->getExecutionEnvironment());
std::unique_ptr<MockScratchSpaceControllerXeHPPlus> scratchController = std::make_unique<MockScratchSpaceControllerXeHPPlus>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
std::unique_ptr<MockScratchSpaceControllerXeHPAndLater> scratchController = std::make_unique<MockScratchSpaceControllerXeHPAndLater>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
uint64_t bindlessOffset = 0x4000;
scratchController->bindlessSS.surfaceStateOffset = bindlessOffset;
EXPECT_EQ(scratchController->getScratchPatchAddress(), bindlessOffset);
@@ -74,9 +74,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ScratchComtrolerTests, givenDirtyScratchAllocationO
csr.setupContext(*pDevice->getDefaultEngine().osContext);
ExecutionEnvironment *execEnv = static_cast<ExecutionEnvironment *>(pDevice->getExecutionEnvironment());
std::unique_ptr<MockScratchSpaceControllerXeHPPlus> scratchController = std::make_unique<MockScratchSpaceControllerXeHPPlus>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
std::unique_ptr<MockScratchSpaceControllerXeHPAndLater> scratchController = std::make_unique<MockScratchSpaceControllerXeHPAndLater>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
auto bindlessHeapHelper = std::make_unique<BindlessHeapsHelper>(pDevice->getMemoryManager(), pDevice->getNumAvailableDevices() > 1, pDevice->getRootDeviceIndex());
bool gsbaStateDirty = false;
bool frontEndStateDirty = false;
@@ -94,9 +94,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ScratchComtrolerTests, givenNotDirtyScratchAllocati
csr.setupContext(*pDevice->getDefaultEngine().osContext);
ExecutionEnvironment *execEnv = static_cast<ExecutionEnvironment *>(pDevice->getExecutionEnvironment());
std::unique_ptr<MockScratchSpaceControllerXeHPPlus> scratchController = std::make_unique<MockScratchSpaceControllerXeHPPlus>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
std::unique_ptr<MockScratchSpaceControllerXeHPAndLater> scratchController = std::make_unique<MockScratchSpaceControllerXeHPAndLater>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
auto bindlessHeapHelper = std::make_unique<BindlessHeapsHelper>(pDevice->getMemoryManager(), pDevice->getNumAvailableDevices() > 1, pDevice->getRootDeviceIndex());
bool gsbaStateDirty = false;
bool frontEndStateDirty = false;
@@ -116,9 +116,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ScratchComtrolerTests, givenPrivateScratchEnabledWh
csr.setupContext(*pDevice->getDefaultEngine().osContext);
ExecutionEnvironment *execEnv = static_cast<ExecutionEnvironment *>(pDevice->getExecutionEnvironment());
std::unique_ptr<MockScratchSpaceControllerXeHPPlus> scratchController = std::make_unique<MockScratchSpaceControllerXeHPPlus>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
std::unique_ptr<MockScratchSpaceControllerXeHPAndLater> scratchController = std::make_unique<MockScratchSpaceControllerXeHPAndLater>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
auto bindlessHeapHelper = std::make_unique<BindlessHeapsHelper>(pDevice->getMemoryManager(), pDevice->getNumAvailableDevices() > 1, pDevice->getRootDeviceIndex());
bool gsbaStateDirty = false;
bool frontEndStateDirty = false;
@@ -138,9 +138,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ScratchComtrolerTests, givenPrivateScratchDisabledW
csr.setupContext(*pDevice->getDefaultEngine().osContext);
ExecutionEnvironment *execEnv = static_cast<ExecutionEnvironment *>(pDevice->getExecutionEnvironment());
std::unique_ptr<MockScratchSpaceControllerXeHPPlus> scratchController = std::make_unique<MockScratchSpaceControllerXeHPPlus>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
std::unique_ptr<MockScratchSpaceControllerXeHPAndLater> scratchController = std::make_unique<MockScratchSpaceControllerXeHPAndLater>(pDevice->getRootDeviceIndex(),
*execEnv,
*csr.getInternalAllocationStorage());
auto bindlessHeapHelper = std::make_unique<BindlessHeapsHelper>(pDevice->getMemoryManager(), pDevice->getNumAvailableDevices() > 1, pDevice->getRootDeviceIndex());
bool gsbaStateDirty = false;
bool frontEndStateDirty = false;