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

Create separate file for program image surface state 

Change-Id: I0bebc551d6ee95a7b5f46abfdd875b305d54b467
This commit is contained in:
kamdiedrich 2020-02-11 23:42:16 +01:00
parent c6ea9ee62e
commit 4da8fe050b
7 changed files with 208 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
core/image/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(NEO_CORE_IMAGE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state.h
)
set_property(GLOBAL PROPERTY NEO_CORE_IMAGE ${NEO_CORE_IMAGE})
add_subdirectories()

73
core/image/image_surface_state.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/execution_environment/execution_environment.h"
#include "core/gmm_helper/gmm.h"
#include "core/gmm_helper/resource_info.h"
#include "core/helpers/surface_format_info.h"
#include "core/memory_manager/graphics_allocation.h"
namespace NEO {
template <typename GfxFamily>
void setImageSurfaceState(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const NEO::ImageInfo &imageInfo, NEO::Gmm *gmm, NEO::GmmHelper &gmmHelper, uint32_t cubeFaceIndex) {
using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE;
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);
uint32_t renderTargetViewExtent = static_cast<uint32_t>(imageCount);
uint32_t minimumArrayElement = 0;
auto hAlign = RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4;
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;
imageCount = __GMM_MAX_CUBE_FACE - cubeFaceIndex;
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));
surfaceState->setCoherencyType(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT);
surfaceState->setMultisampledSurfaceStorageFormat(RENDER_SURFACE_STATE::MULTISAMPLED_SURFACE_STORAGE_FORMAT::MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS);
}
} // namespace NEO

14
core/unit_tests/image/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(NEO_CORE_IMAGE_TESTS
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests.cpp
)
set_property(GLOBAL PROPERTY NEO_CORE_IMAGE_TESTS ${NEO_CORE_IMAGE_TESTS})
add_subdirectories()

89
core/unit_tests/image/image_surface_state_tests.cpp Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/gmm_helper/gmm.h"
#include "core/gmm_helper/gmm_helper.h"
#include "core/helpers/aligned_memory.h"
#include "core/helpers/basic_math.h"
#include "core/image/image_surface_state.h"
#include "core/memory_manager/graphics_allocation.h"
#include "core/memory_manager/surface.h"
#include "runtime/helpers/surface_formats.h"
#include "runtime/kernel/kernel.h"
#include "runtime/mem_obj/image.h"
#include "test.h"
#include "unit_tests/fixtures/device_fixture.h"
#include "unit_tests/fixtures/image_fixture.h"
#include "unit_tests/mocks/mock_gmm.h"
#include "unit_tests/mocks/mock_gmm_resource_info.h"
#include "unit_tests/mocks/mock_graphics_allocation.h"
#include <memory>
class ImageSurfaceStateTests : public DeviceFixture,
public testing::Test {
public:
void SetUp() override {
DeviceFixture::SetUp();
gmmHelper = pDevice->getGmmHelper();
}
void TearDown() override {
DeviceFixture::TearDown();
}
MockGmm mockGmm;
GmmHelper *gmmHelper = nullptr;
NEO::ImageInfo imageInfo;
};
HWTEST_F(ImageSurfaceStateTests, givenImageInfoWhenSetImageSurfaceStateThenProperFieldsAreSet) {
auto size = sizeof(typename FamilyType::RENDER_SURFACE_STATE);
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
const uint32_t cubeFaceIndex = 2u;
imageInfo.qPitch = 1u;
imageInfo.imgDesc.imageArraySize = 2u;
imageInfo.imgDesc.imageDepth = 3u;
imageInfo.imgDesc.imageHeight = 4u;
imageInfo.imgDesc.imageRowPitch = 5u;
imageInfo.imgDesc.imageSlicePitch = 6u;
imageInfo.imgDesc.imageWidth = 7u;
imageInfo.imgDesc.numMipLevels = 8u;
imageInfo.imgDesc.numSamples = 9u;
imageInfo.imgDesc.imageType = ImageType::Image2DArray;
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, &mockGmm, *gmmHelper, cubeFaceIndex);
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT;
using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
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->getAuxiliarySurfaceBaseAddress(), 0u);
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->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()));
EXPECT_EQ(castSurfaceState->getTileMode(), mockGmm.gmmResourceInfo->getTileModeSurfaceState());
EXPECT_EQ(castSurfaceState->getMemoryObjectControlState(), gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_IMAGE));
EXPECT_EQ(castSurfaceState->getCoherencyType(), RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT);
EXPECT_EQ(castSurfaceState->getMultisampledSurfaceStorageFormat(), RENDER_SURFACE_STATE::MULTISAMPLED_SURFACE_STORAGE_FORMAT::MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS);
surfaceState = std::make_unique<char[]>(size);
castSurfaceState = reinterpret_cast<typename FamilyType::RENDER_SURFACE_STATE *>(surfaceState.get());
setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, nullptr, *gmmHelper, cubeFaceIndex);
EXPECT_EQ(castSurfaceState->getSurfaceHorizontalAlignment(), RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4);
EXPECT_EQ(castSurfaceState->getSurfaceVerticalAlignment(), RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4);
}

1
runtime/core_files.cmake
View File

@ -18,6 +18,7 @@ append_sources_from_properties(NEO_CORE_SOURCES
NEO_CORE_OS_INTERFACE
NEO_CORE_PAGE_FAULT_MANAGER
NEO_CORE_PROGRAM
NEO_CORE_IMAGE
)

65
runtime/mem_obj/image.inl
View File

@ -11,6 +11,7 @@
#include "core/gmm_helper/resource_info.h"
#include "core/helpers/aligned_memory.h"
#include "core/helpers/hw_cmds.h"
#include "core/image/image_surface_state.h"
#include "runtime/helpers/surface_formats.h"
#include "runtime/mem_obj/image.h"
@ -31,44 +32,30 @@ template <typename GfxFamily>
void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, uint32_t mipLevel) {
using SURFACE_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT;
auto surfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(memory);
auto gmm = getGraphicsAllocation()->getDefaultGmm();
auto gmmHelper = executionEnvironment->getGmmHelper();
auto imageCount = std::max(getImageDesc().image_depth, getImageDesc().image_array_size);
if (imageCount == 0) {
imageCount = 1;
}
bool isImageArray = getImageDesc().image_array_size > 1 &&
(getImageDesc().image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY ||
getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY);
uint32_t renderTargetViewExtent = static_cast<uint32_t>(imageCount);
uint32_t minimumArrayElement = 0;
auto hAlign = RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4;
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;
imageCount = __GMM_MAX_CUBE_FACE - cubeFaceIndex;
renderTargetViewExtent = 1;
minimumArrayElement = cubeFaceIndex;
}
auto imageDescriptor = Image::convertDescriptor(getImageDesc());
ImageInfo imgInfo;
imgInfo.imgDesc = imageDescriptor;
imgInfo.qPitch = qPitch;
auto imageHeight = getImageDesc().image_height;
if (imageHeight == 0) {
imageHeight = 1;
}
surfaceState->setAuxiliarySurfaceMode(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
surfaceState->setAuxiliarySurfacePitch(1u);
surfaceState->setAuxiliarySurfaceQpitch(0u);
surfaceState->setAuxiliarySurfaceBaseAddress(0u);
auto imageCount = std::max(getImageDesc().image_depth, getImageDesc().image_array_size);
if (imageCount == 0) {
imageCount = 1;
}
if (cubeFaceIndex != __GMM_NO_CUBE_MAP) {
imageCount = __GMM_MAX_CUBE_FACE - cubeFaceIndex;
}
setImageSurfaceState<GfxFamily>(surfaceState, imgInfo, getGraphicsAllocation()->getDefaultGmm(), *gmmHelper, cubeFaceIndex);
if (getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
// image1d_buffer is image1d created from buffer. The length of buffer could be larger
@ -95,17 +82,12 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
}
surfaceState->setSurfaceBaseAddress(getGraphicsAllocation()->getGpuAddress() + this->surfaceOffsets.offset);
surfaceState->setRenderTargetViewExtent(renderTargetViewExtent);
surfaceState->setMinimumArrayElement(minimumArrayElement);
surfaceState->setSurfaceMinLod(this->baseMipLevel + mipLevel);
surfaceState->setMipCountLod((this->mipCount > 0) ? (this->mipCount - 1) : 0);
setMipTailStartLod(surfaceState);
// SurfaceQpitch is in rows but must be a multiple of VALIGN
surfaceState->setSurfaceQpitch(qPitch);
surfaceState->setSurfaceFormat(static_cast<SURFACE_FORMAT>(getSurfaceFormatInfo().surfaceFormat.GenxSurfaceFormat));
surfaceState->setSurfaceArray(isImageArray);
cl_channel_order imgChannelOrder = getSurfaceFormatInfo().OCLImageFormat.image_channel_order;
int shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, imgChannelOrder);
@ -127,21 +109,9 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA);
}
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));
surfaceState->setXOffset(this->surfaceOffsets.xOffset);
surfaceState->setYOffset(this->surfaceOffsets.yOffset);
surfaceState->setCoherencyType(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT);
if (IsNV12Image(&this->getImageFormat())) {
surfaceState->setYOffsetForUOrUvPlane(this->surfaceOffsets.yOffsetForUVplane);
surfaceState->setXOffsetForUOrUvPlane(this->surfaceOffsets.xOffset);
@ -151,7 +121,6 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
}
surfaceState->setNumberOfMultisamples((typename RENDER_SURFACE_STATE::NUMBER_OF_MULTISAMPLES)mcsSurfaceInfo.multisampleCount);
surfaceState->setMultisampledSurfaceStorageFormat(RENDER_SURFACE_STATE::MULTISAMPLED_SURFACE_STORAGE_FORMAT::MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS);
if (imageDesc.num_samples > 1) {
setAuxParamsForMultisamples(surfaceState);

1
unit_tests/core_unit_tests_files.cmake
View File

@ -11,6 +11,7 @@ append_sources_from_properties(NEO_CORE_UNIT_TESTS_SOURCES
NEO_CORE_DEBUG_SETTINGS_TESTS
NEO_CORE_INDIRECT_HEAP_TESTS
NEO_CORE_ENCODERS_TESTS
NEO_CORE_IMAGE_TESTS
)
if(WIN32)