Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: disable support for 3-channel interop handle

Browse Source 
returns error for import of 3 channel interop handles
returns error for 3 channel 32 bit image formats

Related-To: NEO-12887

Signed-off-by: Kulkarni, Ashwin Kumar <ashwin.kumar.kulkarni@intel.com>
This commit is contained in:
Kulkarni, Ashwin Kumar
2025-01-17 18:49:53 +00:00
committed by Compute-Runtime-Automation
parent e1d1decf90
commit 215ac6374b
2 changed files with 233 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -25,9 +25,38 @@
#include "igfxfmid.h"
namespace L0 {
ImageAllocatorFn imageFactory[IGFX_MAX_PRODUCT] = {};
bool getImageDescriptor(const ze_image_desc_t *origImgDesc, ze_image_desc_t *imgDesc);
bool isImportedWin32Handle(const ze_image_desc_t *imgDesc) {
const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(imgDesc->pNext);
bool importedWin32Handle = false;
while (extendedDesc) {
if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32) {
importedWin32Handle = true;
}
extendedDesc = reinterpret_cast<const ze_base_desc_t *>(extendedDesc->pNext);
}
return importedWin32Handle;
}
void getImageDescriptorFor3ChEmulation(const ze_image_desc_t *origImgDesc, ze_image_desc_t *imgDesc) {
*imgDesc = *origImgDesc;
if (origImgDesc->format.layout == ZE_IMAGE_FORMAT_LAYOUT_16_16_16) {
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
}
if (origImgDesc->format.layout == ZE_IMAGE_FORMAT_LAYOUT_8_8_8) {
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
}
return;
}
ImageImp::~ImageImp() {
if ((isImageView() || imageFromBuffer) && this->device != nullptr) {
@ -87,20 +116,30 @@ ze_result_t ImageImp::createView(Device *device, const ze_image_desc_t *desc, ze
image->imgInfo = this->imgInfo;
image->imageFromBuffer = this->imageFromBuffer;
ze_image_desc_t imgDesc = {};
bool modified = getImageDescriptor(desc, &imgDesc);
auto result = ZE_RESULT_SUCCESS;
if (modified && this->isMimickedImage()) {
image->setMimickedImage(true);
result = image->initialize(device, &imgDesc);
} else {
switch (desc->format.layout) {
default:
result = image->initialize(device, desc);
break;
case ZE_IMAGE_FORMAT_LAYOUT_32_32_32:
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
if (isImportedWin32Handle(desc)) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} else {
ze_image_desc_t imgDesc = {};
getImageDescriptorFor3ChEmulation(desc, &imgDesc);
image->setMimickedImage(true);
result = image->initialize(device, &imgDesc);
}
break;
}
if (result != ZE_RESULT_SUCCESS) {
image->destroy();
image = nullptr;
}
*pImage = image;
return result;
@ -136,58 +175,6 @@ NEO::SurfaceStateInHeapInfo *ImageImp::getBindlessSlot() {
return bindlessInfo.get();
}
bool getImageDescriptor(const ze_image_desc_t *origImgDesc, ze_image_desc_t *imgDesc) {
bool modified = false;
*imgDesc = *origImgDesc;
if (origImgDesc->pNext) {
const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(origImgDesc->pNext);
if (extendedDesc->stype != ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32) {
switch (origImgDesc->format.layout) {
default:
break;
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
}
}
} else {
switch (origImgDesc->format.layout) {
default:
break;
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
}
}
return modified;
}
ze_result_t Image::create(uint32_t productFamily, Device *device, const ze_image_desc_t *desc, Image **pImage) {
ze_result_t result = ZE_RESULT_SUCCESS;
ImageAllocatorFn allocator = nullptr;
@ -198,15 +185,25 @@ ze_result_t Image::create(uint32_t productFamily, Device *device, const ze_image
ImageImp *image = nullptr;
if (allocator) {
image = static_cast<ImageImp *>((*allocator)());
ze_image_desc_t imgDesc = {};
bool modified = getImageDescriptor(desc, &imgDesc);
if (modified) {
image->setMimickedImage(true);
result = image->initialize(device, &imgDesc);
} else {
switch (desc->format.layout) {
default:
result = image->initialize(device, desc);
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
if (isImportedWin32Handle(desc)) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} else {
ze_image_desc_t imgDesc = {};
getImageDescriptorFor3ChEmulation(desc, &imgDesc);
image->setMimickedImage(true);
result = image->initialize(device, &imgDesc);
}
break;
case ZE_IMAGE_FORMAT_LAYOUT_32_32_32:
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
break;
}
if (result != ZE_RESULT_SUCCESS) {
image->destroy();
image = nullptr;

211
level_zero/core/test/unit_tests/sources/image/test_image.cpp
View File

@ -381,6 +381,41 @@ HWTEST2_F(ImageView, given3ChannelImageWhenCreateImageViewIsCalledThenProperView
zeImageDestroy(imgHandle);
}
HWTEST2_F(ImageView, given3Channel16BitImageWhenCreateImageViewIsCalledThenProperViewIsCreated, MatchAny) {
const size_t width = 32;
const size_t height = 32;
const size_t depth = 1;
ze_image_desc_t srcImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_16_16_16, ZE_IMAGE_FORMAT_TYPE_FLOAT,
ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_1},
width,
height,
depth,
0,
0};
Image *imagePtr;
auto result = Image::create(productFamily, device, &srcImgDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_image_handle_t imgHandle = imagePtr->toHandle();
ze_image_handle_t viewHandle;
auto ret = L0::Image::fromHandle(imgHandle)->createView(device, &srcImgDesc, &viewHandle);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
auto viewDesc = static_cast<L0::Image *>(viewHandle)->getImageInfo().imgDesc;
EXPECT_EQ(width, viewDesc.imageWidth);
EXPECT_EQ(height, viewDesc.imageHeight);
zeImageDestroy(viewHandle);
zeImageDestroy(imgHandle);
}
HWTEST2_F(ImageView, given3ChannelMickedImageWhenCreateImageViewIsCalledThenProperViewIsCreated, MatchAny) {
const size_t width = 32;
const size_t height = 32;
@ -425,6 +460,49 @@ HWTEST2_F(ImageView, given3ChannelMickedImageWhenCreateImageViewIsCalledThenProp
zeImageDestroy(imgHandle);
}
HWTEST2_F(ImageView, given32bitImageWhenCreateImageViewIsCalledWith3ChannelThenNotSuppotedIsReturned, MatchAny) {
const size_t width = 32;
const size_t height = 32;
const size_t depth = 1;
ze_image_desc_t srcImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_32_32_32_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},
width,
height,
depth,
0,
0};
Image *imagePtr;
auto result = Image::create(productFamily, device, &srcImgDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_image_handle_t imgHandle = imagePtr->toHandle();
ze_image_desc_t viewImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_32_32_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_1},
width,
height,
depth,
0,
0};
ze_image_handle_t viewHandle;
auto ret = L0::Image::fromHandle(imgHandle)->createView(device, &viewImgDesc, &viewHandle);
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, ret);
zeImageDestroy(imgHandle);
}
HWTEST2_F(ImageView, givenPlanarImageWhenCreateImageWithInvalidStructViewThenProperErrorIsReturned, MatchAny) {
const size_t width = 32;
const size_t height = 32;
@ -2534,49 +2612,6 @@ HWTEST2_F(ImageCreateExternalMemoryTest, givenNTHandleWhenCreatingInteropImageTh
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreateExternalMemoryTest, givenNTHandleOfInteropImageWhenImageViewCreateIsCalledThenSuccessIsReturned, MatchAny) {
const size_t width = 32;
const size_t height = 32;
const size_t depth = 1;
ze_image_desc_t srcImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_8_8_8, ZE_IMAGE_FORMAT_TYPE_UNORM,
ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_1},
width,
height,
depth,
0,
0};
ze_external_memory_import_win32_handle_t importNTHandle = {};
importNTHandle.handle = &imageHandle;
importNTHandle.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
importNTHandle.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32;
srcImgDesc.pNext = &importNTHandle;
delete driverHandle->svmAllocsManager;
driverHandle->setMemoryManager(execEnv->memoryManager.get());
driverHandle->svmAllocsManager = new NEO::SVMAllocsManager(execEnv->memoryManager.get(), false);
Image *imagePtr;
auto result = Image::create(productFamily, device, &srcImgDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
ze_image_handle_t imgHandle = imagePtr->toHandle();
ze_image_handle_t viewHandle;
srcImgDesc.pNext = nullptr;
auto ret = L0::Image::fromHandle(imgHandle)->createView(device, &srcImgDesc, &viewHandle);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
zeImageDestroy(viewHandle);
}
HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel8bitUintThenSuccessIsReturned, MatchAny) {
ze_image_desc_t desc = {};
@ -2607,6 +2642,35 @@ HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel8bitUintThenSuccessIs
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreateExternalMemoryTest, givenNtHandleWhenCreatingImageWith3Channel8bitUintThenNotSupportedIsReturned, MatchAny) {
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
desc.type = ZE_IMAGE_TYPE_3D;
desc.format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8;
desc.format.type = ZE_IMAGE_FORMAT_TYPE_UINT;
desc.width = 11;
desc.height = 13;
desc.depth = 17;
desc.format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
desc.format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
desc.format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
desc.format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
ze_external_memory_import_win32_handle_t importNTHandle = {};
importNTHandle.handle = &imageHandle;
importNTHandle.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
importNTHandle.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32;
desc.pNext = &importNTHandle;
Image *imagePtr = nullptr;
auto result = Image::create(productFamily, device, &desc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
std::unique_ptr<L0::Image> image(imagePtr);
EXPECT_EQ(image, nullptr);
}
HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel16bitUintThenSuccessIsReturned, MatchAny) {
ze_image_desc_t desc = {};
@ -2637,5 +2701,66 @@ HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel16bitUintThenSuccessI
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreate, givenValidImageDescriptionFor3Channel32BitFloatWhenImageCreateThenUnsupportedIsReturned, MatchAny) {
ze_image_desc_t zeDesc = {};
zeDesc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
zeDesc.arraylevels = 1u;
zeDesc.depth = 1u;
zeDesc.height = 1u;
zeDesc.width = 100u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
zeDesc.flags = ZE_IMAGE_FLAG_BIAS_UNCACHED;
zeDesc.format = {ZE_IMAGE_FORMAT_LAYOUT_32_32_32,
ZE_IMAGE_FORMAT_TYPE_FLOAT,
ZE_IMAGE_FORMAT_SWIZZLE_R,
ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_1};
Image *imagePtr;
auto result = Image::create(productFamily, device, &zeDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
std::unique_ptr<L0::Image> image(imagePtr);
EXPECT_EQ(image, nullptr);
}
HWTEST2_F(ImageView, given3ChannelImageWhenCreateImageViewWithNtHandleIsCalledThenNotSupportedIsReturned, MatchAny) {
const size_t width = 32;
const size_t height = 32;
const size_t depth = 1;
ze_image_desc_t srcImgDesc = {ZE_STRUCTURE_TYPE_IMAGE_DESC,
nullptr,
(ZE_IMAGE_FLAG_KERNEL_WRITE | ZE_IMAGE_FLAG_BIAS_UNCACHED),
ZE_IMAGE_TYPE_2D,
{ZE_IMAGE_FORMAT_LAYOUT_8_8_8, ZE_IMAGE_FORMAT_TYPE_UNORM,
ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_1},
width,
height,
depth,
0,
0};
Image *imagePtr;
auto result = Image::create(productFamily, device, &srcImgDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_image_handle_t imgHandle = imagePtr->toHandle();
ze_external_memory_import_win32_handle_t importNTHandle = {};
importNTHandle.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
importNTHandle.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32;
srcImgDesc.pNext = &importNTHandle;
ze_image_handle_t viewHandle;
auto ret = L0::Image::fromHandle(imgHandle)->createView(device, &srcImgDesc, &viewHandle);
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, ret);
zeImageDestroy(imgHandle);
}
} // namespace ult
} // namespace L0