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

Cleanup image implementation

Browse Source 
Remove unused functions
Remove dead code
Add static functions
Add new formats support
Add unit tests

Change-Id: I95ac1ca1997d4968ce350a0cde169b13cae58edb
This commit is contained in:
kamdiedrich
2020-03-26 12:22:55 +01:00
committed by sys_ocldev
parent 95f217f9ef
commit f417c13534
7 changed files with 205 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/image/image.h
View File

@@ -32,11 +32,9 @@ struct Image : _ze_image_handle_t {
static Image *create(uint32_t productFamily, Device *device, const ze_image_desc_t *desc);
virtual NEO::GraphicsAllocation *getAllocation() = 0;
virtual void decoupleAllocation(NEO::CommandContainer &commandContainer) = 0;
virtual void copySurfaceStateToSSH(void *surfaceStateHeap,
const uint32_t surfaceStateOffset) = 0;
virtual void copyRedescribedSurfaceStateToSSH(void *surfaceStateHeap, const uint32_t surfaceStateOffset) = 0;
virtual size_t getSizeInBytes() = 0;
virtual NEO::ImageInfo getImageInfo() = 0;
virtual ze_image_desc_t getImageDesc() = 0;

18
level_zero/core/source/image/image_hw.h
View File

@@ -24,10 +24,8 @@ struct ImageCoreFamily : public ImageImp {
using RSS = typename GfxFamily::RENDER_SURFACE_STATE;
using RENDER_FORMAT = typename RENDER_SURFACE_STATE::SURFACE_FORMAT;
using SHADER_CHANNEL_SELECT = typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT;
using ImageImp::ImageImp;
static const RENDER_FORMAT surfaceFormatUndefined = static_cast<RENDER_FORMAT>(-1);
static const GMM_RESOURCE_FORMAT gmmResourceFormatUndefined = static_cast<GMM_RESOURCE_FORMAT>(-1);
NEO::SurfaceFormatInfo surfaceFormatsForRedescribe[5] = {
@@ -94,34 +92,34 @@ struct ImageCoreFamily : public ImageImp {
{GMM_FORMAT_R32G32B32A32_SNORM_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R32G32B32A32_SNORM), 0, 4, 4, 16},
{GMM_FORMAT_R32G32B32A32_FLOAT_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R32G32B32A32_FLOAT), 0, 4, 4, 16}},
// ZE_IMAGE_FORMAT_LAYOUT_10_10_10_2
{{GMM_FORMAT_R10G10B10A2_UINT_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_UINT), 0, 1, 1, 1},
{GMM_FORMAT_R10G10B10A2_SINT_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_SINT), 0, 1, 1, 1},
{GMM_FORMAT_R10G10B10A2_UNORM_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_UNORM), 0, 1, 1, 1},
{GMM_FORMAT_R10G10B10A2_SNORM_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_SNORM), 0, 1, 1, 1},
{{GMM_FORMAT_R10G10B10A2_UINT_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_UINT), 0, 4, 1, 4},
{GMM_FORMAT_R10G10B10A2_SINT_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_SINT), 0, 4, 1, 4},
{GMM_FORMAT_R10G10B10A2_UNORM_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_UNORM), 0, 4, 1, 4},
{GMM_FORMAT_R10G10B10A2_SNORM_TYPE, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R10G10B10A2_SNORM), 0, 4, 1, 4},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 1, 1, 1}},
// ZE_IMAGE_FORMAT_LAYOUT_11_11_10
{{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0}},
{GMM_FORMAT_R11G11B10_FLOAT, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_R11G11B10_FLOAT), 0, 3, 0, 4}},
// ZE_IMAGE_FORMAT_LAYOUT_5_6_5
{{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{GMM_FORMAT_B5G6R5_UNORM, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_B5G6R5_UNORM), 0, 3, 0, 2},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0}},
// ZE_IMAGE_FORMAT_LAYOUT_5_5_5_1
{{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{GMM_FORMAT_B5G5R5A1_UNORM, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_B5G5R5A1_UNORM), 0, 4, 0, 2},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0}},
// ZE_IMAGE_FORMAT_LAYOUT_4_4_4_4
{{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0},
{GMM_FORMAT_B4G4R4A4_UNORM, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(RSS::SURFACE_FORMAT_B4G4R4A4_UNORM), 0, 4, 1, 2},
{gmmResourceFormatUndefined, static_cast<NEO::GFX3DSTATE_SURFACEFORMAT>(surfaceFormatUndefined), 0, 0, 0, 0}}};
const SHADER_CHANNEL_SELECT shaderChannelSelect[ZE_IMAGE_FORMAT_SWIZZLE_MAX + 1] = {

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

@@ -18,41 +18,6 @@
#include "level_zero/core/source/image/image_hw.h"
inline NEO::ImageType convertType(const ze_image_type_t type) {
switch (type) {
case ZE_IMAGE_TYPE_2D:
return NEO::ImageType::Image2D;
case ZE_IMAGE_TYPE_3D:
return NEO::ImageType::Image3D;
case ZE_IMAGE_TYPE_2DARRAY:
return NEO::ImageType::Image2DArray;
case ZE_IMAGE_TYPE_1D:
return NEO::ImageType::Image1D;
case ZE_IMAGE_TYPE_1DARRAY:
return NEO::ImageType::Image1DArray;
case ZE_IMAGE_TYPE_BUFFER:
return NEO::ImageType::Image1DBuffer;
default:
break;
}
return NEO::ImageType::Invalid;
}
inline NEO::ImageDescriptor convertDescriptor(const ze_image_desc_t &imageDesc) {
NEO::ImageDescriptor desc = {};
desc.fromParent = false;
desc.imageArraySize = imageDesc.arraylevels;
desc.imageDepth = imageDesc.depth;
desc.imageHeight = imageDesc.height;
desc.imageRowPitch = 0u;
desc.imageSlicePitch = 0u;
desc.imageType = convertType(imageDesc.type);
desc.imageWidth = imageDesc.width;
desc.numMipLevels = imageDesc.miplevels;
desc.numSamples = 0u;
return desc;
}
namespace L0 {
template <GFXCORE_FAMILY gfxCoreFamily>
bool ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_image_desc_t *desc) {
@@ -61,22 +26,22 @@ bool ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_image_d
return false;
}
if (desc->format.layout > ZE_IMAGE_FORMAT_LAYOUT_MAX) {
if (static_cast<uint32_t>(desc->format.layout) > ZE_IMAGE_FORMAT_LAYOUT_MAX) {
return false;
}
if (desc->format.type > ZE_IMAGE_FORMAT_TYPE_MAX) {
if (static_cast<uint32_t>(desc->format.type) > ZE_IMAGE_FORMAT_TYPE_MAX) {
return false;
}
if (desc->format.x > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
desc->format.y > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
desc->format.z > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
desc->format.w > ZE_IMAGE_FORMAT_SWIZZLE_MAX) {
if (static_cast<uint32_t>(desc->format.x) > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
static_cast<uint32_t>(desc->format.y) > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
static_cast<uint32_t>(desc->format.z) > ZE_IMAGE_FORMAT_SWIZZLE_MAX ||
static_cast<uint32_t>(desc->format.w) > ZE_IMAGE_FORMAT_SWIZZLE_MAX) {
return false;
}
if (desc->format.type > ZE_IMAGE_FORMAT_TYPE_MAX) {
if (static_cast<uint32_t>(desc->format.type) > ZE_IMAGE_FORMAT_TYPE_MAX) {
return false;
}
@@ -116,7 +81,7 @@ bool ImageCoreFamily<gfxCoreFamily>::initialize(Device *device, const ze_image_d
imgInfo.preferRenderCompression = false;
NEO::AllocationProperties properties(device->getRootDeviceIndex(), true, imgInfo, NEO::GraphicsAllocation::AllocationType::IMAGE);
allocation = device->getDriverHandle()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
allocation = device->getNEODevice()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
UNRECOVERABLE_IF(allocation == nullptr);
auto gmm = this->allocation->getDefaultGmm();

7
level_zero/core/source/image/image_imp.cpp
View File

@@ -15,9 +15,11 @@ namespace L0 {
ImageAllocatorFn imageFactory[IGFX_MAX_PRODUCT] = {};
ze_result_t ImageImp::destroy() {
this->device->getDriverHandle()->getMemoryManager()->freeGraphicsMemory(this->allocation);
ImageImp::~ImageImp() {
this->device->getNEODevice()->getMemoryManager()->freeGraphicsMemory(this->allocation);
}
ze_result_t ImageImp::destroy() {
delete this;
return ZE_RESULT_SUCCESS;
}
@@ -40,5 +42,4 @@ Image *Image::create(uint32_t productFamily, Device *device, const ze_image_desc
bool ImageImp::initialize(Device *device, const ze_image_desc_t *desc) {
return true;
}
} // namespace L0

104
level_zero/core/source/image/image_imp.h
View File

@@ -13,84 +13,62 @@
namespace L0 {
const int ZE_IMAGE_FORMAT_RENDER_LAYOUT_MAX = ZE_IMAGE_FORMAT_LAYOUT_P416;
const int ZE_IMAGE_FORMAT_MEDIA_LAYOUT_OFFSET = ZE_IMAGE_FORMAT_LAYOUT_Y8;
const int ZE_IMAGE_FORMAT_MEDIA_LAYOUT_MAX = ZE_IMAGE_FORMAT_LAYOUT_P416;
const int ZE_IMAGE_FORMAT_LAYOUT_MAX = ZE_IMAGE_FORMAT_MEDIA_LAYOUT_MAX;
const int ZE_IMAGE_FORMAT_TYPE_MAX = ZE_IMAGE_FORMAT_TYPE_FLOAT;
const int ZE_IMAGE_FORMAT_SWIZZLE_MAX = ZE_IMAGE_FORMAT_SWIZZLE_X;
struct ImageFormatDescriptor {
enum formatType {
RENDER,
MEDIA
};
uint32_t channelBytes;
uint32_t bitsPerPixel;
enum formatType type;
ImageFormatDescriptor(enum formatType type, uint32_t cBytes, uint32_t bpp = 0)
: channelBytes(cBytes), type(type) {
bitsPerPixel = bpp > 0 ? bpp : cBytes * 8;
}
};
constexpr uint32_t ZE_IMAGE_FORMAT_RENDER_LAYOUT_MAX = ZE_IMAGE_FORMAT_LAYOUT_4_4_4_4;
constexpr uint32_t ZE_IMAGE_FORMAT_MEDIA_LAYOUT_OFFSET = ZE_IMAGE_FORMAT_LAYOUT_Y8;
constexpr uint32_t ZE_IMAGE_FORMAT_MEDIA_LAYOUT_MAX = ZE_IMAGE_FORMAT_LAYOUT_P416;
constexpr uint32_t ZE_IMAGE_FORMAT_LAYOUT_MAX = ZE_IMAGE_FORMAT_MEDIA_LAYOUT_MAX;
constexpr uint32_t ZE_IMAGE_FORMAT_TYPE_MAX = ZE_IMAGE_FORMAT_TYPE_FLOAT;
constexpr uint32_t ZE_IMAGE_FORMAT_SWIZZLE_MAX = ZE_IMAGE_FORMAT_SWIZZLE_X;
struct ImageImp : public Image {
using IFD = ImageFormatDescriptor;
ze_result_t destroy() override;
virtual bool initialize(Device *device, const ze_image_desc_t *desc);
const ImageFormatDescriptor formats[ZE_IMAGE_FORMAT_LAYOUT_MAX + 1] = {
IFD(IFD::RENDER, 1), // ZE_IMAGE_FORMAT_LAYOUT_8
IFD(IFD::RENDER, 2), // ZE_IMAGE_FORMAT_LAYOUT_16
IFD(IFD::RENDER, 4), // ZE_IMAGE_FORMAT_LAYOUT_32
IFD(IFD::RENDER, 2), // ZE_IMAGE_FORMAT_LAYOUT_8_8
IFD(IFD::RENDER, 4), // ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8
IFD(IFD::RENDER, 4), // ZE_IMAGE_FORMAT_LAYOUT_16_16
IFD(IFD::RENDER, 8), // ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16
IFD(IFD::RENDER, 8), // ZE_IMAGE_FORMAT_LAYOUT_32_32
IFD(IFD::RENDER, 16), // ZE_IMAGE_FORMAT_LAYOUT_32_32_32_32
IFD(IFD::RENDER, 4), // ZE_IMAGE_FORMAT_LAYOUT_10_10_10_2
IFD(IFD::RENDER, 4), // ZE_IMAGE_FORMAT_LAYOUT_11_11_10
IFD(IFD::RENDER, 2), // ZE_IMAGE_FORMAT_LAYOUT_5_6_5
IFD(IFD::RENDER, 2), // ZE_IMAGE_FORMAT_LAYOUT_5_5_5_1
IFD(IFD::RENDER, 2), // ZE_IMAGE_FORMAT_LAYOUT_4_4_4_4
IFD(IFD::MEDIA, 1), // ZE_IMAGE_FORMAT_LAYOUT_Y8
IFD(IFD::MEDIA, 1, 12), // ZE_IMAGE_FORMAT_LAYOUT_NV12
IFD(IFD::MEDIA, 2), // ZE_IMAGE_FORMAT_LAYOUT_YUYV
IFD(IFD::MEDIA, 2), // ZE_IMAGE_FORMAT_LAYOUT_VYUY
IFD(IFD::MEDIA, 2), // ZE_IMAGE_FORMAT_LAYOUT_YVYU
IFD(IFD::MEDIA, 2), // ZE_IMAGE_FORMAT_LAYOUT_UYVY
IFD(IFD::MEDIA, 4), // ZE_IMAGE_FORMAT_LAYOUT_AYUV
IFD(IFD::MEDIA, 0), // ZE_IMAGE_FORMAT_LAYOUT_YUAV
IFD(IFD::MEDIA, 2, 24), // ZE_IMAGE_FORMAT_LAYOUT_P010
IFD(IFD::MEDIA, 4, 32), // ZE_IMAGE_FORMAT_LAYOUT_Y410
IFD(IFD::MEDIA, 2, 24), // ZE_IMAGE_FORMAT_LAYOUT_P012
IFD(IFD::MEDIA, 2, 16), // ZE_IMAGE_FORMAT_LAYOUT_Y16
IFD(IFD::MEDIA, 2, 24), // ZE_IMAGE_FORMAT_LAYOUT_P016
IFD(IFD::MEDIA, 2, 32), // ZE_IMAGE_FORMAT_LAYOUT_Y216
IFD(IFD::MEDIA, 2, 32), // ZE_IMAGE_FORMAT_LAYOUT_P216
IFD(IFD::MEDIA, 2, 64) // ZE_IMAGE_FORMAT_LAYOUT_P416
};
ImageImp() {}
~ImageImp() override = default;
~ImageImp() override;
NEO::GraphicsAllocation *getAllocation() override { return allocation; }
void decoupleAllocation(NEO::CommandContainer &commandContainer) override {
commandContainer.getDeallocationContainer().push_back(allocation);
allocation = NULL;
}
size_t getSizeInBytes() override { return imgInfo.size; }
NEO::ImageInfo getImageInfo() override { return imgInfo; }
ze_image_desc_t getImageDesc() override {
return imageFormatDesc;
}
static NEO::ImageType convertType(const ze_image_type_t type) {
switch (type) {
case ZE_IMAGE_TYPE_2D:
return NEO::ImageType::Image2D;
case ZE_IMAGE_TYPE_3D:
return NEO::ImageType::Image3D;
case ZE_IMAGE_TYPE_2DARRAY:
return NEO::ImageType::Image2DArray;
case ZE_IMAGE_TYPE_1D:
return NEO::ImageType::Image1D;
case ZE_IMAGE_TYPE_1DARRAY:
return NEO::ImageType::Image1DArray;
case ZE_IMAGE_TYPE_BUFFER:
return NEO::ImageType::Image1DBuffer;
default:
break;
}
return NEO::ImageType::Invalid;
}
static NEO::ImageDescriptor convertDescriptor(const ze_image_desc_t &imageDesc) {
NEO::ImageDescriptor desc = {};
desc.fromParent = false;
desc.imageArraySize = imageDesc.arraylevels;
desc.imageDepth = imageDesc.depth;
desc.imageHeight = imageDesc.height;
desc.imageRowPitch = 0u;
desc.imageSlicePitch = 0u;
desc.imageType = convertType(imageDesc.type);
desc.imageWidth = imageDesc.width;
desc.numMipLevels = imageDesc.miplevels;
desc.numSamples = 0u;
return desc;
}
protected:
Device *device = nullptr;

10
level_zero/core/test/unit_tests/sources/image/CMakeLists.txt Normal file
View File

@@ -0,0 +1,10 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_image.cpp
)

134
level_zero/core/test/unit_tests/sources/image/test_image.cpp Normal file
View File

@@ -0,0 +1,134 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/unit_test/helpers/default_hw_info.h"
#include "opencl/test/unit_test/mocks/mock_device.h"
#include "test.h"
#include "level_zero/core/source/image/image_hw.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
namespace L0 {
namespace ult {
struct ImageStaticFunctionConvertTypeTest : public testing::TestWithParam<std::pair<ze_image_type_t, NEO::ImageType>> {
void SetUp() override {
}
void TearDown() override {
}
};
TEST_P(ImageStaticFunctionConvertTypeTest, givenZeImageFormatTypeWhenConvertTypeThenCorrectImageTypeReturned) {
auto params = GetParam();
EXPECT_EQ(ImageImp::convertType(params.first), params.second);
}
std::pair<ze_image_type_t, NEO::ImageType> validTypes[] = {
{ZE_IMAGE_TYPE_2D, NEO::ImageType::Image2D},
{ZE_IMAGE_TYPE_3D, NEO::ImageType::Image3D},
{ZE_IMAGE_TYPE_2DARRAY, NEO::ImageType::Image2DArray},
{ZE_IMAGE_TYPE_1D, NEO::ImageType::Image1D},
{ZE_IMAGE_TYPE_1DARRAY, NEO::ImageType::Image1DArray},
{ZE_IMAGE_TYPE_BUFFER, NEO::ImageType::Image1DBuffer}};
INSTANTIATE_TEST_CASE_P(
imageTypeFlags,
ImageStaticFunctionConvertTypeTest,
testing::ValuesIn(validTypes));
struct ImageStaticFunctionDescriptorFixture {
void SetUp() {
}
void TearDown() {
}
};
using ImageStaticFunctionDescriptorTest = Test<ImageStaticFunctionDescriptorFixture>;
TEST_F(ImageStaticFunctionDescriptorTest, givenZeImageDescWhenConvertDescriptorThenCorrectImageDescriptorReturned) {
ze_image_desc_t zeDesc = {};
zeDesc.arraylevels = 1u;
zeDesc.depth = 1u;
zeDesc.height = 1u;
zeDesc.width = 1u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
NEO::ImageDescriptor desc = ImageImp::convertDescriptor(zeDesc);
EXPECT_EQ(desc.fromParent, false);
EXPECT_EQ(desc.imageArraySize, zeDesc.arraylevels);
EXPECT_EQ(desc.imageDepth, zeDesc.depth);
EXPECT_EQ(desc.imageHeight, zeDesc.height);
EXPECT_EQ(desc.imageRowPitch, 0u);
EXPECT_EQ(desc.imageSlicePitch, 0u);
EXPECT_EQ(desc.imageType, NEO::ImageType::Image2DArray);
EXPECT_EQ(desc.imageWidth, zeDesc.width);
EXPECT_EQ(desc.numMipLevels, zeDesc.miplevels);
EXPECT_EQ(desc.numSamples, 0u);
}
struct DeviceFixture {
void SetUp() {
neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
device = std::make_unique<Mock<L0::DeviceImp>>(neoDevice, neoDevice->getExecutionEnvironment());
}
void TearDown() {
}
NEO::MockDevice *neoDevice = nullptr;
std::unique_ptr<Mock<L0::DeviceImp>> device = nullptr;
};
using ImageSupport = IsAtMostProduct<IGFX_TIGERLAKE_LP>;
using ImageCreate = Test<DeviceFixture>;
HWTEST2_F(ImageCreate, givenValidImageDescriptionWhenImageCreateThenImageIsCreatedCorrectly, ImageSupport) {
ze_image_desc_t zeDesc = {};
zeDesc.arraylevels = 1u;
zeDesc.depth = 1u;
zeDesc.height = 1u;
zeDesc.width = 1u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
zeDesc.version = ZE_IMAGE_DESC_VERSION_CURRENT;
zeDesc.flags = ZE_IMAGE_FLAG_PROGRAM_READ;
zeDesc.format = {ZE_IMAGE_FORMAT_LAYOUT_32,
ZE_IMAGE_FORMAT_TYPE_UINT,
ZE_IMAGE_FORMAT_SWIZZLE_R,
ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_A};
std::unique_ptr<L0::Image> image(Image::create(productFamily, device.get(), &zeDesc));
ASSERT_NE(image, nullptr);
auto imageInfo = image->getImageInfo();
EXPECT_EQ(imageInfo.imgDesc.fromParent, false);
EXPECT_EQ(imageInfo.imgDesc.imageArraySize, zeDesc.arraylevels);
EXPECT_EQ(imageInfo.imgDesc.imageDepth, zeDesc.depth);
EXPECT_EQ(imageInfo.imgDesc.imageHeight, zeDesc.height);
EXPECT_EQ(imageInfo.imgDesc.imageType, NEO::ImageType::Image2DArray);
EXPECT_EQ(imageInfo.imgDesc.imageWidth, zeDesc.width);
EXPECT_EQ(imageInfo.imgDesc.numMipLevels, zeDesc.miplevels);
EXPECT_EQ(imageInfo.imgDesc.numSamples, 0u);
EXPECT_EQ(imageInfo.baseMipLevel, 0u);
EXPECT_EQ(imageInfo.linearStorage, false);
EXPECT_EQ(imageInfo.mipCount, 0u);
EXPECT_EQ(imageInfo.plane, GMM_NO_PLANE);
EXPECT_EQ(imageInfo.preferRenderCompression, false);
EXPECT_EQ(imageInfo.useLocalMemory, false);
}
} // namespace ult
} // namespace L0