intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-11 16:45:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Adjust RENDER_SURFACE_STATE structures naming

Browse Source 
Performs minor renaming (mostly capitalization) in order to align with
specification.

Renames L1_CACHE_POLICY to L1_CACHE_CONTROL.

Related-To: NEO-13147

Signed-off-by: Vysochyn, Illia <illia.vysochyn@intel.com>
This commit is contained in:
Vysochyn, Illia
2024-11-28 16:31:41 +00:00
committed by Compute-Runtime-Automation
parent 48c376a623
commit afd22999cc
47 changed files with 322 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
shared/test/common/mocks/mock_gmm_resource_info.h
View File

@@ -55,7 +55,7 @@ class MockGmmResourceInfo : public GmmResourceInfo {
uint32_t getAuxQPitch() override { return auxQPitch; }
uint32_t getMipTailStartLodSurfaceState() override { return mipTailStartLod; }
uint32_t getMipTailStartLODSurfaceState() override { return mipTailStartLod; }
GMM_RESOURCE_FORMAT getResourceFormat() override { return mockResourceCreateParams.Format; }
@@ -104,7 +104,7 @@ class MockGmmResourceInfo : public GmmResourceInfo {
void setUnifiedAuxPitchTiles(uint32_t value);
void setAuxQPitch(uint32_t value);
void setMipTailStartLod(uint32_t newMipTailStartLod) { mipTailStartLod = newMipTailStartLod; }
void setMipTailStartLOD(uint32_t newMipTailStartLod) { mipTailStartLod = newMipTailStartLod; }
void refreshHandle() override {
refreshHandleCalled++;

12
shared/test/unit_test/command_container/command_encoder_tests_xe_hpg_core_and_later.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -28,7 +28,7 @@ HWTEST2_F(CommandEncoderXeHpgCorePlusTests, givenSpecifiedL1CacheControlWhenAppe
auto rssCmd = FamilyType::cmdInitRenderSurfaceState;
auto l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WBP;
auto l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WBP;
debugManager.flags.OverrideL1CacheControlInSurfaceState.set(l1CacheControl);
NEO::EncodeSurfaceStateArgs args;
@@ -43,18 +43,18 @@ HWTEST2_F(CommandEncoderXeHpgCorePlusTests, givenSpecifiedL1CacheControlWhenAppe
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CacheControlCachePolicy());
l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB;
l1CacheControl = FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB;
debugManager.flags.OverrideL1CacheControlInSurfaceState.set(l1CacheControl);
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(static_cast<uint32_t>(l1CacheControl), rssCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(static_cast<uint32_t>(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_UC), rssCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(static_cast<uint32_t>(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_UC), rssCmd.getL1CacheControlCachePolicy());
memoryManager->freeGraphicsMemory(allocation);
}

6
shared/test/unit_test/encoders/test_encode_states_dg2.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -40,7 +40,7 @@ HWTEST2_F(CommandEncodeStatesDG2Test, givenCommandContainerWhenSetStateBaseAddre
auto cmd = genCmdCast<STATE_BASE_ADDRESS *>(*itorCmd);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, cmd->getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, cmd->getL1CacheControlCachePolicy());
}
HWTEST2_F(CommandEncodeStatesDG2Test, givenCommandContainerAndDebuggerWhenSetStateBaseAddressCalledThenCachePolicyIsWBP, IsDG2) {
@@ -64,5 +64,5 @@ HWTEST2_F(CommandEncodeStatesDG2Test, givenCommandContainerAndDebuggerWhenSetSta
auto cmd = genCmdCast<STATE_BASE_ADDRESS *>(*itorCmd);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, cmd->getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, cmd->getL1CacheControlCachePolicy());
}

10
shared/test/unit_test/gen12lp/image_surface_state_tests_gen12lp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -44,11 +44,11 @@ GEN12LPTEST_F(ImageSurfaceStateTestsGen12LP, givenGmmWithMediaCompressedWhenSetM
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLod<FamilyType>(castSurfaceState, nullptr);
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), 0u);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLod<FamilyType>(castSurfaceState, mockGmm.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), mockGmm->gmmResourceInfo->getMipTailStartLodSurfaceState());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}

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

@@ -168,7 +168,7 @@ struct MyMockResourecInfo : public GmmResourceInfo {
GMM_RESOURCE_FLAG *getResourceFlags() override {
return &flags;
}
uint32_t getMipTailStartLodSurfaceState() override {
uint32_t getMipTailStartLODSurfaceState() override {
return 0;
}
size_t pitch = 0;

6
shared/test/unit_test/helpers/cache_policy_tests.cpp
View File

@@ -25,13 +25,13 @@ HWTEST2_F(ProductHelperTest, givenL1CachePolicyHelperWhenUnsupportedL1PoliciesAn
HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreWhenGetL1CachePolicyThenReturnCorrectValue, IsAtLeastXeHpgCore) {
using GfxFamily = typename HwMapper<productFamily>::GfxFamily;
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getL1CachePolicy(false), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP);
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getL1CachePolicy(true), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP);
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getL1CachePolicy(false), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP);
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getL1CachePolicy(true), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP);
}
HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreWhenGetUncached1CachePolicyThenReturnCorrectValue, IsAtLeastXeHpgCore) {
using GfxFamily = typename HwMapper<productFamily>::GfxFamily;
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getUncachedL1CachePolicy(), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC);
EXPECT_EQ(L1CachePolicyHelper<productFamily>::getUncachedL1CachePolicy(), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC);
}
HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreAndWriteBackPolicyWhenGetL1CachePolicyThenReturnCorrectValue, IsAtLeastXeHpgCore) {

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

@@ -117,12 +117,12 @@ HWTEST2_F(GfxCoreHelperTest, WhenSettingRenderSurfaceStateForBufferThenL1CachePo
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, offset, pitch, nullptr, false, type, false,
false);
EXPECT_NE(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB, surfaceState->getL1CachePolicyL1CacheControl());
EXPECT_NE(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB, surfaceState->getL1CacheControlCachePolicy());
gfxCoreHelper.setRenderSurfaceStateForScratchResource(rootDeviceEnvironment, stateBuffer, size, addr, offset, pitch, nullptr, false, type, false,
true);
EXPECT_EQ(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB, surfaceState->getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB, surfaceState->getL1CacheControlCachePolicy());
alignedFree(stateBuffer);
}

6
shared/test/unit_test/helpers/gfx_core_helper_tests_dg2_and_later.cpp
View File

@@ -33,7 +33,7 @@ HWTEST2_F(GfxCoreHelperDg2AndLaterTest, GivenUseL1CacheAsTrueWhenCallSetL1CacheP
RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
bool useL1Cache = true;
helper.setL1CachePolicy(useL1Cache, &surfaceState, defaultHwInfo.get());
EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB, surfaceState.getL1CachePolicyL1CacheControl());
EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB, surfaceState.getL1CacheControlCachePolicy());
}
HWTEST2_F(GfxCoreHelperDg2AndLaterTest, GivenOverrideL1CacheControlInSurfaceStateForScratchSpaceWhenCallSetL1CachePolicyThenL1CachePolicyL1CacheControlIsSetProperly, IsAtLeastXeHpgCore) {
@@ -49,7 +49,7 @@ HWTEST2_F(GfxCoreHelperDg2AndLaterTest, GivenOverrideL1CacheControlInSurfaceStat
RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
bool useL1Cache = true;
helper.setL1CachePolicy(useL1Cache, &surfaceState, defaultHwInfo.get());
EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_POLICY_UC, surfaceState.getL1CachePolicyL1CacheControl());
EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_CONTROL_UC, surfaceState.getL1CacheControlCachePolicy());
}
HWTEST2_F(GfxCoreHelperDg2AndLaterTest, GivenUseL1CacheAsFalseWhenCallSetL1CachePolicyThenL1CachePolicyL1CacheControlIsNotSet, IsAtLeastXeHpgCore) {
@@ -61,7 +61,7 @@ HWTEST2_F(GfxCoreHelperDg2AndLaterTest, GivenUseL1CacheAsFalseWhenCallSetL1Cache
RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
bool useL1Cache = false;
helper.setL1CachePolicy(useL1Cache, &surfaceState, defaultHwInfo.get());
EXPECT_NE(RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB, surfaceState.getL1CachePolicyL1CacheControl());
EXPECT_NE(RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB, surfaceState.getL1CacheControlCachePolicy());
}
using GfxCoreHelperWithLargeGrf = ::testing::Test;

46
shared/test/unit_test/helpers/state_base_address_tests.cpp
View File

@@ -291,31 +291,31 @@ HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSetti
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(3);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(4);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, stateBaseAddress.getL1CacheControlCachePolicy());
}
args.isDebuggerActive = true;
{
@@ -323,31 +323,31 @@ HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSetti
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(3);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(4);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, stateBaseAddress.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendExtraCacheSettings(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC, stateBaseAddress.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, stateBaseAddress.getL1CacheControlCachePolicy());
}
}
@@ -356,12 +356,12 @@ HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePol
struct {
uint32_t option;
typename FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY cachePolicy;
typename FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL cachePolicy;
} testInputs[] = {
{0, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP},
{2, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB},
{3, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT},
{4, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS}};
{0, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP},
{2, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB},
{3, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT},
{4, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS}};
StateBaseAddressHelperArgs<FamilyType> args = createSbaHelperArgs<FamilyType>(&sbaCmd, pDevice->getRootDeviceEnvironment().getGmmHelper(), &ssh, nullptr, nullptr);
args.setGeneralStateBaseAddress = true;
@@ -375,13 +375,13 @@ HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePol
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(input.cachePolicy, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(input.cachePolicy, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, sbaCmd.getL1CacheControlCachePolicy());
}
}
@@ -408,18 +408,18 @@ HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingRssThenProgramCorrectL1CachePol
struct {
uint32_t option;
typename FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY cachePolicy;
typename FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL cachePolicy;
} testInputs[] = {
{0, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WBP},
{2, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WB},
{3, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WT},
{4, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_POLICY_WS}};
{0, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WBP},
{2, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WB},
{3, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WT},
{4, FamilyType::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WS}};
for (const auto &input : testInputs) {
DebugManagerStateRestore restore;
debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(input.option);
EncodeSurfaceState<FamilyType>::encodeBuffer(args);
EXPECT_EQ(input.cachePolicy, rssCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(input.cachePolicy, rssCmd.getL1CacheControlCachePolicy());
}
memoryManager->freeGraphicsMemory(allocation);
}

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

@@ -301,7 +301,7 @@ struct MyMockResourecInfo : public GmmResourceInfo {
GMM_RESOURCE_FLAG *getResourceFlags() override {
return &flags;
}
uint32_t getMipTailStartLodSurfaceState() override {
uint32_t getMipTailStartLODSurfaceState() override {
return 0;
}
size_t pitch = 0;

4
shared/test/unit_test/image/image_surface_state_tests.cpp
View File

@@ -48,7 +48,7 @@ HWTEST2_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProp
EXPECT_EQ(castSurfaceState->getRenderTargetViewExtent(), 1u);
EXPECT_EQ(castSurfaceState->getMinimumArrayElement(), cubeFaceIndex);
EXPECT_EQ(castSurfaceState->getSurfaceQpitch(), imageInfo.qPitch >> RENDER_SURFACE_STATE::tagSURFACEQPITCH::SURFACEQPITCH_BIT_SHIFT);
EXPECT_EQ(castSurfaceState->getSurfaceQPitch(), imageInfo.qPitch >> RENDER_SURFACE_STATE::tagSURFACEQPITCH::SURFACEQPITCH_BIT_SHIFT);
EXPECT_EQ(castSurfaceState->getSurfaceArray(), true);
EXPECT_EQ(castSurfaceState->getSurfaceHorizontalAlignment(), static_cast<typename RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT>(mockGmm->gmmResourceInfo->getHAlignSurfaceState()));
EXPECT_EQ(castSurfaceState->getSurfaceVerticalAlignment(), static_cast<typename RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT>(mockGmm->gmmResourceInfo->getVAlignSurfaceState()));
@@ -87,7 +87,7 @@ HWTEST2_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProp
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceMode(), AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfacePitch(), 1u);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceQpitch(), 0u);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceQPitch(), 0u);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceBaseAddress(), 0u);
surfaceState = std::make_unique<char[]>(size);

24
shared/test/unit_test/os_interface/product_helper_tests.cpp
View File

@@ -695,29 +695,29 @@ HWTEST2_F(ProductHelperTest, givenProductHelperAndDebugFlagWhenGetL1CachePolicyT
DebugManagerStateRestore restorer;
debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(0);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true));
debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(2);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(true));
debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(3);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(true));
debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(4);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(true));
debugManager.flags.ForceAllResourcesUncached.set(true);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_UC, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(true));
}
HWTEST2_F(ProductHelperTest, givenProductHelperWhenGetL1CachePolicyThenReturnWriteByPass, IsAtLeastXeHpgCore) {
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, productHelper->getL1CachePolicy(true));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false));
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true));
}
HWTEST2_F(ProductHelperTest, givenPlatformWithUnsupportedL1CachePoliciesWhenGetL1CachePolicyThenReturnZero, IsAtMostXeHpCore) {

8
shared/test/unit_test/xe2_hpg_core/image_surface_state_tests_xe2_hpg_core.cpp
View File

@@ -21,13 +21,13 @@ XE2_HPG_CORETEST_F(ImageSurfaceStateTestsXe2HpgCore, givenGmmWithMediaCompressed
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLod<FamilyType>(castSurfaceState, nullptr);
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), 0u);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLod<FamilyType>(castSurfaceState, mockGmm.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), mockGmm->gmmResourceInfo->getMipTailStartLodSurfaceState());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}
XE2_HPG_CORETEST_F(ImageSurfaceStateTestsXe2HpgCore, givenNotMediaCompressedImageWhenAppendingSurfaceStateParamsForCompressionThenCallAppriopriateFunction) {

8
shared/test/unit_test/xe2_hpg_core/test_encode_xe2_hpg_core.cpp
View File

@@ -654,7 +654,7 @@ XE2_HPG_CORETEST_F(Xe2HpgSbaTest, givenSpecificProductFamilyWhenAppendingSbaThen
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, sbaCmd.getL1CacheControlCachePolicy());
}
XE2_HPG_CORETEST_F(Xe2HpgSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProgrammedThenItMatchesTheOverrideValue) {
@@ -669,19 +669,19 @@ XE2_HPG_CORETEST_F(Xe2HpgSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsPr
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(0u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2u);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(2u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(2u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(1u, sbaCmd.getL1CacheControlCachePolicy());
}

10
shared/test/unit_test/xe_hpc_core/image_surface_state_tests_xe_hpc_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -47,13 +47,13 @@ XE_HPC_CORETEST_F(ImageSurfaceStateTestsXeHpcCore, givenGmmWithMediaCompressedWh
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLod<FamilyType>(castSurfaceState, nullptr);
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), 0u);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLod<FamilyType>(castSurfaceState, mockGmm.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), mockGmm->gmmResourceInfo->getMipTailStartLodSurfaceState());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}
XE_HPC_CORETEST_F(ImageSurfaceStateTestsXeHpcCore, givenSurfaceStateAndNullptrReleaseHelperWhenAuxParamsForMCSCCSAreSetThenCorrectAuxModeIsSet) {

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

@@ -498,7 +498,7 @@ XE_HPC_CORETEST_F(XeHpcSbaTest, givenSpecificProductFamilyWhenAppendingSbaThenPr
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, sbaCmd.getL1CacheControlCachePolicy());
}
XE_HPC_CORETEST_F(XeHpcSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProgrammedThenItMatchesTheOverrideValue) {
@@ -513,19 +513,19 @@ XE_HPC_CORETEST_F(XeHpcSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProg
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(0u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2u);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(2u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(2u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(1u, sbaCmd.getL1CacheControlCachePolicy());
}

6
shared/test/unit_test/xe_hpg_core/dg2/cache_policy_tests_dg2.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -17,8 +17,8 @@ using namespace NEO;
DG2TEST_F(ProductHelperTest, givenDG2WhenGetL1CachePolicyThenReturnWbPolicyUnlessDebuggerIsActive) {
using GfxFamily = typename HwMapper<IGFX_DG2>::GfxFamily;
EXPECT_EQ(L1CachePolicyHelper<IGFX_DG2>::getL1CachePolicy(false), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB);
EXPECT_EQ(L1CachePolicyHelper<IGFX_DG2>::getL1CachePolicy(true), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP);
EXPECT_EQ(L1CachePolicyHelper<IGFX_DG2>::getL1CachePolicy(false), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB);
EXPECT_EQ(L1CachePolicyHelper<IGFX_DG2>::getL1CachePolicy(true), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP);
}
DG2TEST_F(ProductHelperTest, givenDG2WhenGetCachingPolicyOptionsThenReturnCorrectValue) {

10
shared/test/unit_test/xe_hpg_core/dg2/test_encode_dg2.cpp
View File

@@ -76,11 +76,11 @@ DG2TEST_F(Dg2SbaTest, givenSpecificProductFamilyWhenAppendingSbaThenProgramCorre
args.setGeneralStateBaseAddress = true;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WB, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, sbaCmd.getL1CacheControlCachePolicy());
args.isDebuggerActive = true;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, sbaCmd.getL1CacheControlCachePolicy());
}
DG2TEST_F(Dg2SbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProgrammedThenItMatchesTheOverrideValue) {
@@ -94,19 +94,19 @@ DG2TEST_F(Dg2SbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProgrammedThen
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(0u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2u);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(2u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(2u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(1u, sbaCmd.getL1CacheControlCachePolicy());
}

8
shared/test/unit_test/xe_hpg_core/hw_cmds_xe_hpg_core_tests.cpp
View File

@@ -110,7 +110,7 @@ XE_HPG_CORETEST_F(XeHpgSbaTest, givenSpecificProductFamilyWhenAppendingSbaThenPr
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, sbaCmd.getL1CacheControlCachePolicy());
}
XE_HPG_CORETEST_F(XeHpgSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProgrammedThenItMatchesTheOverrideValue) {
@@ -125,19 +125,19 @@ XE_HPG_CORETEST_F(XeHpgSbaTest, givenL1CachingOverrideWhenStateBaseAddressIsProg
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(0u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceStatelessL1CachingPolicy.set(2u);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(2u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(2u, sbaCmd.getL1CacheControlCachePolicy());
debugManager.flags.ForceAllResourcesUncached.set(true);
updateSbaHelperArgsL1CachePolicy<FamilyType>(args, productHelper);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());
EXPECT_EQ(1u, sbaCmd.getL1CacheControlCachePolicy());
}

10
shared/test/unit_test/xe_hpg_core/image_surface_state_tests_xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -47,13 +47,13 @@ XE_HPG_CORETEST_F(ImageSurfaceStateTestsXeHpgCore, givenGmmWithMediaCompressedWh
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLod<FamilyType>(castSurfaceState, nullptr);
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), 0u);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLod<FamilyType>(castSurfaceState, mockGmm.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLod(), mockGmm->gmmResourceInfo->getMipTailStartLodSurfaceState());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}
XE_HPG_CORETEST_F(ImageSurfaceStateTestsXeHpgCore, givenSurfaceStateAndNullptrReleaseHelperWhenAuxParamsForMCSCCSAreSetThenCorrectAuxModeIsSet) {