diff --git a/shared/source/device_binary_format/elf/zebin_elf.h b/shared/source/device_binary_format/elf/zebin_elf.h index 4d8c8897bb..c0bce01633 100644 --- a/shared/source/device_binary_format/elf/zebin_elf.h +++ b/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 diff --git a/shared/source/device_binary_format/elf/zeinfo_enum_lookup.h b/shared/source/device_binary_format/elf/zeinfo_enum_lookup.h index 9335265f5f..6951c59559 100644 --- a/shared/source/device_binary_format/elf/zeinfo_enum_lookup.h +++ b/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 lookup({{{packedLocalIds, ArgType::ArgTypePackedLocalIds}, +static constexpr LookupArray lookup({{{packedLocalIds, ArgType::ArgTypePackedLocalIds}, {localId, ArgType::ArgTypeLocalId}, {localSize, ArgType::ArgTypeLocalSize}, {groupCount, ArgType::ArgTypeGroupCount}, @@ -46,7 +48,14 @@ static constexpr LookupArray 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 lookup({{{imageTypeMedia, ImageType::ImageTypeMedia}, - {imageTypeBlock, ImageType::ImageTypeMediaBlock}}}); +static constexpr LookupArray 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 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 struct EnumLooker {}; @@ -147,4 +187,9 @@ struct EnumLooker { static constexpr ConstStringRef name = ImageType::name; static constexpr auto members = ImageType::lookup; }; +template <> +struct EnumLooker { + static constexpr ConstStringRef name = SamplerType::name; + static constexpr auto members = SamplerType::lookup; +}; } // namespace NEO::Zebin::ZeInfo::EnumLookup \ No newline at end of file diff --git a/shared/source/device_binary_format/zebin_decoder.cpp b/shared/source/device_binary_format/zebin_decoder.cpp index 3a7489b47e..93318a4b0a 100644 --- a/shared/source/device_binary_format/zebin_decoder.cpp +++ b/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(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(); + } + return static_cast(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(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(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(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()) { + static constexpr auto maxSamplerStateSize = 16U; + static constexpr auto maxIndirectSamplerStateSize = 64U; + auto &sampler = dst.payloadMappings.explicitArgs[src.argIndex].as(); + sampler.bindful = maxIndirectSamplerStateSize + maxSamplerStateSize * src.samplerIndex; + } break; case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::MemoryAddressingModeStateless: if (false == dst.payloadMappings.explicitArgs[src.argIndex].is()) { @@ -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(); - arg.metadataPayload.imgHeight = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageHeight: + explicitArgs[src.argIndex].as(true).metadataPayload.imgHeight = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageWidth: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.imgWidth = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageWidth: + explicitArgs[src.argIndex].as(true).metadataPayload.imgWidth = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageDepth: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.imgDepth = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageDepth: + explicitArgs[src.argIndex].as(true).metadataPayload.imgDepth = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelDataType: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.channelDataType = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelDataType: + explicitArgs[src.argIndex].as(true).metadataPayload.channelDataType = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelOrder: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.channelOrder = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageChannelOrder: + explicitArgs[src.argIndex].as(true).metadataPayload.channelOrder = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageArraySize: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.arraySize = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageArraySize: + explicitArgs[src.argIndex].as(true).metadataPayload.arraySize = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageNumSamples: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.numSamples = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageNumSamples: + explicitArgs[src.argIndex].as(true).metadataPayload.numSamples = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageMipLevels: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.numMipLevels = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageMipLevels: + explicitArgs[src.argIndex].as(true).metadataPayload.numMipLevels = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatBaseOffset: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.flatBaseOffset = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatBaseOffset: + explicitArgs[src.argIndex].as(true).metadataPayload.flatBaseOffset = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatWidth: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.flatWidth = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatWidth: + explicitArgs[src.argIndex].as(true).metadataPayload.flatWidth = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatHeight: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.flatHeight = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatHeight: + explicitArgs[src.argIndex].as(true).metadataPayload.flatHeight = src.offset; + break; - case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatPitch: { - auto &arg = dst.payloadMappings.explicitArgs[src.argIndex].as(); - arg.metadataPayload.flatPitch = src.offset; - } break; + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImageFlatPitch: + explicitArgs[src.argIndex].as(true).metadataPayload.flatPitch = src.offset; + break; + + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerAddrMode: + explicitArgs[src.argIndex].as(true).metadataPayload.samplerAddressingMode = src.offset; + break; + + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerNormCoords: + explicitArgs[src.argIndex].as(true).metadataPayload.samplerNormalizedCoords = src.offset; + break; + + case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeSamplerSnapWa: + explicitArgs[src.argIndex].as(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; } diff --git a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp index e825f6fb6d..27bd86c38c 100644 --- a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp +++ b/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()); } -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()); -} - 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(); + EXPECT_EQ(64U, sampler0.bindful); + + auto &sampler1 = args[1].as(); + EXPECT_TRUE(args[1].getExtendedTypeInfo().isAccelerator); + EXPECT_EQ(80U, sampler1.bindful); + + auto &sampler2 = args[2].as(); + 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(); + EXPECT_TRUE(args[3].getExtendedTypeInfo().isAccelerator); + EXPECT_TRUE(args[3].getExtendedTypeInfo().hasVmeExtendedDescriptor); + EXPECT_EQ(12U, sampler3.bindless); + auto vmePayload = static_cast(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 {