intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: don't use global GfxCoreHelper getter in shared files 2/n

Browse Source 
Related-To: NEO-6853
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>
This commit is contained in:
Kamil Kopryk
2022-12-28 22:18:29 +00:00
committed by Compute-Runtime-Automation
parent 0b2faaa957
commit 6665f49593
29 changed files with 208 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
shared/test/unit_test/built_ins/sip_tests.cpp
View File

@@ -338,10 +338,11 @@ TEST_F(HexadecimalHeaderSipTest, whenInitHexadecimalArraySipKernelIsCalledTwiceT
using StateSaveAreaSipTest = Test<RawBinarySipFixture>;
TEST_F(StateSaveAreaSipTest, givenEmptyStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenMaxDbgSurfaceSizeIsReturned) {
MockSipData::useMockSip = true;
MockSipData::mockSipKernel->mockStateSaveAreaHeader.clear();
auto hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_EQ(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), SipKernel::getSipKernel(*pDevice).getStateSaveAreaSize(pDevice));
}
@@ -349,7 +350,7 @@ TEST_F(StateSaveAreaSipTest, givenCorruptedStateSaveAreaHeaderWhenGetStateSaveAr
MockSipData::useMockSip = true;
MockSipData::mockSipKernel->mockStateSaveAreaHeader = {'g', 'a', 'r', 'b', 'a', 'g', 'e'};
auto hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_EQ(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), SipKernel::getSipKernel(*pDevice).getStateSaveAreaSize(pDevice));
}

9
shared/test/unit_test/command_container/command_container_tests.cpp
View File

@@ -140,7 +140,7 @@ TEST_F(CommandContainerTest, givenCommandContainerWhenInitializeThenEverythingIs
EXPECT_EQ(cmdContainer.getIddBlock(), nullptr);
EXPECT_EQ(cmdContainer.getNumIddPerBlock(), defaultNumIddsPerBlock);
auto &gfxCoreHelper = GfxCoreHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
EXPECT_EQ(cmdContainer.getInstructionHeapBaseAddress(),
pDevice->getMemoryManager()->getInternalHeapBaseAddress(0, !gfxCoreHelper.useSystemMemoryPlacementForISA(pDevice->getHardwareInfo())));
@@ -722,8 +722,8 @@ TEST_F(CommandContainerHeaps, givenCommandContainerForDifferentRootDevicesThenIn
auto device0 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
auto &gfxCoreHelper0 = GfxCoreHelper::get(device0->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper1 = GfxCoreHelper::get(device1->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper0 = device0->getGfxCoreHelper();
auto &gfxCoreHelper1 = device1->getGfxCoreHelper();
CommandContainer cmdContainer0;
cmdContainer0.initialize(device0.get(), nullptr, true);
@@ -836,8 +836,7 @@ TEST_F(CommandContainerTest, givenCmdContainerWhenAlocatingNextCmdBufferThenStre
TEST_F(CommandContainerTest, givenCmdContainerWhenCloseAndAllocateNextCommandBufferCalledThenBBEndPlacedAtEndOfLinearStream) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto ptr = cmdContainer.getCommandStream()->getSpace(0u);
cmdContainer.closeAndAllocateNextCommandBuffer();
EXPECT_EQ(memcmp(ptr, gfxCoreHelper.getBatchBufferEndReference(), gfxCoreHelper.getBatchBufferEndSize()), 0);

3
shared/test/unit_test/command_stream/aub_command_stream_receiver_1_tests.cpp
View File

@@ -253,7 +253,8 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenMultipl
pDevice->executionEnvironment->rootDeviceEnvironments[0]->aubCenter.reset(new AubCenter());
auto &hwInfo = pDevice->getHardwareInfo();
auto engineInstance = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto engineInstance = gfxCoreHelper.getGpgpuEngineInstances(hwInfo)[0];
MockOsContext osContext(0, EngineDescriptorHelper::getDefaultDescriptor(engineInstance));
auto aubCsr1 = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());

6
shared/test/unit_test/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@@ -588,7 +588,8 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
auto engineInstance = GfxCoreHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engineInstance = gfxCoreHelper.getGpgpuEngineInstances(*hwInfo)[0];
UltDeviceFactory deviceFactory{1, 0, *executionEnvironment};
DeviceBitfield deviceBitfield(1);
MockOsContext osContext(0, EngineDescriptorHelper::getDefaultDescriptor(engineInstance, deviceBitfield));
@@ -841,7 +842,8 @@ HWTEST_F(AubCommandStreamReceiverTests, whenAubCommandStreamReceiverIsCreatedThe
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenEngineIsInitializedThenDumpHandleIsGenerated) {
MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
auto engineInstance = GfxCoreHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engineInstance = gfxCoreHelper.getGpgpuEngineInstances(*hwInfo)[0];
DeviceBitfield deviceBitfield(1);
MockOsContext osContext(0, EngineDescriptorHelper::getDefaultDescriptor(engineInstance, deviceBitfield));
executionEnvironment.initializeMemoryManager();

4
shared/test/unit_test/command_stream/command_stream_receiver_tests.cpp
View File

@@ -698,7 +698,7 @@ HWTEST_F(CommandStreamReceiverTest, givenUpdateTaskCountFromWaitWhenCheckTaskCou
HWTEST_F(CommandStreamReceiverTest, givenUpdateTaskCountFromWaitWhenCheckIfEnabledThenCanBeEnabledOnlyWithDirectSubmission) {
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
auto &gfxCoreHelper = GfxCoreHelper::get(csr.peekHwInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
{
csr.directSubmissionAvailable = true;
@@ -719,7 +719,7 @@ HWTEST_F(CommandStreamReceiverTest, givenUpdateTaskCountFromWaitInMultiRootDevic
SetUp();
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
auto &gfxCoreHelper = GfxCoreHelper::get(csr.peekHwInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
{
csr.directSubmissionAvailable = true;

15
shared/test/unit_test/command_stream/linear_stream_tests.cpp
View File

@@ -169,8 +169,7 @@ TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenOn
TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenThereIsNoSpaceForCommandAndBBEndThenNewCmdBufferAllocated) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto stream = reinterpret_cast<MyLinearStreamMock *>(cmdContainer.getCommandStream());
size_t dummyCommandSize = 2;
stream->sizeUsed = stream->getMaxAvailableSpace() - gfxCoreHelper.getBatchBufferEndSize() - (dummyCommandSize - 1);
@@ -182,8 +181,7 @@ TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenTh
TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenThereIsNoSpaceForCommandAndBBEndThenLinearStreamHasNewAllocation) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto stream = reinterpret_cast<MyLinearStreamMock *>(cmdContainer.getCommandStream());
size_t dummyCommandSize = 2;
stream->sizeUsed = stream->getMaxAvailableSpace() - gfxCoreHelper.getBatchBufferEndSize() - (dummyCommandSize - 1);
@@ -196,8 +194,7 @@ TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenTh
TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenThereIsNoSpaceForCommandAndBBEndThenGetSpaceReturnPtrFromNewAllocation) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto stream = reinterpret_cast<MyLinearStreamMock *>(cmdContainer.getCommandStream());
size_t dummyCommandSize = 2;
stream->sizeUsed = stream->getMaxAvailableSpace() - gfxCoreHelper.getBatchBufferEndSize() - (dummyCommandSize - 1);
@@ -209,8 +206,7 @@ TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenTh
TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenThereIsSpaceForCommandAndBBEndThenNewCmdBufferIsNotAllocated) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto stream = reinterpret_cast<MyLinearStreamMock *>(cmdContainer.getCommandStream());
size_t dummyCommandSize = 2;
stream->sizeUsed = stream->getMaxAvailableSpace() - gfxCoreHelper.getBatchBufferEndSize() - (dummyCommandSize);
@@ -222,8 +218,7 @@ TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenTh
TEST_F(CommandContainerLinearStreamTest, givenLinearStreamWithCmdContainerWhenThereIsNoSpaceForCommandAndBBEndThenBBEndAddedAtEndOfStream) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice, nullptr, true);
auto &hwInfo = pDevice->getHardwareInfo();
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto stream = reinterpret_cast<MyLinearStreamMock *>(cmdContainer.getCommandStream());
size_t dummyCommandSize = 2;
stream->sizeUsed = stream->getMaxAvailableSpace() - gfxCoreHelper.getBatchBufferEndSize() - (dummyCommandSize - 1);

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

@@ -57,7 +57,7 @@ DG1TEST_F(GfxCoreHelperTestDg1, givenDg1AndVariousSteppingsWhenGettingIsWorkarou
}
DG1TEST_F(GfxCoreHelperTestDg1, givenBufferAllocationTypeWhenSetExtraAllocationDataIsCalledThenIsLockableIsSet) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
AllocationData allocData{};
allocData.flags.useSystemMemory = true;
AllocationProperties allocProperties(0, 1, AllocationType::BUFFER, {});
@@ -68,7 +68,7 @@ DG1TEST_F(GfxCoreHelperTestDg1, givenBufferAllocationTypeWhenSetExtraAllocationD
}
DG1TEST_F(GfxCoreHelperTestDg1, givenBufferAllocationTypeWhenSetExtraAllocationDataIsCalledWithShareableSetThenIsLockableIsFalse) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
AllocationData allocData{};
allocData.flags.useSystemMemory = true;
AllocationProperties allocProperties(0, 1, AllocationType::BUFFER, {});

4
shared/test/unit_test/helpers/hw_helper_default_tests.cpp
View File

@@ -11,12 +11,12 @@
#include "shared/test/common/test_macros/hw_test.h"
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenGfxCoreHelperWhenAskedForHvAlign4RequiredThenReturnTrue) {
auto &gfxCoreHelper = GfxCoreHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
EXPECT_TRUE(gfxCoreHelper.hvAlign4Required());
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenGfxCoreHelperWhenGettingBindlessSurfaceExtendedMessageDescriptorValueThenCorrectValueIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto value = gfxCoreHelper.getBindlessSurfaceExtendedMessageDescriptorValue(0x200);
typename FamilyType::DataPortBindlessSurfaceExtendedMessageDescriptor messageExtDescriptor = {};

204
shared/test/unit_test/helpers/hw_helper_tests.cpp
View File

@@ -59,31 +59,31 @@ TEST(GfxCoreHelperSimpleTest, givenDebugVariableWhenAskingForCompressionThenRetu
}
TEST_F(GfxCoreHelperTest, WhenGettingHelperThenValidHelperReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_NE(nullptr, &helper);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_NE(nullptr, &gfxCoreHelper);
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForTimestampPacketAlignmentThenReturnFourCachelines) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
constexpr auto expectedAlignment = MemoryConstants::cacheLineSize * 4;
EXPECT_EQ(expectedAlignment, helper.getTimestampPacketAllocatorAlignment());
EXPECT_EQ(expectedAlignment, gfxCoreHelper.getTimestampPacketAllocatorAlignment());
}
HWTEST2_F(GfxCoreHelperTest, givenGfxCoreHelperWhenGettingISAPaddingThenCorrectValueIsReturned, IsAtMostXeHpgCore) {
auto &helper = getHelper<GfxCoreHelper>();
EXPECT_EQ(helper.getPaddingForISAAllocation(), 512u);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getPaddingForISAAllocation(), 512u);
}
HWTEST_F(GfxCoreHelperTest, givenForceExtendedKernelIsaSizeSetWhenGettingISAPaddingThenCorrectValueIsReturned) {
DebugManagerStateRestore restore;
auto &helper = getHelper<GfxCoreHelper>();
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto defaultPadding = helper.getPaddingForISAAllocation();
auto defaultPadding = gfxCoreHelper.getPaddingForISAAllocation();
for (int32_t valueToTest : {0, 1, 2, 10}) {
DebugManager.flags.ForceExtendedKernelIsaSize.set(valueToTest);
EXPECT_EQ(helper.getPaddingForISAAllocation(), defaultPadding + MemoryConstants::pageSize * valueToTest);
EXPECT_EQ(gfxCoreHelper.getPaddingForISAAllocation(), defaultPadding + MemoryConstants::pageSize * valueToTest);
}
}
@@ -128,28 +128,28 @@ TEST_F(GfxCoreHelperTest, givenDebuggingInactiveWhenSipKernelTypeIsQueriedThenCs
}
TEST_F(GfxCoreHelperTest, givenEngineTypeRcsWhenCsTraitsAreQueiredThenCorrectNameInTraitsIsReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_NE(nullptr, &helper);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_NE(nullptr, &gfxCoreHelper);
auto &csTraits = helper.getCsTraits(aub_stream::ENGINE_RCS);
auto &csTraits = gfxCoreHelper.getCsTraits(aub_stream::ENGINE_RCS);
EXPECT_STREQ("RCS", csTraits.name.c_str());
}
using isTglLpOrBelow = IsAtMostProduct<IGFX_TIGERLAKE_LP>;
HWTEST2_F(GfxCoreHelperTest, givenGfxCoreHelperWhenGettingThreadsPerEUConfigsThenNoConfigsAreReturned, isTglLpOrBelow) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto &configs = helper.getThreadsPerEUConfigs();
auto &configs = gfxCoreHelper.getThreadsPerEUConfigs();
EXPECT_EQ(0U, configs.size());
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenGfxCoreHelperWhenGetGpuTimeStampInNSIsCalledThenCorrectValueIsReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto timeStamp = 0x00ff'ffff'ffff;
auto frequency = 123456.0;
auto result = static_cast<uint64_t>(timeStamp * frequency);
EXPECT_EQ(result, helper.getGpuTimeStampInNS(timeStamp, frequency));
EXPECT_EQ(result, gfxCoreHelper.getGpuTimeStampInNS(timeStamp, frequency));
}
TEST(DwordBuilderTest, WhenSettingNonMaskedBitsThenOnlySelectedBitAreSet) {
@@ -394,8 +394,8 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvid
void *stateBuffer = alignedMalloc(sizeof(RENDER_SURFACE_STATE), sizeof(RENDER_SURFACE_STATE));
ASSERT_NE(nullptr, stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_EQ(sizeof(RENDER_SURFACE_STATE), helper.getRenderSurfaceStateSize());
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(sizeof(RENDER_SURFACE_STATE), gfxCoreHelper.getRenderSurfaceStateSize());
size_t size = 0x1000;
SURFACE_STATE_BUFFER_LENGTH length;
@@ -404,7 +404,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvid
size_t offset = 0x1000;
uint32_t pitch = 0x40;
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, offset, pitch, nullptr, false, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, offset, pitch, nullptr, false, type, true, false);
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
EXPECT_EQ(length.SurfaceState.Depth + 1u, state->getDepth());
@@ -420,7 +420,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvid
size = 0x1003;
length.Length = static_cast<uint32_t>(alignUp(size, 4) - 1);
bool isReadOnly = false;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED), state->getMemoryObjectControlState());
EXPECT_EQ(length.SurfaceState.Depth + 1u, state->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, state->getWidth());
@@ -430,7 +430,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvid
size = 0x1000;
addr = 0x2001;
length.Length = static_cast<uint32_t>(size - 1);
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED), state->getMemoryObjectControlState());
EXPECT_EQ(length.SurfaceState.Depth + 1u, state->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, state->getWidth());
@@ -441,7 +441,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenNoAllocationProvid
size = 0x1005;
length.Length = static_cast<uint32_t>(alignUp(size, 4) - 1);
isReadOnly = true;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, nullptr, isReadOnly, type, true, false);
EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER), state->getMemoryObjectControlState());
EXPECT_EQ(length.SurfaceState.Depth + 1u, state->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, state->getWidth());
@@ -462,7 +462,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenAllocationProvided
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
SURFACE_STATE_BUFFER_LENGTH length;
@@ -476,7 +476,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenAllocationProvided
GraphicsAllocation allocation(0, AllocationType::UNKNOWN, cpuAddr, gpuAddr, 0u, allocSize, MemoryPool::MemoryNull, 0u);
allocation.setDefaultGmm(new Gmm(pDevice->getGmmHelper(), allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize(), 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, true, false);
EXPECT_EQ(length.SurfaceState.Depth + 1u, state->getDepth());
EXPECT_EQ(length.SurfaceState.Width + 1u, state->getWidth());
EXPECT_EQ(length.SurfaceState.Height + 1u, state->getHeight());
@@ -501,7 +501,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmAndAllocationCo
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
uint64_t addr = 0x2000;
@@ -514,7 +514,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmAndAllocationCo
allocation.setDefaultGmm(new Gmm(rootDeviceEnvironment.getGmmHelper(), allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize(), 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
allocation.getDefaultGmm()->isCompressionEnabled = true;
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
EXPECT_EQ(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, state->getCoherencyType());
EXPECT_TRUE(EncodeSurfaceState<FamilyType>::isAuxModeEnabled(state, allocation.getDefaultGmm()));
@@ -533,7 +533,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmCompressionDisa
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
uint64_t addr = 0x2000;
@@ -545,7 +545,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmCompressionDisa
GraphicsAllocation allocation(0, AllocationType::BUFFER, cpuAddr, gpuAddr, 0u, allocSize, MemoryPool::MemoryNull, 1);
allocation.setDefaultGmm(new Gmm(rootDeviceEnvironment.getGmmHelper(), allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize(), 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
EXPECT_EQ(UnitTestHelper<FamilyType>::getCoherencyTypeSupported(RENDER_SURFACE_STATE::COHERENCY_TYPE_IA_COHERENT), state->getCoherencyType());
EXPECT_EQ(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE, state->getAuxiliarySurfaceMode());
@@ -566,7 +566,7 @@ HWTEST_F(GfxCoreHelperTest, givenOverrideMocsIndexForScratchSpaceWhenSurfaceStat
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
uint64_t addr = 0x2000;
@@ -578,7 +578,7 @@ HWTEST_F(GfxCoreHelperTest, givenOverrideMocsIndexForScratchSpaceWhenSurfaceStat
GraphicsAllocation allocation(0, AllocationType::BUFFER, cpuAddr, gpuAddr, 0u, allocSize, MemoryPool::MemoryNull, 1);
allocation.setDefaultGmm(new Gmm(rootDeviceEnvironment.getGmmHelper(), allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize(), 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, false, false);
auto mocsProgrammed = state->getMemoryObjectControlState() >> 1;
EXPECT_EQ(1u, mocsProgrammed);
@@ -598,7 +598,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmAndAllocationCo
RENDER_SURFACE_STATE *state = reinterpret_cast<RENDER_SURFACE_STATE *>(stateBuffer);
memset(stateBuffer, 0, sizeof(RENDER_SURFACE_STATE));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
uint64_t addr = 0x2000;
@@ -611,7 +611,7 @@ HWTEST_F(GfxCoreHelperTest, givenCreatedSurfaceStateBufferWhenGmmAndAllocationCo
allocation.setDefaultGmm(new Gmm(rootDeviceEnvironment.getGmmHelper(), allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize(), 0, GMM_RESOURCE_USAGE_OCL_BUFFER, false, {}, true));
allocation.getDefaultGmm()->isCompressionEnabled = true;
SURFACE_TYPE type = RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER;
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, 0, pitch, &allocation, false, type, true, false);
EXPECT_EQ(UnitTestHelper<FamilyType>::getCoherencyTypeSupported(RENDER_SURFACE_STATE::COHERENCY_TYPE_IA_COHERENT), state->getCoherencyType());
EXPECT_EQ(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE, state->getAuxiliarySurfaceMode());
@@ -655,7 +655,7 @@ HWTEST_F(GfxCoreHelperTest, DISABLED_profilingCreationOfRenderSurfaceStateVsMemc
}
auto &rootDeviceEnvironment = pDevice->getRootDeviceEnvironment();
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t size = 0x1000;
uint64_t addr = 0x2000;
@@ -664,7 +664,7 @@ HWTEST_F(GfxCoreHelperTest, DISABLED_profilingCreationOfRenderSurfaceStateVsMemc
for (uint32_t i = 0; i < maxLoop; ++i) {
auto t1 = std::chrono::high_resolution_clock::now();
helper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, surfaceStates[i], size, addr, 0, pitch, nullptr, false, type, true, false);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, surfaceStates[i], size, addr, 0, pitch, nullptr, false, type, true, false);
auto t2 = std::chrono::high_resolution_clock::now();
timesCreate.push_back(t1);
timesCreate.push_back(t2);
@@ -757,8 +757,8 @@ TEST(GfxCoreHelperCacheFlushTest, givenEnableCacheFlushFlagIsReadPlatformSetting
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenGfxCoreHelperWhenGettingGlobalTimeStampBitsThenCorrectValueIsReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_EQ(helper.getGlobalTimeStampBits(), 36U);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getGlobalTimeStampBits(), 36U);
}
TEST_F(GfxCoreHelperTest, givenEnableLocalMemoryDebugVarAndOsEnableLocalMemoryWhenSetThenGetEnableLocalMemoryReturnsCorrectValue) {
@@ -784,26 +784,26 @@ TEST_F(GfxCoreHelperTest, givenEnableLocalMemoryDebugVarAndOsEnableLocalMemoryWh
TEST_F(GfxCoreHelperTest, givenAUBDumpForceAllToLocalMemoryDebugVarWhenSetThenGetEnableLocalMemoryReturnsCorrectValue) {
DebugManagerStateRestore dbgRestore;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo));
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
DebugManager.flags.AUBDumpForceAllToLocalMemory.set(true);
EXPECT_TRUE(helper.getEnableLocalMemory(hardwareInfo));
EXPECT_TRUE(gfxCoreHelper.getEnableLocalMemory(hardwareInfo));
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenVariousCachesRequestThenCorrectMocsIndexesAreReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getGmmHelper();
auto expectedMocsForL3off = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
auto expectedMocsForL3on = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
auto expectedMocsForL3andL1on = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST) >> 1;
auto mocsIndex = helper.getMocsIndex(*gmmHelper, false, true);
auto mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, false, true);
EXPECT_EQ(expectedMocsForL3off, mocsIndex);
mocsIndex = helper.getMocsIndex(*gmmHelper, true, false);
mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, false);
EXPECT_EQ(expectedMocsForL3on, mocsIndex);
mocsIndex = helper.getMocsIndex(*gmmHelper, true, true);
mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, true);
if (mocsIndex != expectedMocsForL3andL1on) {
EXPECT_EQ(expectedMocsForL3on, mocsIndex);
} else {
@@ -848,17 +848,17 @@ HWTEST_F(GfxCoreHelperTest, givenDebugVariableSetWhenAskingForAuxTranslationMode
HWTEST_F(GfxCoreHelperTest, givenDebugFlagWhenCheckingIfBufferIsSuitableForCompressionThenReturnCorrectValue) {
DebugManagerStateRestore restore;
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
DebugManager.flags.OverrideBufferSuitableForRenderCompression.set(0);
EXPECT_FALSE(helper.isBufferSizeSuitableForCompression(0, *defaultHwInfo));
EXPECT_FALSE(helper.isBufferSizeSuitableForCompression(KB, *defaultHwInfo));
EXPECT_FALSE(helper.isBufferSizeSuitableForCompression(KB + 1, *defaultHwInfo));
EXPECT_FALSE(gfxCoreHelper.isBufferSizeSuitableForCompression(0, *defaultHwInfo));
EXPECT_FALSE(gfxCoreHelper.isBufferSizeSuitableForCompression(KB, *defaultHwInfo));
EXPECT_FALSE(gfxCoreHelper.isBufferSizeSuitableForCompression(KB + 1, *defaultHwInfo));
DebugManager.flags.OverrideBufferSuitableForRenderCompression.set(1);
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(0, *defaultHwInfo));
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(KB, *defaultHwInfo));
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(KB + 1, *defaultHwInfo));
EXPECT_TRUE(gfxCoreHelper.isBufferSizeSuitableForCompression(0, *defaultHwInfo));
EXPECT_TRUE(gfxCoreHelper.isBufferSizeSuitableForCompression(KB, *defaultHwInfo));
EXPECT_TRUE(gfxCoreHelper.isBufferSizeSuitableForCompression(KB + 1, *defaultHwInfo));
}
HWTEST_F(GfxCoreHelperTest, WhenIsBankOverrideRequiredIsCalledThenFalseIsReturned) {
@@ -868,19 +868,19 @@ HWTEST_F(GfxCoreHelperTest, WhenIsBankOverrideRequiredIsCalledThenFalseIsReturne
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, GivenBarrierEncodingWhenCallingGetBarriersCountFromHasBarrierThenNumberOfBarriersIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(0u, gfxCoreHelper.getBarriersCountFromHasBarriers(0u));
EXPECT_EQ(1u, gfxCoreHelper.getBarriersCountFromHasBarriers(1u));
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, GivenVariousValuesWhenCallingCalculateAvailableThreadCountThenCorrectValueIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto result = gfxCoreHelper.calculateAvailableThreadCount(hardwareInfo, 0);
EXPECT_EQ(hardwareInfo.gtSystemInfo.ThreadCount, result);
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, GivenModifiedGtSystemInfoWhenCallingCalculateAvailableThreadCountThenCorrectValueIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = hardwareInfo;
for (auto threadCount : {1u, 5u, 9u}) {
hwInfo.gtSystemInfo.ThreadCount = threadCount;
@@ -914,16 +914,16 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenDefaultGfxCoreHelperHwWhenIs
}
HWTEST_F(GfxCoreHelperTest, givenDefaultGfxCoreHelperHwWhenMinimalSIMDSizeIsQueriedThen8IsReturned) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_EQ(8u, helper.getMinimalSIMDSize());
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(8u, gfxCoreHelper.getMinimalSIMDSize());
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, WhenIsFusedEuDispatchEnabledIsCalledThenFalseIsReturned) {
if (hardwareInfo.platform.eRenderCoreFamily == IGFX_GEN12LP_CORE) {
GTEST_SKIP();
}
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_FALSE(helper.isFusedEuDispatchEnabled(hardwareInfo, false));
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isFusedEuDispatchEnabled(hardwareInfo, false));
}
HWTEST_F(PipeControlHelperTests, WhenGettingPipeControSizeForCacheFlushThenReturnCorrectValue) {
@@ -993,7 +993,7 @@ HWTEST2_F(ProductHelperCommonTest, givenHardwareInfoAndDebugVariableNodeOrdinalE
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForIsaSystemMemoryPlacementThenReturnFalseIfLocalMemorySupported) {
DebugManagerStateRestore restorer;
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
hardwareInfo.featureTable.flags.ftrLocalMemory = true;
auto localMemoryEnabled = gfxCoreHelper.getEnableLocalMemory(hardwareInfo);
@@ -1015,7 +1015,7 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForIsaSystemMemoryPlacem
}
TEST_F(GfxCoreHelperTest, givenInvalidEngineTypeWhenGettingEngineGroupTypeThenThrow) {
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_ANY_THROW(gfxCoreHelper.getEngineGroupType(aub_stream::EngineType::NUM_ENGINES, EngineUsage::Regular, hardwareInfo));
EXPECT_ANY_THROW(gfxCoreHelper.getEngineGroupType(aub_stream::EngineType::ENGINE_VECS, EngineUsage::Regular, hardwareInfo));
}
@@ -1125,23 +1125,23 @@ HWTEST_F(GfxCoreHelperTest, GivenZeroSlmSizeWhenComputeSlmSizeIsCalledThenCorrec
}
HWTEST2_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCheckingSipWaThenFalseIsReturned, isTglLpOrBelow) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(helper.isSipWANeeded(*defaultHwInfo));
EXPECT_FALSE(gfxCoreHelper.isSipWANeeded(*defaultHwInfo));
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, givenGfxCoreHelperWhenGettingPlanarYuvHeightThenHelperReturnsCorrectValue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_EQ(helper.getPlanarYuvMaxHeight(), 16352u);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getPlanarYuvMaxHeight(), 16352u);
}
TEST_F(GfxCoreHelperTest, WhenGettingIsCpuImageTransferPreferredThenFalseIsReturned) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isCpuImageTransferPreferred(*defaultHwInfo));
}
TEST_F(GfxCoreHelperTest, whenFtrGpGpuMidThreadLevelPreemptFeatureDisabledThenFalseIsReturned) {
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
FeatureTable featureTable = {};
featureTable.flags.ftrGpGpuMidThreadLevelPreempt = false;
bool result = gfxCoreHelper.isAdditionalFeatureFlagRequired(&featureTable);
@@ -1149,18 +1149,18 @@ TEST_F(GfxCoreHelperTest, whenFtrGpGpuMidThreadLevelPreemptFeatureDisabledThenFa
}
HWTEST_F(GfxCoreHelperTest, whenGettingNumberOfCacheRegionsThenReturnZero) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(0u, gfxCoreHelper.getNumCacheRegions());
}
HWCMDTEST_F(IGFX_GEN8_CORE, GfxCoreHelperTest, whenCheckingForSmallKernelPreferenceThenFalseIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.preferSmallWorkgroupSizeForKernel(0u, this->pDevice->getHardwareInfo()));
EXPECT_FALSE(gfxCoreHelper.preferSmallWorkgroupSizeForKernel(20000u, this->pDevice->getHardwareInfo()));
}
HWTEST_F(GfxCoreHelperTest, whenSetCompressedFlagThenProperFlagSet) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmm = std::make_unique<MockGmm>(pDevice->getGmmHelper());
gmm->resourceParams.Flags.Info.RenderCompressed = 0;
@@ -1172,7 +1172,7 @@ HWTEST_F(GfxCoreHelperTest, whenSetCompressedFlagThenProperFlagSet) {
}
HWTEST_F(GfxCoreHelperTest, whenAdjustPreemptionSurfaceSizeIsCalledThenCsrSizeDoesntChange) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
size_t csrSize = 1024;
size_t oldCsrSize = csrSize;
gfxCoreHelper.adjustPreemptionSurfaceSize(csrSize);
@@ -1180,7 +1180,7 @@ HWTEST_F(GfxCoreHelperTest, whenAdjustPreemptionSurfaceSizeIsCalledThenCsrSizeDo
}
HWTEST_F(GfxCoreHelperTest, whenSetSipKernelDataIsCalledThenSipKernelDataDoesntChange) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
uint32_t *sipKernelBinary = nullptr;
uint32_t *oldSipKernelBinary = sipKernelBinary;
size_t kernelBinarySize = 1024;
@@ -1191,28 +1191,28 @@ HWTEST_F(GfxCoreHelperTest, whenSetSipKernelDataIsCalledThenSipKernelDataDoesntC
}
HWTEST_F(GfxCoreHelperTest, whenIsSipKernelAsHexadecimalArrayPreferredIsCalledThenReturnFalse) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isSipKernelAsHexadecimalArrayPreferred());
}
using isXeHpCoreOrBelow = IsAtMostProduct<IGFX_XE_HP_SDV>;
HWTEST2_F(GfxCoreHelperTest, givenXeHPAndBelowPlatformWhenCheckingIfUnTypedDataPortCacheFlushRequiredThenReturnFalse, isXeHpCoreOrBelow) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.unTypedDataPortCacheFlushRequired());
}
HWTEST2_F(GfxCoreHelperTest, givenXeHPAndBelowPlatformPlatformWhenCheckingIfEngineTypeRemappingIsRequiredThenReturnFalse, isXeHpCoreOrBelow) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isEngineTypeRemappingToHwSpecificRequired());
}
HWTEST2_F(GfxCoreHelperTest, givenAtMostGen12lpPlatformiWhenCheckingIfScratchSpaceSurfaceStateAccessibleThenFalseIsReturned, IsAtMostGen12lp) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isScratchSpaceSurfaceStateAccessible());
}
HWTEST2_F(GfxCoreHelperTest, givenAtLeastXeHpPlatformWhenCheckingIfScratchSpaceSurfaceStateAccessibleTheniTrueIsReturned, IsAtLeastXeHpCore) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isScratchSpaceSurfaceStateAccessible());
}
@@ -1222,7 +1222,7 @@ HWTEST_F(GfxCoreHelperTest, givenGetRenderSurfaceStateBaseAddressCalledThenCorre
RENDER_SURFACE_STATE renderSurfaceState;
uint64_t expectedBaseAddress = 0x1122334455667788;
renderSurfaceState.setSurfaceBaseAddress(expectedBaseAddress);
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(expectedBaseAddress, gfxCoreHelper.getRenderSurfaceStateBaseAddress(&renderSurfaceState));
}
@@ -1232,15 +1232,15 @@ HWTEST_F(GfxCoreHelperTest, givenGetRenderSurfaceStatePitchCalledThenCorrectValu
RENDER_SURFACE_STATE renderSurfaceState;
uint32_t expectedPitch = 0x400;
renderSurfaceState.setSurfacePitch(expectedPitch);
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(expectedPitch, gfxCoreHelper.getRenderSurfaceStatePitch(&renderSurfaceState));
}
TEST(GfxCoreHelperTests, whenBlitterSupportIsDisabledThenDontExposeAnyBcsEngine) {
HWTEST_F(GfxCoreHelperTest, whenBlitterSupportIsDisabledThenDontExposeAnyBcsEngine) {
auto hwInfo = *defaultHwInfo;
hwInfo.capabilityTable.blitterOperationsSupported = false;
hwInfo.featureTable.ftrBcsInfo.set(0);
const auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto engineUsageTypes = gfxCoreHelper.getGpgpuEngineInstances(hwInfo);
for (auto &engineUsageType : engineUsageTypes) {
EXPECT_FALSE(EngineHelpers::isBcs(engineUsageType.first));
@@ -1260,22 +1260,22 @@ HWTEST2_F(GfxCoreHelperTest, givenXeHpOrXeHpgCoreWhenDisableL3ForDebugCalledThen
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenFalseIsReturned) {
auto &gfxCoreHelper = NEO::GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isRevisionSpecificBinaryBuiltinRequired());
}
HWTEST2_F(GfxCoreHelperTest, givenDG2GfxCoreHelperWhenGettingIsPlatformFlushTaskEnabledThenTrueIsReturned, IsDG2) {
auto &gfxCoreHelper = NEO::GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
}
HWTEST2_F(GfxCoreHelperTest, givenPvcGfxCoreHelperWhenGettingIsPlatformFlushTaskEnabledThenTrueIsReturned, IsPVC) {
auto &gfxCoreHelper = NEO::GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
}
HWTEST2_F(GfxCoreHelperTest, givenAtMostGen12lpGfxCoreHelperWhenGettingIsPlatformFlushTaskEnabledThenFalseIsReturned, IsAtMostGen12lp) {
auto &gfxCoreHelper = NEO::GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
}
@@ -1288,7 +1288,7 @@ struct CoherentWANotNeeded {
}
};
HWTEST2_F(GfxCoreHelperTest, givenProductHelperWhenCheckingForceNonGpuCoherencyWAThenPassedValueReturned, CoherentWANotNeeded) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.forceNonGpuCoherencyWA(true));
EXPECT_FALSE(gfxCoreHelper.forceNonGpuCoherencyWA(false));
}
@@ -1303,18 +1303,18 @@ struct ForceNonCoherentMode {
};
HWTEST2_F(GfxCoreHelperTest, givenProductHelperWhenCheckingForceNonGpuCoherencyWAThenFalseIsReturned, ForceNonCoherentMode) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.forceNonGpuCoherencyWA(true));
EXPECT_FALSE(gfxCoreHelper.forceNonGpuCoherencyWA(false));
}
HWTEST_F(GfxCoreHelperTest, GivenHwInfoWhenGetBatchBufferEndSizeCalledThenCorrectSizeReturned) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getBatchBufferEndSize(), sizeof(typename FamilyType::MI_BATCH_BUFFER_END));
}
HWTEST_F(GfxCoreHelperTest, GivenHwInfoWhenGetBatchBufferEndReferenceCalledThenCorrectPtrReturned) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getBatchBufferEndReference(), reinterpret_cast<const void *>(&FamilyType::cmdInitBatchBufferEnd));
}
@@ -1331,23 +1331,23 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenPassingComputeEngineTypeThenIt
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForRelaxedOrderingSupportThenReturnFalse) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isRelaxedOrderingSupported());
}
HWTEST2_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCallCopyThroughLockedPtrEnabledThenReturnFalse, IsNotXeHpgOrXeHpcCore) {
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.copyThroughLockedPtrEnabled(*defaultHwInfo));
}
HWTEST2_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCallGetAmountOfAllocationsToFillThenReturnFalse, IsNotXeHpcCore) {
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getAmountOfAllocationsToFill(), 0u);
}
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenFlagSetAndCallCopyThroughLockedPtrEnabledThenReturnCorrectValue) {
DebugManagerStateRestore restorer;
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
DebugManager.flags.ExperimentalCopyThroughLock.set(0);
EXPECT_FALSE(gfxCoreHelper.copyThroughLockedPtrEnabled(*defaultHwInfo));
@@ -1357,7 +1357,7 @@ HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenFlagSetAndCallCopyThroughLocke
HWTEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenFlagSetAndCallGetAmountOfAllocationsToFillThenReturnCorrectValue) {
DebugManagerStateRestore restorer;
GfxCoreHelper &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
DebugManager.flags.SetAmountOfReusableAllocations.set(0);
EXPECT_EQ(gfxCoreHelper.getAmountOfAllocationsToFill(), 0u);
@@ -1377,7 +1377,7 @@ HWTEST2_F(GfxCoreHelperTest, GivenVariousValuesAndXeHpOrXeHpgCoreWhenCallingCalc
{256, 4}}};
const auto &hwInfo = *defaultHwInfo;
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
for (const auto &[grfCount, expectedThreadCountPerEu] : grfTestInputs) {
auto expected = expectedThreadCountPerEu * hwInfo.gtSystemInfo.EUCount;
auto result = gfxCoreHelper.calculateAvailableThreadCount(hwInfo, grfCount);
@@ -1389,7 +1389,7 @@ HWTEST2_F(GfxCoreHelperTest, GivenModifiedGtSystemInfoAndXeHpOrXeHpgCoreWhenCall
std::array<std::tuple<uint32_t, uint32_t, uint32_t>, 3> testInputs = {{{1, 64, 1},
{5, 128, 5},
{8, 256, 4}}};
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = hardwareInfo;
for (const auto &[threadCount, grfCount, expectedThreadCount] : testInputs) {
hwInfo.gtSystemInfo.ThreadCount = threadCount;
@@ -1399,26 +1399,26 @@ HWTEST2_F(GfxCoreHelperTest, GivenModifiedGtSystemInfoAndXeHpOrXeHpgCoreWhenCall
}
HWTEST2_F(GfxCoreHelperTest, givenAtMostGen12lpPlatformWhenGettingMinimalScratchSpaceSizeThen1024IsReturned, IsAtMostGen12lp) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(1024U, gfxCoreHelper.getMinimalScratchSpaceSize());
}
HWTEST2_F(GfxCoreHelperTest, givenAtLeastXeHpPlatformWhenGettingMinimalScratchSpaceSizeThen64IsReturned, IsAtLeastXeHpCore) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(64U, gfxCoreHelper.getMinimalScratchSpaceSize());
}
TEST(GfxCoreHelperTests, whenIsDynamicallyPopulatedisFalseThengetHighestEnabledSliceReturnsMaxSlicesSupported) {
HWTEST_F(GfxCoreHelperTest, whenIsDynamicallyPopulatedisFalseThengetHighestEnabledSliceReturnsMaxSlicesSupported) {
auto hwInfo = *defaultHwInfo;
hwInfo.gtSystemInfo.IsDynamicallyPopulated = false;
hwInfo.gtSystemInfo.MaxSlicesSupported = 4;
const auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto maxSlice = gfxCoreHelper.getHighestEnabledSlice(hwInfo);
EXPECT_EQ(maxSlice, hwInfo.gtSystemInfo.MaxSlicesSupported);
}
TEST(GfxCoreHelperTests, whenIsDynamicallyPopulatedisTrueThengetHighestEnabledSliceReturnsHighestEnabledSliceInfo) {
HWTEST_F(GfxCoreHelperTest, whenIsDynamicallyPopulatedisTrueThengetHighestEnabledSliceReturnsHighestEnabledSliceInfo) {
auto hwInfo = *defaultHwInfo;
hwInfo.gtSystemInfo.IsDynamicallyPopulated = true;
@@ -1427,17 +1427,17 @@ TEST(GfxCoreHelperTests, whenIsDynamicallyPopulatedisTrueThengetHighestEnabledSl
hwInfo.gtSystemInfo.SliceInfo[i].Enabled = false;
}
hwInfo.gtSystemInfo.SliceInfo[6].Enabled = true;
const auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto maxSlice = gfxCoreHelper.getHighestEnabledSlice(hwInfo);
EXPECT_EQ(maxSlice, 7u);
}
HWTEST_F(ProductHelperCommonTest, givenPatIndexAndAllocationTypeWhenCallOverridePatIndexThenSameIndexIsReturned) {
auto &helper = getHelper<ProductHelper>();
auto &gfxCoreHelper = getHelper<ProductHelper>();
uint64_t patIndex = 1u;
auto allocationType = NEO::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER;
EXPECT_EQ(patIndex, helper.overridePatIndex(allocationType, patIndex));
EXPECT_EQ(patIndex, gfxCoreHelper.overridePatIndex(allocationType, patIndex));
allocationType = NEO::AllocationType::BUFFER;
patIndex = 3u;
EXPECT_EQ(patIndex, helper.overridePatIndex(allocationType, patIndex));
EXPECT_EQ(patIndex, gfxCoreHelper.overridePatIndex(allocationType, patIndex));
}

7
shared/test/unit_test/helpers/hw_helper_tests_dg2_and_later.cpp
View File

@@ -13,6 +13,7 @@
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/unit_test_helper.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/test_macros/hw_test.h"
using namespace NEO;
@@ -190,12 +191,14 @@ HWTEST2_F(PipeControlHelperTestsDg2AndLater, givenDebugDisableCacheFlushWhenProg
}
HWTEST2_F(GfxCoreHelperDg2AndLaterTest, givenXeHPGAndLaterPlatformWhenCheckingIfUnTypedDataPortCacheFlushRequiredThenReturnTrue, IsAtLeastXeHpgCore) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.unTypedDataPortCacheFlushRequired());
}
HWTEST2_F(GfxCoreHelperDg2AndLaterTest, givenGfxCoreHelperWhenCheckIsUpdateTaskCountFromWaitSupportedThenReturnsTrue, IsAtLeastXeHpgCore) {
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isUpdateTaskCountFromWaitSupported());
}

4
shared/test/unit_test/helpers/hw_helper_tests_dg2_or_below.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/helpers/hw_helper.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/test_macros/hw_test.h"
using namespace NEO;
@@ -15,6 +16,7 @@ using GfxCoreHelperDg2OrBelowTests = ::testing::Test;
using isDG2OrBelow = IsAtMostProduct<IGFX_DG2>;
HWTEST2_F(GfxCoreHelperDg2OrBelowTests, WhenGettingIsKmdMigrationSupportedThenFalseIsReturned, isDG2OrBelow) {
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isKmdMigrationSupported(*defaultHwInfo));
}

20
shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp
View File

@@ -19,18 +19,18 @@ using GfxCoreHelperTestPvcAndLater = GfxCoreHelperTest;
HWTEST2_F(GfxCoreHelperTestPvcAndLater, givenVariousCachesRequestsThenProperMocsIndexesAreBeingReturned, IsAtLeastXeHpcCore) {
DebugManagerStateRestore restore;
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto gmmHelper = this->pDevice->getRootDeviceEnvironment().getGmmHelper();
auto expectedMocsForL3off = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
auto expectedMocsForL3on = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) >> 1;
auto mocsIndex = helper.getMocsIndex(*gmmHelper, false, true);
auto mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, false, true);
EXPECT_EQ(expectedMocsForL3off, mocsIndex);
mocsIndex = helper.getMocsIndex(*gmmHelper, true, false);
mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, false);
EXPECT_EQ(expectedMocsForL3on, mocsIndex);
mocsIndex = helper.getMocsIndex(*gmmHelper, true, true);
mocsIndex = gfxCoreHelper.getMocsIndex(*gmmHelper, true, true);
EXPECT_EQ(expectedMocsForL3on, mocsIndex);
}
@@ -54,7 +54,7 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, GivenVariousValuesAndPvcAndLaterPlatform
{160, 6},
{192, 5},
{256, 4}}};
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
for (const auto &[grfCount, expectedThreadCountPerEu] : grfTestInputs) {
auto expected = expectedThreadCountPerEu * hardwareInfo.gtSystemInfo.EUCount;
auto result = gfxCoreHelper.calculateAvailableThreadCount(hardwareInfo, grfCount);
@@ -66,7 +66,7 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, GivenModifiedGtSystemInfoAndPvcAndLaterP
std::array<std::pair<uint32_t, uint32_t>, 3> testInputs = {{{64, 256},
{96, 384},
{128, 512}}};
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = hardwareInfo;
for (const auto &[euCount, expectedThreadCount] : testInputs) {
hwInfo.gtSystemInfo.EUCount = euCount;
@@ -76,13 +76,13 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, GivenModifiedGtSystemInfoAndPvcAndLaterP
}
HWTEST2_F(GfxCoreHelperTestPvcAndLater, givenGfxCoreHelperWhenCheckIsUpdateTaskCountFromWaitSupportedThenReturnsTrue, IsAtLeastXeHpcCore) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isUpdateTaskCountFromWaitSupported());
}
HWTEST2_F(GfxCoreHelperTestPvcAndLater, givenComputeEngineAndCooperativeUsageWhenGetEngineGroupTypeIsCalledThenCooperativeComputeGroupTypeIsReturned, IsAtLeastXeHpcCore) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = *::defaultHwInfo;
hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 4;
aub_stream::EngineType engineTypes[] = {aub_stream::EngineType::ENGINE_CCS, aub_stream::EngineType::ENGINE_CCS1,
@@ -101,12 +101,12 @@ HWTEST2_F(GfxCoreHelperTestPvcAndLater, givenComputeEngineAndCooperativeUsageWhe
}
HWTEST2_F(GfxCoreHelperTestPvcAndLater, givenPVCAndLaterPlatformWhenCheckingIfEngineTypeRemappingIsRequiredThenReturnTrue, IsAtLeastXeHpcCore) {
const auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isEngineTypeRemappingToHwSpecificRequired());
}
HWTEST2_F(GfxCoreHelperTestPvcAndLater, WhenIsRcsAvailableIsCalledThenCorrectValueIsReturned, IsAtLeastXeHpcCore) {
auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = *::defaultHwInfo;
aub_stream::EngineType defaultEngineTypes[] = {aub_stream::EngineType::ENGINE_RCS, aub_stream::EngineType::ENGINE_CCCS,
aub_stream::EngineType::ENGINE_BCS, aub_stream::EngineType::ENGINE_BCS2,

2
shared/test/unit_test/helpers/timestamp_packet_tests.cpp
View File

@@ -276,7 +276,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTimestampPacketTests, givenInvalidDebugFlagSe
HWTEST_F(DeviceTimestampPacketTests, givenTagAlignmentWhenCreatingAllocatorThenGpuAddressIsAligned) {
auto csr = executionEnvironment->memoryManager->getRegisteredEngines()[0].commandStreamReceiver;
auto &gfxCoreHelper = GfxCoreHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
auto allocator = csr->getTimestampPacketAllocator();

2
shared/test/unit_test/memory_manager/memory_manager_allocate_in_device_pool_tests.cpp
View File

@@ -260,7 +260,7 @@ HWTEST_F(MemoryManagerTests, givenEnabledLocalMemoryWhenAllocatingDebugAreaThenH
mockDeviceBitfield};
properties.flags.use32BitFrontWindow = true;
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto systemMemoryPlacement = gfxCoreHelper.useSystemMemoryPlacementForISA(*defaultHwInfo);
HeapIndex expectedHeap = HeapIndex::TOTAL_HEAPS;

10
shared/test/unit_test/memory_manager/surface_tests.cpp
View File

@@ -61,7 +61,9 @@ HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehaves
DeviceBitfield deviceBitfield(1);
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0, deviceBitfield);
auto hwInfo = *defaultHwInfo;
auto engine = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(hwInfo)[0];
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(engine, PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
csr->setupContext(*osContext);
@@ -115,7 +117,8 @@ HWTEST_F(GeneralSurfaceTest, givenGeneralSurfaceWhenMigrationNeededThenMoveToGpu
DeviceBitfield deviceBitfield(1);
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0, deviceBitfield);
auto hwInfo = *defaultHwInfo;
auto engine = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(hwInfo)[0];
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(engine, PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
csr->setupContext(*osContext);
@@ -137,7 +140,8 @@ HWTEST_F(GeneralSurfaceTest, givenGeneralSurfaceWhenMigrationNotNeededThenMoveTo
DeviceBitfield deviceBitfield(1);
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0, deviceBitfield);
auto hwInfo = *defaultHwInfo;
auto engine = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(hwInfo)[0];
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor(engine, PreemptionHelper::getDefaultPreemptionMode(hwInfo)));
csr->setupContext(*osContext);

2
shared/test/unit_test/os_interface/linux/drm_cache_info_tests.cpp
View File

@@ -21,7 +21,7 @@ TEST(DrmCacheInfoTest, givenCacheRegionsExistsWhenCallingSetUpCacheInfoThenCache
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
auto &gfxCoreHelper = GfxCoreHelper::get(drm.context.hwInfo->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
drm.setupCacheInfo(*defaultHwInfo.get());

14
shared/test/unit_test/os_interface/linux/drm_residency_handler_prelim_tests.cpp
View File

@@ -877,7 +877,7 @@ HWTEST_F(DrmMemoryOperationsHandlerBindTest, givenPatIndexProgrammingEnabledWhen
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor());
csr->setupContext(*osContext);
auto &gfxCoreHelper = GfxCoreHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto productHelper = ProductHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily);
bool closSupported = (gfxCoreHelper.getNumCacheRegions() > 0);
@@ -936,7 +936,7 @@ HWTEST_F(DrmMemoryOperationsHandlerBindTest, givenPatIndexErrorAndUncachedDebugF
auto csr = std::make_unique<UltCommandStreamReceiver<FamilyType>>(*executionEnvironment, 0, DeviceBitfield(1));
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), EngineDescriptorHelper::getDefaultDescriptor());
csr->setupContext(*osContext);
auto &gfxCoreHelper = GfxCoreHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto productHelper = ProductHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily);
bool closSupported = (gfxCoreHelper.getNumCacheRegions() > 0);
bool patIndexProgrammingSupported = productHelper->isVmBindPatIndexProgrammingSupported();
@@ -997,7 +997,7 @@ HWTEST_F(DrmMemoryOperationsHandlerBindTest, givenDebugFlagSetWhenVmBindCalledTh
auto timestampStorageAlloc = csr->getTimestampPacketAllocator()->getTag()->getBaseGraphicsAllocation()->getDefaultGraphicsAllocation();
auto &gfxCoreHelper = GfxCoreHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
if (gfxCoreHelper.getNumCacheRegions() == 0) {
GTEST_SKIP();
@@ -1023,7 +1023,7 @@ TEST_F(DrmMemoryOperationsHandlerBindTest, givenClosEnabledAndAllocationToBeCach
mock->cacheInfo.reset(new CacheInfo(*mock, 64 * MemoryConstants::kiloByte, 2, 32));
auto &gfxCoreHelper = GfxCoreHelper::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eRenderCoreFamily);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
if (gfxCoreHelper.getNumCacheRegions() == 0) {
GTEST_SKIP();
@@ -1051,7 +1051,8 @@ TEST_F(DrmMemoryOperationsHandlerBindTest, givenClosEnabledAndAllocationToBeCach
}
TEST(DrmResidencyHandlerTests, givenClosIndexAndMemoryTypeWhenAskingForPatIndexThenReturnCorrectValue) {
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
if (gfxCoreHelper.getNumCacheRegions() == 0) {
EXPECT_ANY_THROW(gfxCoreHelper.getPatIndex(CacheRegion::Default, CachePolicy::Uncached));
@@ -1078,7 +1079,8 @@ TEST(DrmResidencyHandlerTests, givenForceAllResourcesUnchashedSetAskingForPatInd
DebugManagerStateRestore restorer;
DebugManager.flags.ForceAllResourcesUncached.set(1);
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
if (gfxCoreHelper.getNumCacheRegions() == 0) {
EXPECT_ANY_THROW(gfxCoreHelper.getPatIndex(CacheRegion::Default, CachePolicy::Uncached));

3
shared/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp
View File

@@ -302,7 +302,8 @@ TEST_F(MockProductHelperTestLinux, givenPointerToHwInfoWhenConfigureHwInfoCalled
int ret = mockProductHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret);
auto expectedSize = static_cast<size_t>(outHwInfo.gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte);
GfxCoreHelper::get(outHwInfo.platform.eRenderCoreFamily).adjustPreemptionSurfaceSize(expectedSize);
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
gfxCoreHelper.adjustPreemptionSurfaceSize(expectedSize);
EXPECT_EQ(expectedSize, outHwInfo.capabilityTable.requiredPreemptionSurfaceSize);
}

7
shared/test/unit_test/os_interface/windows/os_context_win_tests.cpp
View File

@@ -16,7 +16,8 @@ struct OsContextWinTest : public WddmTestWithMockGdiDll {
void SetUp() override {
WddmTestWithMockGdiDll::SetUp();
preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
engineTypeUsage = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0];
auto &gfxCoreHelper = this->rootDeviceEnvironment->getHelper<GfxCoreHelper>();
engineTypeUsage = gfxCoreHelper.getGpgpuEngineInstances(*defaultHwInfo)[0];
init();
}
@@ -72,7 +73,9 @@ struct OsContextWinTestNoCleanup : public WddmTestWithMockGdiDllNoCleanup {
void SetUp() override {
WddmTestWithMockGdiDllNoCleanup::SetUp();
preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
engineTypeUsage = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0];
auto &gfxCoreHelper = this->rootDeviceEnvironment->getHelper<GfxCoreHelper>();
engineTypeUsage = gfxCoreHelper.getGpgpuEngineInstances(*defaultHwInfo)[0];
init();
}

3
shared/test/unit_test/os_interface/windows/wddm_preemption_tests.cpp
View File

@@ -41,7 +41,8 @@ class WddmPreemptionTests : public Test<WddmFixtureWithMockGdiDll> {
wddm->init();
hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
ASSERT_NE(nullptr, hwInfo);
auto engine = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(*defaultHwInfo)[0];
osContext = std::make_unique<OsContextWin>(*wddm, 0, 0u, EngineDescriptorHelper::getDefaultDescriptor(engine, preemptionMode));
osContext->ensureContextInitialized();
}

4
shared/test/unit_test/os_interface/windows/wddm_shared_allocations_test.cpp
View File

@@ -42,8 +42,8 @@ class WddmSharedTestsFixture : public MockExecutionEnvironmentGmmFixture {
wddm->init();
wddm->wddmInterface.reset(wddmMockInterface);
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto engine = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto &gfxCoreHelper = rootDeviceEnvironment->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(*defaultHwInfo)[0];
osContext = std::make_unique<OsContextWin>(*osInterface->getDriverModel()->as<Wddm>(), 0, 0u, EngineDescriptorHelper::getDefaultDescriptor(engine, preemptionMode));
osContext->ensureContextInitialized();
}

5
shared/test/unit_test/os_interface/windows/wddm_tests.cpp
View File

@@ -407,9 +407,8 @@ struct WddmSkipResourceCleanupFixtureWithMockGdiDll : public GdiDllFixture, publ
wddmMockInterface = static_cast<WddmMockInterface20 *>(wddm->wddmInterface.release());
wddm->init();
wddm->wddmInterface.reset(wddmMockInterface);
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto engine = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto &gfxCoreHelper = rootDeviceEnvironment->getHelper<GfxCoreHelper>();
auto engine = gfxCoreHelper.getGpgpuEngineInstances(*defaultHwInfo)[0];
osContext = std::make_unique<OsContextWin>(*osInterface->getDriverModel()->as<Wddm>(), 0, 0u, EngineDescriptorHelper::getDefaultDescriptor(engine, preemptionMode));
osContext->ensureContextInitialized();
}

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

@@ -453,7 +453,9 @@ HWTEST_F(MidThreadPreemptionTests, givenMidThreadPreemptionWhenFailingOnCsrSurfa
GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const AllocationData &allocationData) override {
auto hwInfo = executionEnvironment.rootDeviceEnvironments[allocationData.rootDeviceIndex]->getHardwareInfo();
if (++allocateGraphicsMemoryCount > GfxCoreHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo).size() - 1) {
auto &gfxCoreHelper = executionEnvironment.rootDeviceEnvironments[allocationData.rootDeviceIndex]->template getHelper<GfxCoreHelper>();
if (++allocateGraphicsMemoryCount > gfxCoreHelper.getGpgpuEngineInstances(*hwInfo).size() - 1) {
return nullptr;
}
return OsAgnosticMemoryManager::allocateGraphicsMemoryWithAlignment(allocationData);

24
shared/test/unit_test/xe_hpc_core/hw_helper_xe_hpc_core_tests.cpp
View File

@@ -8,6 +8,7 @@
#include "shared/source/helpers/hw_helper.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/hw_helper_tests.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
@@ -43,7 +44,8 @@ XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenSlmSizeWhenEncodingThenReturn
{11, 128 * KB}};
auto hwInfo = *defaultHwInfo;
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
for (auto &testInput : computeSlmValuesXeHpcTestsInput) {
EXPECT_EQ(testInput.expected, gfxCoreHelper.computeSlmValues(hwInfo, testInput.slmSize));
@@ -53,18 +55,21 @@ XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenSlmSizeWhenEncodingThenReturn
}
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, WhenGettingIsCpuImageTransferPreferredThenTrueIsReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isCpuImageTransferPreferred(*defaultHwInfo));
}
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenGfxCoreHelperWhenGettingIfRevisionSpecificBinaryBuiltinIsRequiredThenTrueIsReturned) {
auto &gfxCoreHelper = NEO::GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isRevisionSpecificBinaryBuiltinRequired());
}
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenGfxCoreHelperWhenCheckTimestampWaitSupportThenReturnTrue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
EXPECT_TRUE(helper.isTimestampWaitSupportedForQueues());
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isTimestampWaitSupportedForQueues());
}
using ProductHelperTestXeHpcCore = Test<DeviceFixture>;
@@ -76,24 +81,25 @@ XE_HPC_CORETEST_F(ProductHelperTestXeHpcCore, givenProductHelperWhenCheckTimesta
XE_HPC_CORETEST_F(GfxCoreHelperXeHpcCoreTest, givenXeHPCPlatformWhenCheckAssignEngineRoundRobinSupportedThenReturnTrue) {
auto hwInfo = *defaultHwInfo;
auto &gfxCoreHelper = GfxCoreHelperHw<FamilyType>::get();
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.isAssignEngineRoundRobinSupported(hwInfo), ProductHelper::get(hwInfo.platform.eProductFamily)->isAssignEngineRoundRobinSupported());
}
XE_HPC_CORETEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCallCopyThroughLockedPtrEnabledThenReturnTrue) {
auto &gfxCoreHelper = GfxCoreHelperHw<FamilyType>::get();
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.copyThroughLockedPtrEnabled(*defaultHwInfo));
}
XE_HPC_CORETEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenCallGetAmountOfAllocationsToFillThenReturnTrue) {
auto &gfxCoreHelper = GfxCoreHelperHw<FamilyType>::get();
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_EQ(gfxCoreHelper.getAmountOfAllocationsToFill(), 1u);
}
HWTEST_EXCLUDE_PRODUCT(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForRelaxedOrderingSupportThenReturnFalse, IGFX_XE_HPC_CORE);
XE_HPC_CORETEST_F(GfxCoreHelperTest, givenGfxCoreHelperWhenAskingForRelaxedOrderingSupportThenReturnTrue) {
auto &gfxCoreHelper = GfxCoreHelperHw<FamilyType>::get();
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_TRUE(gfxCoreHelper.isRelaxedOrderingSupported());
}

4
shared/test/unit_test/xe_hpc_core/pvc/engine_node_helper_tests_pvc.cpp
View File

@@ -153,7 +153,7 @@ PVCTEST_F(EngineNodeHelperPvcTests, givenCccsDisabledWhenGetGpgpuEnginesCalledTh
}
PVCTEST_F(EngineNodeHelperPvcTests, givenCCSEngineWhenCallingIsCooperativeDispatchSupportedThenTrueIsReturned) {
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = *defaultHwInfo;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCS;
@@ -165,7 +165,7 @@ PVCTEST_F(EngineNodeHelperPvcTests, givenCCSEngineWhenCallingIsCooperativeDispat
PVCTEST_F(EngineNodeHelperPvcTests, givenCCCSEngineAndRevisionBWhenCallingIsCooperativeDispatchSupportedThenFalseIsReturned) {
const auto &productHelper = getHelper<ProductHelper>();
const auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
const auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = *defaultHwInfo;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCCS;

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

@@ -546,7 +546,7 @@ XE_HPC_CORETEST_F(EncodeKernelXeHpcCoreTest, givenMultipleTilesAndImplicitScalin
hwInfo.gtSystemInfo.DualSubSliceCount = hwInfo.gtSystemInfo.MaxDualSubSlicesSupported;
INTERFACE_DESCRIPTOR_DATA iddArg = FamilyType::cmdInitInterfaceDescriptorData;
const uint32_t numGrf = GrfConfig::DefaultGrfNumber;
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
const uint32_t threadGroupCount = gfxCoreHelper.calculateAvailableThreadCount(hwInfo, numGrf) / 32u;
iddArg.setNumberOfThreadsInGpgpuThreadGroup(64u);
@@ -590,7 +590,7 @@ XE_HPC_CORETEST_F(EncodeKernelXeHpcCoreTest, givenDifferentNumGrfWhenCallingAdju
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hwInfo);
INTERFACE_DESCRIPTOR_DATA iddArg = FamilyType::cmdInitInterfaceDescriptorData;
auto &gfxCoreHelper = GfxCoreHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = pDevice->getGfxCoreHelper();
const uint32_t numberOfThreadsInThreadGroup = 1u;
const uint32_t threadGroupCount = gfxCoreHelper.calculateAvailableThreadCount(hwInfo, GrfConfig::DefaultGrfNumber);

4
shared/test/unit_test/xe_hpg_core/dg2/hw_helper_tests_dg2.cpp
View File

@@ -11,6 +11,7 @@
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/gtest_helpers.h"
#include "shared/test/common/helpers/hw_helper_tests.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/mocks/ult_device_factory.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/common/test_macros/test.h"
@@ -20,7 +21,8 @@ using namespace NEO;
using GfxCoreHelperTestDg2 = ::testing::Test;
DG2TEST_F(GfxCoreHelperTestDg2, whenGetExtensionsIsCalledThenMatrixMultiplyAccumulateExtensionsAreReturned) {
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
MockExecutionEnvironment mockExecutionEnvironment{};
auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
auto extensions = gfxCoreHelper.getExtensions(*defaultHwInfo);
EXPECT_TRUE(hasSubstr(extensions, std::string("cl_intel_subgroup_matrix_multiply_accumulate")));

11
shared/test/unit_test/xe_hpg_core/hw_helper_tests_xe_hpg_core.cpp
View File

@@ -96,7 +96,7 @@ XE_HPG_CORETEST_F(LriHelperTestsXeHpgCore, whenProgrammingLriCommandThenExpectMm
}
XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, givenAllocDataWhenSetExtraAllocationDataThenSetLocalMemForProperTypes) {
auto &gfxCoreHelper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
for (int type = 0; type < static_cast<int>(AllocationType::COUNT); type++) {
AllocationProperties allocProperties(0, 1, static_cast<AllocationType>(type), {});
@@ -138,10 +138,9 @@ XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, GivenVariousValuesWhenAlignSlmSize
}
XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, givenGfxCoreHelperWhenGettingThreadsPerEUConfigsThenCorrectConfigsAreReturned) {
auto &helper = GfxCoreHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
EXPECT_NE(nullptr, &helper);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto &configs = helper.getThreadsPerEUConfigs();
auto &configs = gfxCoreHelper.getThreadsPerEUConfigs();
EXPECT_EQ(2U, configs.size());
EXPECT_EQ(4U, configs[0]);
@@ -201,7 +200,7 @@ XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, givenDisablePipeControlFlagIsEnabl
}
XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, givenXeHpgCoreWhenCheckingIfEngineTypeRemappingIsRequiredThenReturnTrue) {
const auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.isEngineTypeRemappingToHwSpecificRequired());
}
@@ -288,6 +287,6 @@ XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore,
}
XE_HPG_CORETEST_F(GfxCoreHelperTestXeHpgCore, givenGfxCoreHelperWhenCallCopyThroughLockedPtrEnabledThenReturnFalse) {
const auto &gfxCoreHelper = GfxCoreHelper::get(hardwareInfo.platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
EXPECT_FALSE(gfxCoreHelper.copyThroughLockedPtrEnabled(*defaultHwInfo));
}

6
shared/test/unit_test/xe_hpg_core/mtl/hw_helper_tests_mtl.cpp
View File

@@ -20,7 +20,7 @@ using namespace NEO;
using GfxCoreHelperTestMtl = GfxCoreHelperTest;
MTLTEST_F(GfxCoreHelperTestMtl, givenVariousMtlReleasesWhenGetExtensionsIsCalledThenMatrixMultiplyAccumulateExtensionsAreCorrectlyReported) {
auto &gfxCoreHelper = GfxCoreHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto hwInfo = *defaultHwInfo;
unsigned int gmdReleases[] = {70, 71, 72, 73};
hwInfo.ipVersion.architecture = 12;
@@ -60,9 +60,9 @@ MTLTEST_F(ProductHelperTestMtl, givenPatIndexAndAllocationTypeWhenCallOverridePa
}
MTLTEST_F(GfxCoreHelperTestMtl, givenAllocationThenCheckResourceCompatibilityReturnsTrue) {
auto &helper = GfxCoreHelper::get(renderCoreFamily);
auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
auto allocation = std::make_unique<GraphicsAllocation>(0, AllocationType::BUFFER, nullptr, 0u, 0, MemoryPool::MemoryNull, 3u, 0llu);
EXPECT_TRUE(helper.checkResourceCompatibility(*allocation));
EXPECT_TRUE(gfxCoreHelper.checkResourceCompatibility(*allocation));
}
MTLTEST_F(GfxCoreHelperTestMtl, givenisCompressionEnabledAndWaAuxTable64KGranularWhenCheckIs1MbAlignmentSupportedThenReturnCorrectValue) {