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

Add xe_hpg shared unit tests 

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski 2021-11-22 10:18:53 +00:00 committed by Compute-Runtime-Automation
parent 182b476c67
commit 8a84170e72
9 changed files with 443 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
shared/test/unit_test/command_container/CMakeLists.txt
View File

@ -9,4 +9,11 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/command_container_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/command_encoder_tests.cpp
)
if(TESTS_DG2_AND_LATER)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/command_encoder_tests_xe_hpg_core_and_later.cpp
)
endif()
add_subdirectories()

50
shared/test/unit_test/command_container/command_encoder_tests_xe_hpg_core_and_later.cpp Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/command_encoder.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "test.h"
using namespace NEO;
using CommandEncoderXeHpgCorePlusTests = Test<DeviceFixture>;
HWTEST2_F(CommandEncoderXeHpgCorePlusTests, givenSpecifiedL1CacheControlWhenAppendingRssThenProgramProvidedL1CachePolicy, IsAtLeastXeHpgCore) {
DebugManagerStateRestore restorer;
auto memoryManager = pDevice->getExecutionEnvironment()->memoryManager.get();
size_t allocationSize = MemoryConstants::pageSize;
AllocationProperties properties(pDevice->getRootDeviceIndex(), allocationSize, GraphicsAllocation::AllocationType::BUFFER, pDevice->getDeviceBitfield());
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(properties);
auto rssCmd = FamilyType::cmdInitRenderSurfaceState;
auto l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WBP;
DebugManager.flags.OverrideL1CacheControlInSurfaceState.set(l1CacheControl);
NEO::EncodeSurfaceStateArgs args;
args.outMemory = &rssCmd;
args.graphicsAddress = allocation->getGpuAddress();
args.size = allocation->getUnderlyingBufferSize();
args.mocs = pDevice->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER);
args.numAvailableDevices = pDevice->getNumGenericSubDevices();
args.allocation = allocation;
args.gmmHelper = pDevice->getGmmHelper();
args.areMultipleSubDevicesInContext = true;
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CachePolicyL1CacheControl());
l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB;
DebugManager.flags.OverrideL1CacheControlInSurfaceState.set(l1CacheControl);
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CachePolicyL1CacheControl());
memoryManager->freeGraphicsMemory(allocation);
}

19
shared/test/unit_test/encoders/CMakeLists.txt
View File

@ -38,4 +38,23 @@ if(TESTS_XE_HP_CORE)
)
endif()
if(TESTS_DG2_AND_LATER)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_encode_dispatch_kernel_dg2_and_later.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_encode_dispatch_kernel_dg2_and_later.h
)
endif()
if(TESTS_DG2)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/command_encoder_tests_dg2.cpp
)
endif()
if(TESTS_XE_HPG_CORE)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_implicit_scaling_xe_hpg.cpp
)
endif()
add_subdirectories()

76
shared/test/unit_test/encoders/command_encoder_tests_dg2.cpp Normal file
View File

@ -0,0 +1,76 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/cmdcontainer.h"
#include "shared/source/os_interface/hw_info_config.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "test.h"
using namespace NEO;
using DG2CommandEncoderTest = Test<DeviceFixture>;
HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterCommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_IsAtLeastXeHpCore, IGFX_DG2);
HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_DG2);
HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterCommandEncoderTest, givenCommandContainerWithDirtyHeapWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_IsAtLeastXeHpCore, IGFX_DG2);
HWTEST2_F(DG2CommandEncoderTest, givenDG2WhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsDG2) {
class MockCommandContainer : public CommandContainer {
public:
MockCommandContainer() : CommandContainer() {}
void clearHeaps() {
dirtyHeaps = 0;
}
};
auto container = MockCommandContainer();
container.clearHeaps();
size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
EXPECT_EQ(size, 176ul);
}
HWTEST2_F(DG2CommandEncoderTest, givenDG2AndCommandContainerWithDirtyHeapWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsDG2) {
auto container = CommandContainer();
container.setHeapDirty(HeapType::SURFACE_STATE);
size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
EXPECT_EQ(size, 192ul);
}
HWTEST2_F(DG2CommandEncoderTest, givenInterfaceDescriptorDataWhenForceThreadGroupDispatchSizeVariableIsDefaultThenThreadGroupDispatchSizeIsNotChanged, IsDG2) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
INTERFACE_DESCRIPTOR_DATA iddArg;
iddArg = FamilyType::cmdInitInterfaceDescriptorData;
const uint32_t forceThreadGroupDispatchSize = -1;
auto hwInfo = pDevice->getHardwareInfo();
const auto &hwInfoConfig = *HwInfoConfig::get(productFamily);
DebugManagerStateRestore restorer;
DebugManager.flags.ForceThreadGroupDispatchSize.set(forceThreadGroupDispatchSize);
uint32_t revisions[] = {REVISION_A0, REVISION_B};
for (auto revision : revisions) {
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
for (auto numberOfThreadsInGroup : {1u, 4u, 16u}) {
iddArg.setNumberOfThreadsInGpgpuThreadGroup(numberOfThreadsInGroup);
EncodeDispatchKernel<FamilyType>::adjustInterfaceDescriptorData(iddArg, hwInfo);
if (hwInfoConfig.isDisableOverdispatchAvailable(hwInfo)) {
if (numberOfThreadsInGroup == 1) {
EXPECT_EQ(2u, iddArg.getThreadGroupDispatchSize());
} else {
EXPECT_EQ(3u, iddArg.getThreadGroupDispatchSize());
}
} else {
EXPECT_EQ(0u, iddArg.getThreadGroupDispatchSize());
}
}
}
}

166
shared/test/unit_test/encoders/test_encode_dispatch_kernel_dg2_and_later.cpp Normal file
View File

@ -0,0 +1,166 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/unit_test/encoders/test_encode_dispatch_kernel_dg2_and_later.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/os_interface/hw_info_config.h"
#include "shared/test/common/cmd_parse/gen_cmd_parse.h"
#include "shared/test/common/fixtures/command_container_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/mocks/mock_dispatch_kernel_encoder_interface.h"
#include "test.h"
#include "hw_cmds.h"
#include "test_traits_common.h"
using namespace NEO;
using CommandEncodeStatesTestDg2AndLater = Test<CommandEncodeStatesFixture>;
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, givenEventAddressWhenEncodeAndPVCAndDG2ThenSetDataportSubsliceCacheFlushIstSet, IsAtLeastXeHpgCore) {
using POSTSYNC_DATA = typename FamilyType::POSTSYNC_DATA;
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
uint32_t dims[] = {2, 1, 1};
std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
uint64_t eventAddress = MemoryConstants::cacheLineSize * 123;
bool requiresUncachedMocs = false;
uint32_t partitionCount = 0;
EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), eventAddress, true, true,
pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, false, partitionCount,
false, false);
GenCmdList commands;
CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
auto itor = find<WALKER_TYPE *>(commands.begin(), commands.end());
ASSERT_NE(itor, commands.end());
auto cmd = genCmdCast<WALKER_TYPE *>(*itor);
EXPECT_EQ(true, cmd->getPostSync().getDataportSubsliceCacheFlush());
}
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, givenEventAddressWhenEncodeAndDG2ThenMocsIndex2IsSet, IsDG2) {
using POSTSYNC_DATA = typename FamilyType::POSTSYNC_DATA;
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
uint32_t dims[] = {2, 1, 1};
std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
uint64_t eventAddress = MemoryConstants::cacheLineSize * 123;
bool requiresUncachedMocs = false;
uint32_t partitionCount = 0;
EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), eventAddress, true, true,
pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, false, partitionCount,
false, false);
GenCmdList commands;
CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
auto itor = find<WALKER_TYPE *>(commands.begin(), commands.end());
ASSERT_NE(itor, commands.end());
auto cmd = genCmdCast<WALKER_TYPE *>(*itor);
auto gmmHelper = pDevice->getGmmHelper();
EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED), cmd->getPostSync().getMocs());
}
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, GivenVariousSlmTotalSizesAndSettingRevIDToDifferentValuesWhenSetAdditionalInfoIsCalledThenCorrectValuesAreSet, IsXeHpgCore) {
using PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS = typename FamilyType::INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS;
const std::vector<PreferredSlmTestValues<FamilyType>> valuesToTest = {
{0, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_0K},
{16 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_16K},
{32 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_32K},
//since we can't set 48KB as SLM size for workgroup, we need to ask for 64KB here.
{64 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_64K},
};
const std::vector<PreferredSlmTestValues<FamilyType>> valuesToTestForDg2AStep = {
{0, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K},
{16 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K},
{32 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K},
{64 * KB, PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K},
};
const std::array<REVID, 5> revs{REVISION_A0, REVISION_B, REVISION_C, REVISION_D, REVISION_K};
auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
for (auto rev : revs) {
hwInfo.platform.usRevId = HwInfoConfig::get(productFamily)->getHwRevIdFromStepping(rev, hwInfo);
if ((hwInfo.platform.eProductFamily == IGFX_DG2) && (rev == REVISION_A0)) {
verifyPreferredSlmValues<FamilyType>(valuesToTestForDg2AStep, hwInfo);
} else {
verifyPreferredSlmValues<FamilyType>(valuesToTest, hwInfo);
}
}
}
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, GivenDebugOverrideWhenSetAdditionalInfoIsCalledThenDebugValuesAreSet, IsAtLeastXeHpgCore) {
using PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS = typename FamilyType::INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS;
DebugManagerStateRestore stateRestore;
PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS debugOverrideValues[] = {PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_0K,
PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_32K,
PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K};
for (auto debugOverrideValue : debugOverrideValues) {
DebugManager.flags.OverridePreferredSlmAllocationSizePerDss.set(debugOverrideValue);
const std::vector<PreferredSlmTestValues<FamilyType>> valuesToTest = {
{0, debugOverrideValue},
{32 * KB, debugOverrideValue},
{64 * KB, debugOverrideValue},
};
verifyPreferredSlmValues<FamilyType>(valuesToTest, hardwareInfo);
}
}
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, givenVariousValuesWhenCallingSetBarrierEnableThenCorrectValuesAreSet, IsAtLeastXeHpgCore) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
INTERFACE_DESCRIPTOR_DATA idd = FamilyType::cmdInitInterfaceDescriptorData;
MockDevice device;
auto hwInfo = device.getHardwareInfo();
uint32_t barrierCounts[] = {0, 1, 2, 7};
for (auto barrierCount : barrierCounts) {
EncodeDispatchKernel<FamilyType>::programBarrierEnable(idd, barrierCount, hwInfo);
EXPECT_EQ(barrierCount, idd.getNumberOfBarriers());
}
}
HWTEST2_F(CommandEncodeStatesTestDg2AndLater, givenOverridePreferredSlmAllocationSizePerDssWhenDispatchingKernelThenCorrectValueIsSet, IsAtLeastXeHpgCore) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
using PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS = typename INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS;
DebugManagerStateRestore restorer;
DebugManager.flags.OverridePreferredSlmAllocationSizePerDss.set(5);
uint32_t dims[] = {2, 1, 1};
std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
uint32_t slmTotalSize = 1;
EXPECT_CALL(*dispatchInterface.get(), getSlmTotalSize()).WillRepeatedly(::testing::Return(slmTotalSize));
bool requiresUncachedMocs = false;
uint32_t partitionCount = 0;
EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false, false,
pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, false, partitionCount,
false, false);
GenCmdList commands;
CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
auto itor = find<WALKER_TYPE *>(commands.begin(), commands.end());
ASSERT_NE(itor, commands.end());
auto cmd = genCmdCast<WALKER_TYPE *>(*itor);
auto &idd = cmd->getInterfaceDescriptor();
EXPECT_EQ(PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS::PREFERRED_SLM_SIZE_IS_128K, idd.getPreferredSlmAllocationSizePerDss());
}

59
shared/test/unit_test/encoders/test_encode_dispatch_kernel_dg2_and_later.h Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/command_encoder.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/kernel/dispatch_kernel_encoder_interface.h"
#include "test.h"
#include "hw_cmds.h"
template <typename FamilyType>
struct PreferredSlmTestValues {
uint32_t preferredSlmAllocationSizePerDss;
typename FamilyType::INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS expectedValueInIdd;
};
template <typename FamilyType>
void verifyPreferredSlmValues(std::vector<PreferredSlmTestValues<FamilyType>> valuesToTest, NEO::HardwareInfo &hwInfo) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
using PREFERRED_SLM_SIZE_OVERRIDE = typename INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_SIZE_OVERRIDE;
using PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS = typename INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE_PER_DSS;
auto threadsPerDssCount = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.SubSliceCount;
uint32_t localWorkGroupsPerDssCounts[] = {1, 2, 4};
INTERFACE_DESCRIPTOR_DATA idd = FamilyType::cmdInitInterfaceDescriptorData;
EXPECT_EQ(0u, idd.getPreferredSlmAllocationSizePerDss());
EXPECT_EQ(PREFERRED_SLM_SIZE_OVERRIDE::PREFERRED_SLM_SIZE_OVERRIDE_IS_DISABLED, idd.getPreferredSlmSizeOverride());
const std::array<NEO::SlmPolicy, 3> slmPolicies = {
NEO::SlmPolicy::SlmPolicyNone,
NEO::SlmPolicy::SlmPolicyLargeSlm,
NEO::SlmPolicy::SlmPolicyLargeData};
for (auto localWorkGroupsPerDssCount : localWorkGroupsPerDssCounts) {
for (auto &valueToTest : valuesToTest) {
for (auto slmPolicy : slmPolicies) {
auto threadsPerThreadGroup = threadsPerDssCount / localWorkGroupsPerDssCount;
auto slmTotalSize = (slmPolicy == NEO::SlmPolicy::SlmPolicyLargeData)
? valueToTest.preferredSlmAllocationSizePerDss
: valueToTest.preferredSlmAllocationSizePerDss / localWorkGroupsPerDssCount;
NEO::EncodeDispatchKernel<FamilyType>::appendAdditionalIDDFields(&idd,
hwInfo,
threadsPerThreadGroup,
slmTotalSize,
slmPolicy);
EXPECT_EQ(valueToTest.expectedValueInIdd, idd.getPreferredSlmAllocationSizePerDss());
EXPECT_EQ(PREFERRED_SLM_SIZE_OVERRIDE::PREFERRED_SLM_SIZE_OVERRIDE_IS_ENABLED, idd.getPreferredSlmSizeOverride());
}
}
}
}

12
shared/test/unit_test/encoders/test_implicit_scaling_xe_hpg.cpp Normal file
View File

@ -0,0 +1,12 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/fixtures/implicit_scaling_fixture.h"
HWTEST2_F(ImplicitScalingTests, GivenXeHpgWhenCheckingPipeControlStallRequiredThenExpectTrue, IsXeHpgCore) {
EXPECT_TRUE(ImplicitScalingDispatch<FamilyType>::getPipeControlStallRequired());
}

7
shared/test/unit_test/preamble/CMakeLists.txt
View File

@ -9,5 +9,12 @@ set(NEO_CORE_PREAMBLE_TESTS
${CMAKE_CURRENT_SOURCE_DIR}/preamble_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/preamble_tests.cpp
)
if(TESTS_XE_HPG_CORE)
list(APPEND NEO_CORE_PREAMBLE_TESTS
${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_xe_hpg_core.cpp
)
endif()
target_sources(${TARGET_NAME} PRIVATE ${NEO_CORE_PREAMBLE_TESTS})
add_subdirectories()

47
shared/test/unit_test/preamble/test_preamble_xe_hpg_core.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/preemption.h"
#include "shared/source/command_stream/stream_properties.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gen_common/reg_configs_common.h"
#include "shared/source/helpers/preamble.h"
#include "shared/source/utilities/stackvec.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
#include "test.h"
using PreambleTest = ::testing::Test;
using namespace NEO;
HWTEST2_F(PreambleTest, whenKernelDebuggingCommandsAreProgrammedThenCorrectCommandsArePlacedIntoStream, IsXeHpgCore) {
typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
auto bufferSize = PreambleHelper<FamilyType>::getKernelDebuggingCommandsSize(true);
auto buffer = std::unique_ptr<char[]>(new char[bufferSize]);
LinearStream stream(buffer.get(), bufferSize);
PreambleHelper<FamilyType>::programKernelDebugging(&stream);
HardwareParse hwParser;
hwParser.parseCommands<FamilyType>(stream);
auto cmdList = hwParser.getCommandsList<MI_LOAD_REGISTER_IMM>();
ASSERT_EQ(2u, cmdList.size());
auto it = cmdList.begin();
MI_LOAD_REGISTER_IMM *pCmd = reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*it);
EXPECT_EQ(0x20d8u, pCmd->getRegisterOffset());
EXPECT_EQ((1u << 5) | (1u << 21), pCmd->getDataDword());
it++;
pCmd = reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*it);
EXPECT_EQ(0xe400u, pCmd->getRegisterOffset());
EXPECT_EQ((1u << 7) | (1u << 4) | (1u << 2) | (1u << 0), pCmd->getDataDword());
}