feat(zebin): add sampler metadata support

This commit adds support for sampler's metadata in zebinary and
updates some image's metadata field names.

Resolves: NEO-7257

Signed-off-by: Krystian Chmielewski <krystian.chmielewski@intel.com>

shared/source/device_binary_format/elf/zebin_elf.h

@@ -170,6 +170,8 @@ static constexpr ConstStringRef sourceOffset("source_offset");
 static constexpr ConstStringRef slmArgAlignment("slm_alignment");
 static constexpr ConstStringRef imageType("image_type");
 static constexpr ConstStringRef imageTransformable("image_transformable");
+static constexpr ConstStringRef samplerType("sampler_type");
+
 namespace ArgType {
 static constexpr ConstStringRef localSize("local_size");
 static constexpr ConstStringRef groupCount("group_count");
@@ -192,17 +194,56 @@ static constexpr ConstStringRef channelDataType("image_channel_data_type");
 static constexpr ConstStringRef channelOrder("image_channel_order");
 static constexpr ConstStringRef arraySize("image_array_size");
 static constexpr ConstStringRef numSamples("image_num_samples");
-static constexpr ConstStringRef numMipLevels("image_mip_levels");
-static constexpr ConstStringRef flatBaseOffset("image_flat_base_offset");
-static constexpr ConstStringRef flatWidth("image_flat_width");
-static constexpr ConstStringRef flatHeight("image_flat_height");
-static constexpr ConstStringRef flatPitch("image_flat_pitch");
+static constexpr ConstStringRef numMipLevels("image_num_mip_levels");
+static constexpr ConstStringRef flatBaseOffset("flat_image_baseoffset");
+static constexpr ConstStringRef flatWidth("flat_image_width");
+static constexpr ConstStringRef flatHeight("flat_image_height");
+static constexpr ConstStringRef flatPitch("flat_image_pitch");
 } // namespace Image
+namespace Sampler {
+static constexpr ConstStringRef snapWa("sampler_snap_wa");
+static constexpr ConstStringRef normCoords("sampler_normalized");
+static constexpr ConstStringRef addrMode("sampler_address");
+namespace Vme {
+static constexpr ConstStringRef blockType("vme_mb_block_type");
+static constexpr ConstStringRef subpixelMode("vme_subpixel_mode");
+static constexpr ConstStringRef sadAdjustMode("vme_sad_adjust_mode");
+static constexpr ConstStringRef searchPathType("vme_search_path_type");
+} // namespace Vme
+} // namespace Sampler
 } // namespace ArgType
 namespace ImageType {
-static constexpr ConstStringRef imageTypeMedia("media");
-static constexpr ConstStringRef imageTypeBlock("media_block");
+static constexpr ConstStringRef imageTypeBuffer("image_buffer");
+static constexpr ConstStringRef imageType1D("image_1d");
+static constexpr ConstStringRef imageType1DArray("image_1d_array");
+static constexpr ConstStringRef imageType2D("image_2d");
+static constexpr ConstStringRef imageType2DArray("image_2d_array");
+static constexpr ConstStringRef imageType3D("image_3d");
+static constexpr ConstStringRef imageTypeCube("image_cube_array");
+static constexpr ConstStringRef imageTypeCubeArray("image_buffer");
+static constexpr ConstStringRef imageType2DDepth("image_2d_depth");
+static constexpr ConstStringRef imageType2DArrayDepth("image_2d_array_depth");
+static constexpr ConstStringRef imageType2DMSAA("image_2d_msaa");
+static constexpr ConstStringRef imageType2DMSAADepth("image_2d_msaa_depth");
+static constexpr ConstStringRef imageType2DArrayMSAA("image_2d_array_msaa");
+static constexpr ConstStringRef imageType2DArrayMSAADepth("image_2d_array_msaa_depth");
+static constexpr ConstStringRef imageType2DMedia("image_2d_media");
+static constexpr ConstStringRef imageType2DMediaBlock("image_2d_media_block");
 } // namespace ImageType
+namespace SamplerType {
+static constexpr ConstStringRef samplerTypeTexture("texture");
+static constexpr ConstStringRef samplerType8x8("sample_8x8");
+static constexpr ConstStringRef samplerType2DConsolve8x8("sample_8x8_2dconvolve");
+static constexpr ConstStringRef samplerTypeErode8x8("sample_8x8_erode");
+static constexpr ConstStringRef samplerTypeDilate8x8("sample_8x8_dilate");
+static constexpr ConstStringRef samplerTypeMinMaxFilter8x8("sample_8x8_minmaxfilter");
+static constexpr ConstStringRef samplerTypeCentroid8x8("sample_8x8_centroid");
+static constexpr ConstStringRef samplerTypeBoolCentroid8x8("sample_8x8_bool_centroid");
+static constexpr ConstStringRef samplerTypeBoolSum8x8("sample_8x8_bool_sum");
+static constexpr ConstStringRef samplerTypeVD("vd");
+static constexpr ConstStringRef samplerTypeVE("ve");
+static constexpr ConstStringRef samplerTypeVME("vme");
+} // namespace SamplerType
 namespace MemoryAddressingMode {
 static constexpr ConstStringRef stateless("stateless");
 static constexpr ConstStringRef stateful("stateful");
@@ -412,6 +453,13 @@ enum ArgType : uint8_t {
     ArgTypeImageFlatWidth,
     ArgTypeImageFlatHeight,
     ArgTypeImageFlatPitch,
+    ArgTypeSamplerSnapWa,
+    ArgTypeSamplerNormCoords,
+    ArgTypeSamplerAddrMode,
+    ArgTypeVmeMbBlockType,
+    ArgTypeVmeSubpixelMode,
+    ArgTypeVmeSadAdjustMode,
+    ArgTypeVmeSearchPathType,
     ArgTypeMax
 };
 
@@ -463,11 +511,42 @@ enum AccessType : uint8_t {
 
 enum ImageType : uint8_t {
     ImageTypeUnknown,
-    ImageTypeMedia,
-    ImageTypeMediaBlock,
+    ImageTypeBuffer,
+    ImageType1D,
+    ImageType1DArray,
+    ImageType2D,
+    ImageType2DArray,
+    ImageType3D,
+    ImageTypeCube,
+    ImageTypeCubeArray,
+    ImageType2DDepth,
+    ImageType2DArrayDepth,
+    ImageType2DMSAA,
+    ImageType2DMSAADepth,
+    ImageType2DArrayMSAA,
+    ImageType2DArrayMSAADepth,
+    ImageType2DMedia,
+    ImageType2DMediaBlock,
     ImageTypeMax
 };
 
+enum SamplerType : uint8_t {
+    SamplerTypeUnknown,
+    SamplerTypeTexture,
+    SamplerType8x8,
+    SamplerType2DConvolve8x8,
+    SamplerTypeErode8x8,
+    SamplerTypeDilate8x8,
+    SamplerTypeMinMaxFilter8x8,
+    SamplerTypeCentroid8x8,
+    SamplerTypeBoolCentroid8x8,
+    SamplerTypeBoolSum8x8,
+    SamplerTypeVME,
+    SamplerTypeVE,
+    SamplerTypeVD,
+    SamplerTypeMax
+};
+
 using ArgTypeT = ArgType;
 using OffseT = int32_t;
 using SourceOffseT = int32_t;
@@ -499,6 +578,7 @@ struct PayloadArgumentBaseT {
     SlmAlignmentT slmArgAlignment = Defaults::slmArgAlignment;
     ImageType imageType = ImageTypeUnknown;
     bool imageTransformable = false;
+    SamplerType samplerType = SamplerTypeUnknown;
 };
 
 } // namespace PayloadArgument

shared/source/device_binary_format/elf/zeinfo_enum_lookup.h

@@ -17,10 +17,12 @@ namespace ArgType {
 using namespace Tags::Kernel::PayloadArgument::ArgType;
 using namespace Tags::Kernel::PerThreadPayloadArgument::ArgType;
 using namespace Tags::Kernel::PayloadArgument::ArgType::Image;
+using namespace Tags::Kernel::PayloadArgument::ArgType::Sampler;
+using namespace Tags::Kernel::PayloadArgument::ArgType::Sampler::Vme;
 using ArgType = Types::Kernel::ArgType;
 
 static constexpr ConstStringRef name = "argument type";
-static constexpr LookupArray<ConstStringRef, ArgType, 27> lookup({{{packedLocalIds, ArgType::ArgTypePackedLocalIds},
+static constexpr LookupArray<ConstStringRef, ArgType, 34> lookup({{{packedLocalIds, ArgType::ArgTypePackedLocalIds},
                                                                    {localId, ArgType::ArgTypeLocalId},
                                                                    {localSize, ArgType::ArgTypeLocalSize},
                                                                    {groupCount, ArgType::ArgTypeGroupCount},
@@ -46,7 +48,14 @@ static constexpr LookupArray<ConstStringRef, ArgType, 27> lookup({{{packedLocalI
                                                                    {flatBaseOffset, ArgType::ArgTypeImageFlatBaseOffset},
                                                                    {flatWidth, ArgType::ArgTypeImageFlatWidth},
                                                                    {flatHeight, ArgType::ArgTypeImageFlatHeight},
-                                                                   {flatPitch, ArgType::ArgTypeImageFlatPitch}}});
+                                                                   {flatPitch, ArgType::ArgTypeImageFlatPitch},
+                                                                   {snapWa, ArgType::ArgTypeSamplerSnapWa},
+                                                                   {normCoords, ArgType::ArgTypeSamplerNormCoords},
+                                                                   {addrMode, ArgType::ArgTypeSamplerAddrMode},
+                                                                   {blockType, ArgType::ArgTypeVmeMbBlockType},
+                                                                   {subpixelMode, ArgType::ArgTypeVmeSubpixelMode},
+                                                                   {sadAdjustMode, ArgType::ArgTypeVmeSadAdjustMode},
+                                                                   {searchPathType, ArgType::ArgTypeVmeSearchPathType}}});
 static_assert(lookup.size() == ArgType::ArgTypeMax - 1, "Every enum field must be present");
 } // namespace ArgType
 namespace MemoryAddressingMode {
@@ -103,11 +112,42 @@ namespace ImageType {
 using namespace Tags::Kernel::PayloadArgument::ImageType;
 using ImageType = Types::Kernel::PayloadArgument::ImageType;
 static constexpr ConstStringRef name = "image type";
-static constexpr LookupArray<ConstStringRef, ImageType, 2> lookup({{{imageTypeMedia, ImageType::ImageTypeMedia},
-                                                                    {imageTypeBlock, ImageType::ImageTypeMediaBlock}}});
+static constexpr LookupArray<ConstStringRef, ImageType, 16> lookup({{{imageTypeBuffer, ImageType::ImageTypeBuffer},
+                                                                     {imageType1D, ImageType::ImageType1D},
+                                                                     {imageType1DArray, ImageType::ImageType1DArray},
+                                                                     {imageType2D, ImageType::ImageType2D},
+                                                                     {imageType2DArray, ImageType::ImageType2DArray},
+                                                                     {imageType3D, ImageType::ImageType3D},
+                                                                     {imageTypeCube, ImageType::ImageTypeCube},
+                                                                     {imageTypeCubeArray, ImageType::ImageTypeCubeArray},
+                                                                     {imageType2DDepth, ImageType::ImageType2DDepth},
+                                                                     {imageType2DArrayDepth, ImageType::ImageType2DArrayDepth},
+                                                                     {imageType2DMSAA, ImageType::ImageType2DMSAA},
+                                                                     {imageType2DMSAADepth, ImageType::ImageType2DMSAADepth},
+                                                                     {imageType2DArrayMSAA, ImageType::ImageType2DArrayMSAA},
+                                                                     {imageType2DArrayMSAADepth, ImageType::ImageType2DArrayMSAADepth},
+                                                                     {imageType2DMedia, ImageType::ImageType2DMedia},
+                                                                     {imageType2DMediaBlock, ImageType::ImageType2DMediaBlock}}});
 static_assert(lookup.size() == ImageType::ImageTypeMax - 1, "Every enum field must be present");
-
 } // namespace ImageType
+namespace SamplerType {
+using namespace Tags::Kernel::PayloadArgument::SamplerType;
+using SamplerType = Types::Kernel::PayloadArgument::SamplerType;
+static constexpr ConstStringRef name = "sampler type";
+static constexpr LookupArray<ConstStringRef, SamplerType, 12> lookup({{{samplerTypeTexture, SamplerType::SamplerTypeTexture},
+                                                                       {samplerType8x8, SamplerType::SamplerType8x8},
+                                                                       {samplerType2DConsolve8x8, SamplerType::SamplerType2DConvolve8x8},
+                                                                       {samplerTypeErode8x8, SamplerType::SamplerTypeErode8x8},
+                                                                       {samplerTypeDilate8x8, SamplerType::SamplerTypeDilate8x8},
+                                                                       {samplerTypeMinMaxFilter8x8, SamplerType::SamplerTypeMinMaxFilter8x8},
+                                                                       {samplerTypeCentroid8x8, SamplerType::SamplerTypeBoolCentroid8x8},
+                                                                       {samplerTypeBoolCentroid8x8, SamplerType::SamplerTypeBoolCentroid8x8},
+                                                                       {samplerTypeBoolSum8x8, SamplerType::SamplerTypeBoolSum8x8},
+                                                                       {samplerTypeVME, SamplerType::SamplerTypeVME},
+                                                                       {samplerTypeVE, SamplerType::SamplerTypeVE},
+                                                                       {samplerTypeVD, SamplerType::SamplerTypeVD}}});
+static_assert(lookup.size() == SamplerType::SamplerTypeMax - 1, "Every enum field must be present");
+} // namespace SamplerType
 
 template <typename T>
 struct EnumLooker {};
@@ -147,4 +187,9 @@ struct EnumLooker<Types::Kernel::PayloadArgument::ImageType> {
     static constexpr ConstStringRef name = ImageType::name;
     static constexpr auto members = ImageType::lookup;
 };
+template <>
+struct EnumLooker<Types::Kernel::PayloadArgument::SamplerType> {
+    static constexpr ConstStringRef name = SamplerType::name;
+    static constexpr auto members = SamplerType::lookup;
+};
 } // namespace NEO::Zebin::ZeInfo::EnumLookup

shared/source/device_binary_format/zebin_decoder.cpp

@@ -16,6 +16,7 @@
 #include "shared/source/device_binary_format/elf/zeinfo_enum_lookup.h"
 #include "shared/source/device_binary_format/yaml/yaml_parser.h"
 #include "shared/source/helpers/ptr_math.h"
+#include "shared/source/kernel/kernel_arg_descriptor_extended_vme.h"
 #include "shared/source/program/kernel_info.h"
 #include "shared/source/program/program_info.h"
 #include "shared/source/utilities/stackvec.h"
@@ -501,6 +502,8 @@ DecodeError readZeInfoPayloadArguments(const NEO::Yaml::YamlParser &parser, cons
                 validPayload &= readZeInfoEnumChecked(parser, payloadArgumentMemberNd, payloadArgMetadata.imageType, context, outErrReason);
             } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::imageTransformable == key) {
                 validPayload &= readZeInfoValueChecked(parser, payloadArgumentMemberNd, payloadArgMetadata.imageTransformable, context, outErrReason);
+            } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::samplerType == key) {
+                validPayload &= readZeInfoEnumChecked(parser, payloadArgumentMemberNd, payloadArgMetadata.samplerType, context, outErrReason);
             } else {
                 outWarning.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unknown entry \"" + key.str() + "\" for payload argument in context of " + context.str() + "\n");
             }
@@ -674,6 +677,17 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
 NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::PayloadArgumentBaseT &src, NEO::KernelDescriptor &dst, uint32_t &crossThreadDataSize,
                                        std::string &outErrReason, std::string &outWarning) {
     crossThreadDataSize = std::max<uint32_t>(crossThreadDataSize, src.offset + src.size);
+
+    auto &explicitArgs = dst.payloadMappings.explicitArgs;
+    auto getVmeDescriptor = [&src, &dst]() {
+        auto &argsExt = dst.payloadMappings.explicitArgsExtendedDescriptors;
+        argsExt.resize(dst.payloadMappings.explicitArgs.size());
+        if (argsExt[src.argIndex] == nullptr) {
+            argsExt[src.argIndex] = std::make_unique<ArgDescVme>();
+        }
+        return static_cast<ArgDescVme *>(argsExt[src.argIndex].get());
+    };
+
     switch (src.argType) {
     default:
         outErrReason.append("DeviceBinaryFormat::Zebin : Invalid arg type in cross thread data section in context of : " + dst.kernelMetadata.kernelName + ".\n");
@@ -686,7 +700,8 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
     }
 
     case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeArgBypointer: {
-        auto &argTraits = dst.payloadMappings.explicitArgs[src.argIndex].getTraits();
+        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex];
+        auto &argTraits = arg.getTraits();
         switch (src.addrspace) {
         default:
             UNRECOVERABLE_IF(NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::AddressSpaceUnknown != src.addrspace);
@@ -708,15 +723,23 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
         case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::AddressSpaceImage: {
             dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>(true);
             auto &extendedInfo = dst.payloadMappings.explicitArgs[src.argIndex].getExtendedTypeInfo();
-            extendedInfo.isMediaImage = (src.imageType == NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::ImageType::ImageTypeMedia);
-            extendedInfo.isMediaBlockImage = (src.imageType == NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::ImageType::ImageTypeMediaBlock);
+            extendedInfo.isMediaImage = (src.imageType == NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::ImageType::ImageType2DMedia);
+            extendedInfo.isMediaBlockImage = (src.imageType == NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::ImageType::ImageType2DMediaBlock);
             extendedInfo.isTransformable = src.imageTransformable;
+            dst.kernelAttributes.flags.usesImages = true;
+        } break;
+        case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::AddressSpaceSampler: {
+            using SamplerType = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::SamplerType;
+            dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescSampler>(true);
+            auto &extendedInfo = arg.getExtendedTypeInfo();
+            extendedInfo.isAccelerator = (src.samplerType == SamplerType::SamplerTypeVME) ||
+                                         (src.samplerType == SamplerType::SamplerTypeVE) ||
+                                         (src.samplerType == SamplerType::SamplerTypeVD);
+            const bool usesVme = src.samplerType == SamplerType::SamplerTypeVME;
+            extendedInfo.hasVmeExtendedDescriptor = usesVme;
+            dst.kernelAttributes.flags.usesVme = usesVme;
+            dst.kernelAttributes.flags.usesSamplers = true;
         } break;
-        case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::AddressSpaceSampler:
-            static constexpr auto maxSamplerStateSize = 16U;
-            static constexpr auto maxIndirectSamplerStateSize = 64U;
-            dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescSampler>(true).bindful = maxIndirectSamplerStateSize + maxSamplerStateSize * src.samplerIndex;
-            break;
         }
 
         switch (src.accessType) {
@@ -744,6 +767,12 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
             outErrReason.append("Invalid or missing memory addressing mode for arg idx : " + std::to_string(src.argIndex) + " in context of : " + dst.kernelMetadata.kernelName + ".\n");
             return DecodeError::InvalidBinary;
         case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::MemoryAddressingModeStateful:
+            if (dst.payloadMappings.explicitArgs[src.argIndex].is<NEO::ArgDescriptor::ArgTSampler>()) {
+                static constexpr auto maxSamplerStateSize = 16U;
+                static constexpr auto maxIndirectSamplerStateSize = 64U;
+                auto &sampler = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescSampler>();
+                sampler.bindful = maxIndirectSamplerStateSize + maxSamplerStateSize * src.samplerIndex;
+            }
             break;
         case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::MemoryAddressingModeStateless:
             if (false == dst.payloadMappings.explicitArgs[src.argIndex].is<NEO::ArgDescriptor::ArgTPointer>()) {
@@ -868,65 +897,81 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
         break;
     }
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageHeight: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.imgHeight = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageHeight:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.imgHeight = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageWidth: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.imgWidth = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageWidth:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.imgWidth = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageDepth: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.imgDepth = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageDepth:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.imgDepth = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelDataType: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.channelDataType = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelDataType:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.channelDataType = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelOrder: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.channelOrder = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelOrder:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.channelOrder = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageArraySize: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.arraySize = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageArraySize:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.arraySize = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageNumSamples: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.numSamples = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageNumSamples:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.numSamples = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageMipLevels: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.numMipLevels = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageMipLevels:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.numMipLevels = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatBaseOffset: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.flatBaseOffset = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatBaseOffset:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.flatBaseOffset = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatWidth: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.flatWidth = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatWidth:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.flatWidth = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatHeight: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.flatHeight = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatHeight:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.flatHeight = src.offset;
+        break;
 
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatPitch: {
-        auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescImage>();
-        arg.metadataPayload.flatPitch = src.offset;
-    } break;
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatPitch:
+        explicitArgs[src.argIndex].as<ArgDescImage>(true).metadataPayload.flatPitch = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerAddrMode:
+        explicitArgs[src.argIndex].as<ArgDescSampler>(true).metadataPayload.samplerAddressingMode = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerNormCoords:
+        explicitArgs[src.argIndex].as<ArgDescSampler>(true).metadataPayload.samplerNormalizedCoords = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerSnapWa:
+        explicitArgs[src.argIndex].as<ArgDescSampler>(true).metadataPayload.samplerSnapWa = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeVmeMbBlockType:
+        getVmeDescriptor()->mbBlockType = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeVmeSubpixelMode:
+        getVmeDescriptor()->subpixelMode = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeVmeSadAdjustMode:
+        getVmeDescriptor()->sadAdjustMode = src.offset;
+        break;
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeVmeSearchPathType:
+        getVmeDescriptor()->searchPathType = src.offset;
+        break;
     }
     return DecodeError::Success;
 }

shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

@@ -11,6 +11,7 @@
 #include "shared/source/device_binary_format/zebin_decoder.h"
 #include "shared/source/helpers/ptr_math.h"
 #include "shared/source/helpers/string.h"
+#include "shared/source/kernel/kernel_arg_descriptor_extended_vme.h"
 #include "shared/source/program/kernel_info.h"
 #include "shared/source/program/program_info.h"
 #include "shared/test/common/device_binary_format/zebin_tests.h"
@@ -3897,47 +3898,6 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenPointerArgWhenAddressSpaceIsI
     EXPECT_TRUE(programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs[0].is<NEO::ArgDescriptor::ArgTImage>());
 }
 
-TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenPointerArgWhenAddressSpaceIsSamplerThenPopulatesArgDescriptorAccordingly) {
-    using AddressSpace = NEO::KernelArgMetadata::AddressSpaceQualifier;
-    using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::AddrSpace;
-
-    std::string zeinfo = R"===(
-    kernels:
-        - name : 'some_kernel'
-            execution_env:   
-                simd_size: 32
-            payload_arguments: 
-                - arg_type : arg_bypointer
-                  arg_index	: 0
-                  addrspace:       sampler
-                  access_type:     readwrite
-                  addrmode: stateful
-    )===";
-    NEO::ProgramInfo programInfo;
-    ZebinTestData::ValidEmptyProgram zebin;
-    zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
-    std::string errors, warnings;
-    auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
-    ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
-
-    NEO::Yaml::YamlParser parser;
-    bool parseSuccess = parser.parse(zeinfo, errors, warnings);
-    ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
-
-    NEO::ZebinSections zebinSections;
-    auto extractErr = NEO::extractZebinSections(elf, zebinSections, errors, warnings);
-    ASSERT_EQ(NEO::DecodeError::Success, extractErr) << errors << " " << warnings;
-
-    auto &kernelNode = *parser.createChildrenRange(*parser.findNodeWithKeyDfs("kernels")).begin();
-    auto err = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
-    EXPECT_EQ(NEO::DecodeError::Success, err);
-    EXPECT_TRUE(errors.empty()) << errors;
-    EXPECT_TRUE(warnings.empty()) << warnings;
-    ASSERT_EQ(1U, programInfo.kernelInfos.size());
-    ASSERT_EQ(1U, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs.size());
-    EXPECT_TRUE(programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs[0].is<NEO::ArgDescriptor::ArgTSampler>());
-}
-
 TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenPointerArgWhenAccessQualifierIsKnownThenPopulatesArgDescriptorAccordingly) {
     using AccessQualifier = NEO::KernelArgMetadata::AccessQualifier;
     using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::AccessType;
@@ -4900,6 +4860,7 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenArgTypePrintfBufferWhenOffset
     ASSERT_EQ(32U, printfSurfaceAddress.stateless);
     EXPECT_EQ(8U, printfSurfaceAddress.pointerSize);
 }
+
 TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidImageArgumentWithImageMetadataThenPopulatesKernelDescriptor) {
     NEO::ConstStringRef zeinfo = R"===(
         kernels:
@@ -4914,7 +4875,7 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidImageArgumentWithImageMe
                   addrmode:        stateful
                   addrspace:       image
                   access_type:     readwrite
-                  image_type:      media
+                  image_type:      image_2d_media
                   image_transformable: true
                 - arg_type:        arg_bypointer
                   offset:          0
@@ -4923,7 +4884,7 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidImageArgumentWithImageMe
                   addrmode:        stateful
                   addrspace:       image
                   access_type:     readwrite
-                  image_type:      media_block
+                  image_type:      image_2d_media_block
                 - arg_type:        image_height
                   offset:          0
                   size:            4
@@ -4952,23 +4913,23 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidImageArgumentWithImageMe
                   offset:          24
                   size:            4
                   arg_index:       1
-                - arg_type:        image_mip_levels
+                - arg_type:        image_num_mip_levels
                   offset:          28
                   size:            4
                   arg_index:       1
-                - arg_type:        image_flat_base_offset
+                - arg_type:        flat_image_baseoffset
                   offset:          32
                   size:            8
                   arg_index:       1
-                - arg_type:        image_flat_width
+                - arg_type:        flat_image_width
                   offset:          40
                   size:            4
                   arg_index:       1
-                - arg_type:        image_flat_height
+                - arg_type:        flat_image_height
                   offset:          44
                   size:            4
                   arg_index:       1
-                - arg_type:        image_flat_pitch
+                - arg_type:        flat_image_pitch
                   offset:          48
                   size:            4
                   arg_index:       1
@@ -5022,6 +4983,128 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidImageArgumentWithImageMe
     EXPECT_EQ(48U, imgMetadata.flatPitch);
 }
 
+TEST(PopulateArgDescriptorCrossthreadPayload, GivenValidSamplerArgumentWithMetadataThenPopulatesKernelDescriptor) {
+    NEO::ConstStringRef zeinfo = R"===(
+        kernels:
+            - name : some_kernel
+              execution_env:
+                simd_size: 32
+              payload_arguments:
+                - arg_type:        arg_bypointer
+                  offset:          0
+                  size:            0
+                  arg_index:       0
+                  addrmode:        stateful
+                  addrspace:       sampler
+                  access_type:     readwrite
+                  sampler_index:   0
+                - arg_type:        arg_bypointer
+                  offset:          0
+                  size:            0
+                  arg_index:       1
+                  addrmode:        stateful
+                  addrspace:       sampler
+                  access_type:     readwrite
+                  sampler_index:   1
+                  sampler_type:    vd
+                - arg_type:        arg_bypointer
+                  offset:          0
+                  size:            0
+                  arg_index:       2
+                  addrmode:        stateful
+                  addrspace:       sampler
+                  access_type:     readwrite
+                  sampler_index:   2
+                  sampler_type:    ve
+                - arg_type:        sampler_snap_wa
+                  offset:          0
+                  size:            4
+                  arg_index:       2
+                - arg_type:        sampler_normalized
+                  offset:          4
+                  size:            4
+                  arg_index:       2
+                - arg_type:        sampler_address
+                  offset:          8
+                  size:            4
+                  arg_index:       2
+                - arg_type:        arg_bypointer
+                  offset:          12
+                  size:            0
+                  arg_index:       3
+                  addrmode:        bindless
+                  addrspace:       sampler
+                  access_type:     readwrite
+                  sampler_type:    vme
+                - arg_type:        vme_mb_block_type
+                  offset:          20
+                  size:            4
+                  arg_index:       3
+                - arg_type:        vme_subpixel_mode
+                  offset:          24
+                  size:            4
+                  arg_index:       3
+                - arg_type:        vme_sad_adjust_mode
+                  offset:          28
+                  size:            4
+                  arg_index:       3
+                - arg_type:        vme_search_path_type
+                  offset:          32
+                  size:            4
+                  arg_index:       3
+)===";
+    NEO::ProgramInfo programInfo;
+    ZebinTestData::ValidEmptyProgram zebin;
+    zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
+    std::string errors, warnings;
+    auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
+    ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
+
+    NEO::Yaml::YamlParser parser;
+    bool parseSuccess = parser.parse(zeinfo, errors, warnings);
+    ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
+
+    NEO::ZebinSections zebinSections;
+    auto extractErr = NEO::extractZebinSections(elf, zebinSections, errors, warnings);
+    ASSERT_EQ(NEO::DecodeError::Success, extractErr) << errors << " " << warnings;
+
+    auto &kernelNode = *parser.createChildrenRange(*parser.findNodeWithKeyDfs("kernels")).begin();
+    auto err = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
+    EXPECT_EQ(NEO::DecodeError::Success, err);
+    EXPECT_TRUE(errors.empty()) << errors;
+    EXPECT_TRUE(warnings.empty()) << warnings;
+
+    const auto &kd = programInfo.kernelInfos[0]->kernelDescriptor;
+    auto &args = kd.payloadMappings.explicitArgs;
+
+    auto &sampler0 = args[0].as<ArgDescSampler>();
+    EXPECT_EQ(64U, sampler0.bindful);
+
+    auto &sampler1 = args[1].as<ArgDescSampler>();
+    EXPECT_TRUE(args[1].getExtendedTypeInfo().isAccelerator);
+    EXPECT_EQ(80U, sampler1.bindful);
+
+    auto &sampler2 = args[2].as<ArgDescSampler>();
+    EXPECT_TRUE(args[2].getExtendedTypeInfo().isAccelerator);
+    EXPECT_EQ(96U, sampler2.bindful);
+    EXPECT_EQ(0U, sampler2.metadataPayload.samplerSnapWa);
+    EXPECT_EQ(4U, sampler2.metadataPayload.samplerNormalizedCoords);
+    EXPECT_EQ(8U, sampler2.metadataPayload.samplerAddressingMode);
+
+    auto &sampler3 = args[3].as<ArgDescSampler>();
+    EXPECT_TRUE(args[3].getExtendedTypeInfo().isAccelerator);
+    EXPECT_TRUE(args[3].getExtendedTypeInfo().hasVmeExtendedDescriptor);
+    EXPECT_EQ(12U, sampler3.bindless);
+    auto vmePayload = static_cast<NEO::ArgDescVme *>(kd.payloadMappings.explicitArgsExtendedDescriptors[3].get());
+    EXPECT_EQ(20U, vmePayload->mbBlockType);
+    EXPECT_EQ(24U, vmePayload->subpixelMode);
+    EXPECT_EQ(28U, vmePayload->sadAdjustMode);
+    EXPECT_EQ(32U, vmePayload->searchPathType);
+
+    EXPECT_TRUE(kd.kernelAttributes.flags.usesSamplers);
+    EXPECT_TRUE(kd.kernelAttributes.flags.usesVme);
+}
+
 class IntelGTNotesFixture : public ::testing::Test {
   protected:
     void SetUp() override {