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

refactor: introduce ImageSurfaceState helper class

Browse Source 
Moved global functions to the ImageSurfaceStateHelper class,
with declarations in the header file and definitions in the base .inl
file.
This change reduces compilation time by:
- removing unnecessary includes from the header file
- adding explicit template instantiations, which are faster than
implicit template instantiations.

Additionally, the image_skl_and_later.inl file has been removed as it
is no longer needed, and its implementation has been moved to the base .inl

Related-To: NEO-12149

Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>
This commit is contained in:
Kamil Kopryk
2025-01-28 20:59:24 +00:00
committed by Compute-Runtime-Automation
parent de60dfa3b2
commit ef896cc799
22 changed files with 250 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
level_zero/core/source/image/image_hw.inl
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -192,14 +192,14 @@ ze_result_t ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_
{ {
surfaceState = GfxFamily::cmdInitRenderSurfaceState; surfaceState = GfxFamily::cmdInitRenderSurfaceState;
uint32_t minArrayElement, renderTargetViewExtent, depth; uint32_t minArrayElement, renderTargetViewExtent, depth;
NEO::setImageSurfaceState<GfxFamily>(&surfaceState, imgInfo, gmm, *gmmHelper, __GMM_NO_CUBE_MAP, NEO::ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceState(&surfaceState, imgInfo, gmm, *gmmHelper, __GMM_NO_CUBE_MAP,
this->allocation->getGpuAddress(), surfaceOffsets, this->allocation->getGpuAddress(), surfaceOffsets,
isMediaFormatLayout, minArrayElement, renderTargetViewExtent); isMediaFormatLayout, minArrayElement, renderTargetViewExtent);
NEO::setImageSurfaceStateDimensions<GfxFamily>(&surfaceState, imgInfo, __GMM_NO_CUBE_MAP, surfaceType, depth); NEO::ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceStateDimensions(&surfaceState, imgInfo, __GMM_NO_CUBE_MAP, surfaceType, depth);
surfaceState.setSurfaceMinLOD(0u); surfaceState.setSurfaceMinLOD(0u);
surfaceState.setMIPCountLOD(0u); surfaceState.setMIPCountLOD(0u);
NEO::setMipTailStartLOD<GfxFamily>(&surfaceState, gmm); NEO::ImageSurfaceStateHelper<GfxFamily>::setMipTailStartLOD(&surfaceState, gmm);
if (!isMediaFormatLayout) { if (!isMediaFormatLayout) {
surfaceState.setShaderChannelSelectRed( surfaceState.setShaderChannelSelectRed(
@@ -316,14 +316,14 @@ ze_result_t ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_
redescribedSurfaceState = GfxFamily::cmdInitRenderSurfaceState; redescribedSurfaceState = GfxFamily::cmdInitRenderSurfaceState;
uint32_t minArrayElement, renderTargetViewExtent, depth; uint32_t minArrayElement, renderTargetViewExtent, depth;
NEO::setImageSurfaceState<GfxFamily>(&redescribedSurfaceState, imgInfoRedescirebed, gmm, *gmmHelper, NEO::ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceState(&redescribedSurfaceState, imgInfoRedescirebed, gmm, *gmmHelper,
__GMM_NO_CUBE_MAP, this->allocation->getGpuAddress(), surfaceOffsets, __GMM_NO_CUBE_MAP, this->allocation->getGpuAddress(), surfaceOffsets,
desc->format.layout == ZE_IMAGE_FORMAT_LAYOUT_NV12, minArrayElement, renderTargetViewExtent); desc->format.layout == ZE_IMAGE_FORMAT_LAYOUT_NV12, minArrayElement, renderTargetViewExtent);
NEO::setImageSurfaceStateDimensions<GfxFamily>(&redescribedSurfaceState, imgInfoRedescirebed, __GMM_NO_CUBE_MAP, surfaceType, depth); NEO::ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceStateDimensions(&redescribedSurfaceState, imgInfoRedescirebed, __GMM_NO_CUBE_MAP, surfaceType, depth);
redescribedSurfaceState.setSurfaceMinLOD(0u); redescribedSurfaceState.setSurfaceMinLOD(0u);
redescribedSurfaceState.setMIPCountLOD(0u); redescribedSurfaceState.setMIPCountLOD(0u);
NEO::setMipTailStartLOD<GfxFamily>(&redescribedSurfaceState, gmm); NEO::ImageSurfaceStateHelper<GfxFamily>::setMipTailStartLOD(&redescribedSurfaceState, gmm);
if (imgInfoRedescirebed.surfaceFormat->gmmSurfaceFormat == GMM_FORMAT_R8_UINT_TYPE || if (imgInfoRedescirebed.surfaceFormat->gmmSurfaceFormat == GMM_FORMAT_R8_UINT_TYPE ||
imgInfoRedescirebed.surfaceFormat->gmmSurfaceFormat == GMM_FORMAT_R16_UINT_TYPE || imgInfoRedescirebed.surfaceFormat->gmmSurfaceFormat == GMM_FORMAT_R16_UINT_TYPE ||
@@ -364,7 +364,7 @@ void ImageCoreFamily<gfxCoreFamily>::copySurfaceStateToSSH(void *surfaceStateHea
&surfaceState, sizeof(RENDER_SURFACE_STATE)); &surfaceState, sizeof(RENDER_SURFACE_STATE));
if (isMediaBlockArg) { if (isMediaBlockArg) {
RENDER_SURFACE_STATE *dstRss = static_cast<RENDER_SURFACE_STATE *>(destSurfaceState); RENDER_SURFACE_STATE *dstRss = static_cast<RENDER_SURFACE_STATE *>(destSurfaceState);
NEO::setWidthForMediaBlockSurfaceState<GfxFamily>(dstRss, imgInfo); NEO::ImageSurfaceStateHelper<GfxFamily>::setWidthForMediaBlockSurfaceState(dstRss, imgInfo);
} }
} }

13
opencl/source/mem_obj/image.inl
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2024 Intel Corporation * Copyright (C) 2018-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,6 +10,7 @@
#include "shared/source/execution_environment/root_device_environment.h" #include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/gmm_helper/gmm.h" #include "shared/source/gmm_helper/gmm.h"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/aligned_memory.h" #include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/populate_factory.h" #include "shared/source/helpers/populate_factory.h"
#include "shared/source/image/image_surface_state.h" #include "shared/source/image/image_surface_state.h"
@@ -41,7 +42,7 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
uint32_t renderTargetViewExtent = 0; uint32_t renderTargetViewExtent = 0;
uint32_t minArrayElement = 0; uint32_t minArrayElement = 0;
setImageSurfaceState<GfxFamily>(surfaceState, imgInfo, graphicsAllocation->getDefaultGmm(), *gmmHelper, cubeFaceIndex, graphicsAllocation->getGpuAddress(), surfaceOffsets, isNV12Image(&this->getImageFormat()), minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceState(surfaceState, imgInfo, graphicsAllocation->getDefaultGmm(), *gmmHelper, cubeFaceIndex, graphicsAllocation->getGpuAddress(), surfaceOffsets, isNV12Image(&this->getImageFormat()), minArrayElement, renderTargetViewExtent);
uint32_t depth = 0; uint32_t depth = 0;
@@ -58,16 +59,16 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
surfaceState->setSurfacePitch(static_cast<uint32_t>(getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes)); surfaceState->setSurfacePitch(static_cast<uint32_t>(getSurfaceFormatInfo().surfaceFormat.imageElementSizeInBytes));
surfaceState->setSurfaceType(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER); surfaceState->setSurfaceType(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER);
} else { } else {
setImageSurfaceStateDimensions<GfxFamily>(surfaceState, imgInfo, cubeFaceIndex, surfaceType, depth); ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceStateDimensions(surfaceState, imgInfo, cubeFaceIndex, surfaceType, depth);
if (setAsMediaBlockImage) { if (setAsMediaBlockImage) {
setWidthForMediaBlockSurfaceState<GfxFamily>(surfaceState, imgInfo); ImageSurfaceStateHelper<GfxFamily>::setWidthForMediaBlockSurfaceState(surfaceState, imgInfo);
} }
} }
uint32_t mipCount = this->mipCount > 0 ? this->mipCount - 1 : 0; uint32_t mipCount = this->mipCount > 0 ? this->mipCount - 1 : 0;
surfaceState->setSurfaceMinLOD(this->baseMipLevel + mipLevel); surfaceState->setSurfaceMinLOD(this->baseMipLevel + mipLevel);
surfaceState->setMIPCountLOD(mipCount); surfaceState->setMIPCountLOD(mipCount);
setMipTailStartLOD<GfxFamily>(surfaceState, gmm); ImageSurfaceStateHelper<GfxFamily>::setMipTailStartLOD(surfaceState, gmm);
cl_channel_order imgChannelOrder = getSurfaceFormatInfo().oclImageFormat.image_channel_order; cl_channel_order imgChannelOrder = getSurfaceFormatInfo().oclImageFormat.image_channel_order;
int shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, imgChannelOrder); int shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, imgChannelOrder);
@@ -119,7 +120,7 @@ void ImageHw<GfxFamily>::setAuxParamsForMultisamples(RENDER_SURFACE_STATE *surfa
surfaceState->setAuxiliarySurfacePitch(mcsGmm->getUnifiedAuxPitchTiles()); surfaceState->setAuxiliarySurfacePitch(mcsGmm->getUnifiedAuxPitchTiles());
surfaceState->setAuxiliarySurfaceQPitch(mcsGmm->getAuxQPitch()); surfaceState->setAuxiliarySurfaceQPitch(mcsGmm->getAuxQPitch());
EncodeSurfaceState<GfxFamily>::setClearColorParams(surfaceState, mcsGmm); EncodeSurfaceState<GfxFamily>::setClearColorParams(surfaceState, mcsGmm);
setUnifiedAuxBaseAddress<GfxFamily>(surfaceState, mcsGmm); ImageSurfaceStateHelper<GfxFamily>::setUnifiedAuxBaseAddress(surfaceState, mcsGmm);
} else if (mcsGmm->unifiedAuxTranslationCapable()) { } else if (mcsGmm->unifiedAuxTranslationCapable()) {
EncodeSurfaceState<GfxFamily>::setImageAuxParamsForCCS(surfaceState, mcsGmm); EncodeSurfaceState<GfxFamily>::setImageAuxParamsForCCS(surfaceState, mcsGmm);
} else { } else {

2
opencl/test/unit_test/mem_obj/image_tests.cpp
View File

@@ -1705,7 +1705,7 @@ HWTEST_F(ImageTransformTest, givenSurfaceBaseAddressAndUnifiedSurfaceWhenSetUnif
EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceBaseAddress()); EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceBaseAddress());
setUnifiedAuxBaseAddress<FamilyType>(&surfaceState, gmm.get()); ImageSurfaceStateHelper<FamilyType>::setUnifiedAuxBaseAddress(&surfaceState, gmm.get());
uint64_t offset = gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF); uint64_t offset = gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF);
EXPECT_EQ(surfBsaseAddress + offset, surfaceState.getAuxiliarySurfaceBaseAddress()); EXPECT_EQ(surfBsaseAddress + offset, surfaceState.getAuxiliarySurfaceBaseAddress());

6
shared/source/command_container/command_encoder_pre_xe2_hpg_core.inl
View File

@@ -1,11 +1,13 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/release_helper/release_helper.h" #include "shared/source/release_helper/release_helper.h"
namespace NEO { namespace NEO {
@@ -70,7 +72,7 @@ void EncodeSurfaceState<Family>::setImageAuxParamsForCCS(R_SURFACE_STATE *surfac
setFlagsForMediaCompression(surfaceState, gmm); setFlagsForMediaCompression(surfaceState, gmm);
setClearColorParams(surfaceState, gmm); setClearColorParams(surfaceState, gmm);
setUnifiedAuxBaseAddress<Family>(surfaceState, gmm); ImageSurfaceStateHelper<Family>::setUnifiedAuxBaseAddress(surfaceState, gmm);
} }
template <typename Family> template <typename Family>

2
shared/source/command_container/command_encoder_xe2_hpg_core_and_later.inl
View File

@@ -6,7 +6,9 @@
*/ */
#include "shared/source/gmm_helper/client_context/gmm_client_context.h" #include "shared/source/gmm_helper/client_context/gmm_client_context.h"
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/hw_walk_order.h" #include "shared/source/helpers/hw_walk_order.h"
namespace NEO { namespace NEO {

1
shared/source/command_container/command_encoder_xehp_and_later.inl
View File

@@ -16,6 +16,7 @@
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/execution_environment/root_device_environment.h" #include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/gmm_helper/client_context/gmm_client_context.h" #include "shared/source/gmm_helper/client_context/gmm_client_context.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/basic_math.h" #include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/cache_policy.h" #include "shared/source/helpers/cache_policy.h"
#include "shared/source/helpers/compiler_product_helper.h" #include "shared/source/helpers/compiler_product_helper.h"

10
shared/source/gen12lp/image_core_gen12lp.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2023 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,7 +10,11 @@
namespace NEO { namespace NEO {
using Family = Gen12LpFamily; using GfxFamily = Gen12LpFamily;
}
#include "shared/source/image/image_skl_and_later.inl" #include "shared/source/image/image_surface_state.inl"
namespace NEO {
template class ImageSurfaceStateHelper<GfxFamily>;
} // namespace NEO } // namespace NEO

4
shared/source/image/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2020-2023 Intel Corporation # Copyright (C) 2020-2025 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -7,7 +7,7 @@
set(NEO_CORE_IMAGE set(NEO_CORE_IMAGE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state.h ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state.h
${CMAKE_CURRENT_SOURCE_DIR}/image_skl_and_later.inl ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state.inl
) )
set_property(GLOBAL PROPERTY NEO_CORE_IMAGE ${NEO_CORE_IMAGE}) set_property(GLOBAL PROPERTY NEO_CORE_IMAGE ${NEO_CORE_IMAGE})

15
shared/source/image/image_skl_and_later.inl
View File

@@ -1,15 +0,0 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
template <>
void setMipTailStartLOD<Family>(Family::RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) {
surfaceState->setMipTailStartLOD(0);
if (gmm != nullptr) {
surfaceState->setMipTailStartLOD(gmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}
}

144
shared/source/image/image_surface_state.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -7,135 +7,25 @@
#pragma once #pragma once
#include "shared/source/command_container/encode_surface_state.h" #include <cstdint>
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/surface_format_info.h"
namespace NEO { namespace NEO {
class Gmm;
struct SurfaceOffsets;
class GmmHelper;
struct ImageInfo;
template <typename GfxFamily> template <typename GfxFamily>
inline void setImageSurfaceState(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, Gmm *gmm, GmmHelper &gmmHelper, uint32_t cubeFaceIndex, uint64_t gpuAddress, const SurfaceOffsets &surfaceOffsets, bool isNV12Format, uint32_t &minimumArrayElement, uint32_t &renderTargetViewExtent) { class ImageSurfaceStateHelper {
public:
using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE; using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE;
using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT; using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
auto imageCount = std::max(imageInfo.imgDesc.imageDepth, imageInfo.imgDesc.imageArraySize);
if (imageCount == 0) {
imageCount = 1;
}
bool isImageArray = imageInfo.imgDesc.imageArraySize > 1 &&
(imageInfo.imgDesc.imageType == ImageType::image2DArray ||
imageInfo.imgDesc.imageType == ImageType::image1DArray);
isImageArray |= (imageInfo.imgDesc.imageType == ImageType::image2D || imageInfo.imgDesc.imageType == ImageType::image2DArray) && debugManager.flags.Force2dImageAsArray.get() == 1;
renderTargetViewExtent = static_cast<uint32_t>(imageCount);
minimumArrayElement = 0;
auto hAlign = RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_DEFAULT;
auto vAlign = RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4;
if (gmm) {
hAlign = static_cast<typename RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT>(gmm->gmmResourceInfo->getHAlignSurfaceState());
vAlign = static_cast<typename RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT>(gmm->gmmResourceInfo->getVAlignSurfaceState());
}
if (cubeFaceIndex != __GMM_NO_CUBE_MAP) {
isImageArray = true;
renderTargetViewExtent = 1;
minimumArrayElement = cubeFaceIndex;
}
surfaceState->setAuxiliarySurfaceMode(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
surfaceState->setAuxiliarySurfacePitch(1u);
surfaceState->setAuxiliarySurfaceQPitch(0u);
surfaceState->setAuxiliarySurfaceBaseAddress(0u);
surfaceState->setRenderTargetViewExtent(renderTargetViewExtent);
surfaceState->setMinimumArrayElement(minimumArrayElement);
// SurfaceQpitch is in rows but must be a multiple of VALIGN
surfaceState->setSurfaceQPitch(imageInfo.qPitch);
surfaceState->setSurfaceArray(isImageArray);
surfaceState->setSurfaceHorizontalAlignment(hAlign);
surfaceState->setSurfaceVerticalAlignment(vAlign);
uint32_t tileMode = gmm ? gmm->gmmResourceInfo->getTileModeSurfaceState()
: static_cast<uint32_t>(RENDER_SURFACE_STATE::TILE_MODE_LINEAR);
surfaceState->setTileMode(static_cast<typename RENDER_SURFACE_STATE::TILE_MODE>(tileMode));
surfaceState->setMemoryObjectControlState(gmmHelper.getMOCS(GMM_RESOURCE_USAGE_OCL_IMAGE));
EncodeSurfaceState<GfxFamily>::setCoherencyType(surfaceState, RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT);
surfaceState->setMultisampledSurfaceStorageFormat(RENDER_SURFACE_STATE::MULTISAMPLED_SURFACE_STORAGE_FORMAT::MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS);
surfaceState->setSurfaceBaseAddress(gpuAddress + surfaceOffsets.offset);
surfaceState->setXOffset(surfaceOffsets.xOffset);
surfaceState->setYOffset(surfaceOffsets.yOffset);
if (isNV12Format) {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ONE);
surfaceState->setYOffsetForUOrUvPlane(surfaceOffsets.yOffsetForUVplane);
surfaceState->setXOffsetForUOrUvPlane(surfaceOffsets.xOffset);
} else {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA);
surfaceState->setYOffsetForUOrUvPlane(0);
surfaceState->setXOffsetForUOrUvPlane(0);
}
surfaceState->setSurfaceFormat(static_cast<SURFACE_FORMAT>(imageInfo.surfaceFormat->genxSurfaceFormat));
}
template <typename GfxFamily>
inline void setImageSurfaceStateDimensions(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, uint32_t cubeFaceIndex, typename GfxFamily::RENDER_SURFACE_STATE::SURFACE_TYPE surfaceType, uint32_t &depth) {
auto imageCount = std::max(imageInfo.imgDesc.imageDepth, imageInfo.imgDesc.imageArraySize);
if (imageCount == 0) {
imageCount = 1;
}
auto imageHeight = imageInfo.imgDesc.imageHeight;
if (imageHeight == 0) {
imageHeight = 1;
}
auto imageWidth = imageInfo.imgDesc.imageWidth;
if (imageWidth == 0) {
imageWidth = 1;
}
if (cubeFaceIndex != __GMM_NO_CUBE_MAP) {
imageCount = __GMM_MAX_CUBE_FACE - cubeFaceIndex;
}
depth = static_cast<uint32_t>(imageCount);
surfaceState->setWidth(static_cast<uint32_t>(imageWidth));
surfaceState->setHeight(static_cast<uint32_t>(imageHeight));
surfaceState->setDepth(depth);
surfaceState->setSurfacePitch(static_cast<uint32_t>(imageInfo.imgDesc.imageRowPitch));
surfaceState->setSurfaceType(surfaceType);
}
template <typename GfxFamily>
inline void setWidthForMediaBlockSurfaceState(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo) {
auto elSize = imageInfo.surfaceFormat->imageElementSizeInBytes;
auto numDwords = static_cast<uint32_t>(Math::divideAndRoundUp(imageInfo.imgDesc.imageWidth * elSize, sizeof(uint32_t)));
surfaceState->setWidth(numDwords);
}
template <typename GfxFamily>
inline void setUnifiedAuxBaseAddress(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
uint64_t baseAddress = surfaceState->getSurfaceBaseAddress() +
gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF);
surfaceState->setAuxiliarySurfaceBaseAddress(baseAddress);
}
template <typename GfxFamily>
void setMipTailStartLOD(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, Gmm *gmm);
static void setImageSurfaceState(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, Gmm *gmm, GmmHelper &gmmHelper, uint32_t cubeFaceIndex, uint64_t gpuAddress, const SurfaceOffsets &surfaceOffsets, bool isNV12Format, uint32_t &minimumArrayElement, uint32_t &renderTargetViewExtent);
static void setImageSurfaceStateDimensions(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, uint32_t cubeFaceIndex, SURFACE_TYPE surfaceType, uint32_t &depth);
static void setWidthForMediaBlockSurfaceState(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo);
static void setUnifiedAuxBaseAddress(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm);
static void setMipTailStartLOD(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm);
};
} // namespace NEO } // namespace NEO

147
shared/source/image/image_surface_state.inl Normal file
View File

@@ -0,0 +1,147 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/encode_surface_state.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/image/image_surface_state.h"
namespace NEO {
template <typename GfxFamily>
void ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceState(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, Gmm *gmm, GmmHelper &gmmHelper, uint32_t cubeFaceIndex, uint64_t gpuAddress, const SurfaceOffsets &surfaceOffsets, bool isNV12Format, uint32_t &minimumArrayElement, uint32_t &renderTargetViewExtent) {
using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT;
using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
auto imageCount = std::max(imageInfo.imgDesc.imageDepth, imageInfo.imgDesc.imageArraySize);
if (imageCount == 0) {
imageCount = 1;
}
bool isImageArray = imageInfo.imgDesc.imageArraySize > 1 &&
(imageInfo.imgDesc.imageType == ImageType::image2DArray ||
imageInfo.imgDesc.imageType == ImageType::image1DArray);
isImageArray |= (imageInfo.imgDesc.imageType == ImageType::image2D || imageInfo.imgDesc.imageType == ImageType::image2DArray) && debugManager.flags.Force2dImageAsArray.get() == 1;
renderTargetViewExtent = static_cast<uint32_t>(imageCount);
minimumArrayElement = 0;
auto hAlign = RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_DEFAULT;
auto vAlign = RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4;
if (gmm) {
hAlign = static_cast<typename RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT>(gmm->gmmResourceInfo->getHAlignSurfaceState());
vAlign = static_cast<typename RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT>(gmm->gmmResourceInfo->getVAlignSurfaceState());
}
if (cubeFaceIndex != __GMM_NO_CUBE_MAP) {
isImageArray = true;
renderTargetViewExtent = 1;
minimumArrayElement = cubeFaceIndex;
}
surfaceState->setAuxiliarySurfaceMode(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
surfaceState->setAuxiliarySurfacePitch(1u);
surfaceState->setAuxiliarySurfaceQPitch(0u);
surfaceState->setAuxiliarySurfaceBaseAddress(0u);
surfaceState->setRenderTargetViewExtent(renderTargetViewExtent);
surfaceState->setMinimumArrayElement(minimumArrayElement);
// SurfaceQpitch is in rows but must be a multiple of VALIGN
surfaceState->setSurfaceQPitch(imageInfo.qPitch);
surfaceState->setSurfaceArray(isImageArray);
surfaceState->setSurfaceHorizontalAlignment(hAlign);
surfaceState->setSurfaceVerticalAlignment(vAlign);
uint32_t tileMode = gmm ? gmm->gmmResourceInfo->getTileModeSurfaceState()
: static_cast<uint32_t>(RENDER_SURFACE_STATE::TILE_MODE_LINEAR);
surfaceState->setTileMode(static_cast<typename RENDER_SURFACE_STATE::TILE_MODE>(tileMode));
surfaceState->setMemoryObjectControlState(gmmHelper.getMOCS(GMM_RESOURCE_USAGE_OCL_IMAGE));
EncodeSurfaceState<GfxFamily>::setCoherencyType(surfaceState, RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT);
surfaceState->setMultisampledSurfaceStorageFormat(RENDER_SURFACE_STATE::MULTISAMPLED_SURFACE_STORAGE_FORMAT::MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS);
surfaceState->setSurfaceBaseAddress(gpuAddress + surfaceOffsets.offset);
surfaceState->setXOffset(surfaceOffsets.xOffset);
surfaceState->setYOffset(surfaceOffsets.yOffset);
if (isNV12Format) {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ONE);
surfaceState->setYOffsetForUOrUvPlane(surfaceOffsets.yOffsetForUVplane);
surfaceState->setXOffsetForUOrUvPlane(surfaceOffsets.xOffset);
} else {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA);
surfaceState->setYOffsetForUOrUvPlane(0);
surfaceState->setXOffsetForUOrUvPlane(0);
}
surfaceState->setSurfaceFormat(static_cast<SURFACE_FORMAT>(imageInfo.surfaceFormat->genxSurfaceFormat));
}
template <typename GfxFamily>
void ImageSurfaceStateHelper<GfxFamily>::setImageSurfaceStateDimensions(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo, uint32_t cubeFaceIndex, RENDER_SURFACE_STATE::SURFACE_TYPE surfaceType, uint32_t &depth) {
auto imageCount = std::max(imageInfo.imgDesc.imageDepth, imageInfo.imgDesc.imageArraySize);
if (imageCount == 0) {
imageCount = 1;
}
auto imageHeight = imageInfo.imgDesc.imageHeight;
if (imageHeight == 0) {
imageHeight = 1;
}
auto imageWidth = imageInfo.imgDesc.imageWidth;
if (imageWidth == 0) {
imageWidth = 1;
}
if (cubeFaceIndex != __GMM_NO_CUBE_MAP) {
imageCount = __GMM_MAX_CUBE_FACE - cubeFaceIndex;
}
depth = static_cast<uint32_t>(imageCount);
surfaceState->setWidth(static_cast<uint32_t>(imageWidth));
surfaceState->setHeight(static_cast<uint32_t>(imageHeight));
surfaceState->setDepth(depth);
surfaceState->setSurfacePitch(static_cast<uint32_t>(imageInfo.imgDesc.imageRowPitch));
surfaceState->setSurfaceType(surfaceType);
}
template <typename GfxFamily>
void ImageSurfaceStateHelper<GfxFamily>::setWidthForMediaBlockSurfaceState(RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo) {
auto elSize = imageInfo.surfaceFormat->imageElementSizeInBytes;
auto numDwords = static_cast<uint32_t>(Math::divideAndRoundUp(imageInfo.imgDesc.imageWidth * elSize, sizeof(uint32_t)));
surfaceState->setWidth(numDwords);
}
template <typename GfxFamily>
void ImageSurfaceStateHelper<GfxFamily>::setUnifiedAuxBaseAddress(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
uint64_t baseAddress = surfaceState->getSurfaceBaseAddress() +
gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF);
surfaceState->setAuxiliarySurfaceBaseAddress(baseAddress);
}
template <typename GfxFamily>
void ImageSurfaceStateHelper<GfxFamily>::setMipTailStartLOD(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) {
surfaceState->setMipTailStartLOD(0);
if (gmm != nullptr) {
surfaceState->setMipTailStartLOD(gmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
}
}
} // namespace NEO

10
shared/source/xe2_hpg_core/image_core_xe2_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,7 +10,11 @@
namespace NEO { namespace NEO {
using Family = Xe2HpgCoreFamily; using GfxFamily = Xe2HpgCoreFamily;
}
#include "shared/source/image/image_skl_and_later.inl" #include "shared/source/image/image_surface_state.inl"
namespace NEO {
template class ImageSurfaceStateHelper<GfxFamily>;
} // namespace NEO } // namespace NEO

8
shared/source/xe3_core/image_core_xe3_core.cpp
View File

@@ -10,7 +10,9 @@
namespace NEO { namespace NEO {
using Family = Xe3CoreFamily; using GfxFamily = Xe3CoreFamily;
}
#include "shared/source/image/image_skl_and_later.inl" #include "shared/source/image/image_surface_state.inl"
namespace NEO {
template class ImageSurfaceStateHelper<GfxFamily>;
} // namespace NEO } // namespace NEO

10
shared/source/xe_hpc_core/image_core_xe_hpc_core.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021-2023 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,7 +10,9 @@
namespace NEO { namespace NEO {
using Family = XeHpcCoreFamily; using GfxFamily = XeHpcCoreFamily;
}
#include "shared/source/image/image_skl_and_later.inl" #include "shared/source/image/image_surface_state.inl"
namespace NEO {
template class ImageSurfaceStateHelper<GfxFamily>;
} // namespace NEO } // namespace NEO

10
shared/source/xe_hpg_core/image_core_xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021-2023 Intel Corporation * Copyright (C) 2021-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,7 +10,9 @@
namespace NEO { namespace NEO {
using Family = XeHpgCoreFamily; using GfxFamily = XeHpgCoreFamily;
}
#include "shared/source/image/image_skl_and_later.inl" #include "shared/source/image/image_surface_state.inl"
namespace NEO {
template class ImageSurfaceStateHelper<GfxFamily>;
} // namespace NEO } // namespace NEO

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

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

3
shared/test/unit_test/image/image_surface_state_fixture.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2023 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -8,6 +8,7 @@
#pragma once #pragma once
#include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/aligned_memory.h" #include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/basic_math.h" #include "shared/source/helpers/basic_math.h"
#include "shared/source/image/image_surface_state.h" #include "shared/source/image/image_surface_state.h"

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

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -40,7 +40,7 @@ HWTEST2_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProp
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE; using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT; using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT;
@@ -76,7 +76,7 @@ HWTEST2_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProp
surfaceState = std::make_unique<char[]>(size); surfaceState = std::make_unique<char[]>(size);
castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get()); castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, nullptr, *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, false, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, nullptr, *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, false, minArrayElement, renderTargetViewExtent);
EXPECT_EQ(castSurfaceState->getSurfaceHorizontalAlignment(), RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_DEFAULT); EXPECT_EQ(castSurfaceState->getSurfaceHorizontalAlignment(), RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_DEFAULT);
EXPECT_EQ(castSurfaceState->getSurfaceVerticalAlignment(), RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4); EXPECT_EQ(castSurfaceState->getSurfaceVerticalAlignment(), RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4);
@@ -95,7 +95,7 @@ HWTEST2_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProp
typename FamilyType::RENDER_SURFACE_STATE::SURFACE_TYPE surfaceType = RENDER_SURFACE_STATE::SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D; typename FamilyType::RENDER_SURFACE_STATE::SURFACE_TYPE surfaceType = RENDER_SURFACE_STATE::SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D;
uint32_t depth; uint32_t depth;
setImageSurfaceStateDimensions<FamilyType>(castSurfaceState, imageInfo, cubeFaceIndex, surfaceType, depth); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceStateDimensions(castSurfaceState, imageInfo, cubeFaceIndex, surfaceType, depth);
EXPECT_EQ(castSurfaceState->getWidth(), static_cast<uint32_t>(imageInfo.imgDesc.imageWidth)); EXPECT_EQ(castSurfaceState->getWidth(), static_cast<uint32_t>(imageInfo.imgDesc.imageWidth));
EXPECT_EQ(castSurfaceState->getHeight(), static_cast<uint32_t>(imageInfo.imgDesc.imageHeight)); EXPECT_EQ(castSurfaceState->getHeight(), static_cast<uint32_t>(imageInfo.imgDesc.imageHeight));
@@ -134,7 +134,7 @@ HWTEST_F(ImageSurfaceStateTests, givenImage2DWhen2dImageWAIsEnabledThenArrayFlag
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
EXPECT_TRUE(castSurfaceState->getSurfaceArray()); EXPECT_TRUE(castSurfaceState->getSurfaceArray());
} }
@@ -158,7 +158,7 @@ HWTEST_F(ImageSurfaceStateTests, givenImage2DWhen2dImageWAIsDisabledThenArrayFla
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
EXPECT_FALSE(castSurfaceState->getSurfaceArray()); EXPECT_FALSE(castSurfaceState->getSurfaceArray());
} }
@@ -182,7 +182,7 @@ HWTEST_F(ImageSurfaceStateTests, givenImage2DArrayOfSize1When2dImageWAIsEnabledT
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
EXPECT_TRUE(castSurfaceState->getSurfaceArray()); EXPECT_TRUE(castSurfaceState->getSurfaceArray());
} }
@@ -206,7 +206,7 @@ HWTEST_F(ImageSurfaceStateTests, givenImage2DArrayOfSize1When2dImageWAIsDisabled
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
EXPECT_FALSE(castSurfaceState->getSurfaceArray()); EXPECT_FALSE(castSurfaceState->getSurfaceArray());
} }
@@ -230,7 +230,7 @@ HWTEST_F(ImageSurfaceStateTests, givenImage1DWhen2dImageWAIsEnabledThenArrayFlag
const uint64_t gpuAddress = 0x000001a78a8a8000; const uint64_t gpuAddress = 0x000001a78a8a8000;
uint32_t minArrayElement, renderTargetViewExtent; uint32_t minArrayElement, renderTargetViewExtent;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent); ImageSurfaceStateHelper<FamilyType>::setImageSurfaceState(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true, minArrayElement, renderTargetViewExtent);
EXPECT_FALSE(castSurfaceState->getSurfaceArray()); EXPECT_FALSE(castSurfaceState->getSurfaceArray());
} }
@@ -245,7 +245,7 @@ struct ImageWidthTest : ImageSurfaceStateTests {
void verifyProgramming(typename FamilyType::RENDER_SURFACE_STATE &renderSurfaceState, const std::array<ImageWidthParams, 6> &params) { void verifyProgramming(typename FamilyType::RENDER_SURFACE_STATE &renderSurfaceState, const std::array<ImageWidthParams, 6> &params) {
for (auto &param : params) { for (auto &param : params) {
imageInfo.imgDesc.imageWidth = param.imageWidth; imageInfo.imgDesc.imageWidth = param.imageWidth;
setWidthForMediaBlockSurfaceState<FamilyType>(&renderSurfaceState, imageInfo); ImageSurfaceStateHelper<FamilyType>::setWidthForMediaBlockSurfaceState(&renderSurfaceState, imageInfo);
EXPECT_EQ(param.expectedWidthInDwords, renderSurfaceState.getWidth()); EXPECT_EQ(param.expectedWidthInDwords, renderSurfaceState.getWidth());
} }
} }

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

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2024 Intel Corporation * Copyright (C) 2024-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -21,11 +21,11 @@ XE2_HPG_CORETEST_F(ImageSurfaceStateTestsXe2HpgCore, givenGmmWithMediaCompressed
auto surfaceState = std::make_unique<char[]>(size); auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get()); auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr); ImageSurfaceStateHelper<FamilyType>::setMipTailStartLOD(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u); EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get()); ImageSurfaceStateHelper<FamilyType>::setMipTailStartLOD(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState()); EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
} }

4
shared/test/unit_test/xe3_core/image_surface_state_tests_xe3_core.cpp
View File

@@ -22,11 +22,11 @@ XE3_CORETEST_F(ImageSurfaceStateTestsXe3Core, givenGmmWithMediaCompressedWhenSet
auto surfaceState = std::make_unique<char[]>(size); auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get()); auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setMipTailStartLOD<FamilyType>(castSurfaceState, nullptr); ImageSurfaceStateHelper<FamilyType>::setMipTailStartLOD(castSurfaceState, nullptr);
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u); EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), 0u);
setMipTailStartLOD<FamilyType>(castSurfaceState, mockGmm.get()); ImageSurfaceStateHelper<FamilyType>::setMipTailStartLOD(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState()); EXPECT_EQ(castSurfaceState->getMipTailStartLOD(), mockGmm->gmmResourceInfo->getMipTailStartLODSurfaceState());
} }

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

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

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

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