Updating zeinfo decoder

Change-Id: Ib07b58e628e866af6e5368c6856dc9ebf0985aa7
2025-12-19 15:50:38 +08:00 · 2020-08-19 13:07:34 +02:00
parent ba4dd9f866
commit 2a41911166
3 changed files with 208 additions and 19 deletions
--- a/shared/source/device_binary_format/elf/zebin_elf.h
+++ b/shared/source/device_binary_format/elf/zebin_elf.h
@@ -122,8 +122,10 @@ static constexpr ConstStringRef addrspace("addrspace");
 static constexpr ConstStringRef accessType("access_type");
 namespace ArgType {
 static constexpr ConstStringRef localSize("local_size");
-static constexpr ConstStringRef groupSize("group_size");
+static constexpr ConstStringRef groupCount("group_count");
 static constexpr ConstStringRef globalIdOffset("global_id_offset");
+static constexpr ConstStringRef globalSize("global_size");
+static constexpr ConstStringRef enqueuedLocalSize("enqueued_local_size");
 static constexpr ConstStringRef privateBaseStateless("private_base_stateless");
 static constexpr ConstStringRef argByvalue("arg_byvalue");
 static constexpr ConstStringRef argBypointer("arg_bypointer");
@@ -242,7 +244,9 @@ enum ArgType : uint8_t {
    ArgTypePackedLocalIds = 1,
    ArgTypeLocalId,
    ArgTypeLocalSize,
-    ArgTypeGroupSize,
+    ArgTypeGroupCount,
+    ArgTypeGlobalSize,
+    ArgTypeEnqueuedLocalSize,
    ArgTypeGlobalIdOffset,
    ArgTypePrivateBaseStateless,
    ArgTypeArgByvalue,
--- a/shared/source/device_binary_format/zebin_decoder.cpp
+++ b/shared/source/device_binary_format/zebin_decoder.cpp
@@ -203,8 +203,12 @@ bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Ty
        out = ArgTypeT::ArgTypeLocalId;
    } else if (tokenValue == PayloadArgument::ArgType::localSize) {
        out = ArgTypeT::ArgTypeLocalSize;
-    } else if (tokenValue == PayloadArgument::ArgType::groupSize) {
-        out = ArgTypeT::ArgTypeGroupSize;
+    } else if (tokenValue == PayloadArgument::ArgType::groupCount) {
+        out = ArgTypeT::ArgTypeGroupCount;
+    } else if (tokenValue == PayloadArgument::ArgType::globalSize) {
+        out = ArgTypeT::ArgTypeGlobalSize;
+    } else if (tokenValue == PayloadArgument::ArgType::enqueuedLocalSize) {
+        out = ArgTypeT::ArgTypeEnqueuedLocalSize;
    } else if (tokenValue == PayloadArgument::ArgType::globalIdOffset) {
        out = ArgTypeT::ArgTypeGlobalIdOffset;
    } else if (tokenValue == PayloadArgument::ArgType::privateBaseStateless) {
@@ -569,13 +573,28 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
        }
        break;
    }
-    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeGroupSize: {
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeGroupCount: {
        using GroupSizeT = uint32_t;
        if (false == setVecArgIndicesBasedOnSize<GroupSizeT>(dst.payloadMappings.dispatchTraits.numWorkGroups, src.size, src.offset)) {
-            {
-                outErrReason.append("DeviceBinaryFormat::Zebin : Invalid size for argument of type " + NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::ArgType::groupSize.str() + " in context of : " + dst.kernelMetadata.kernelName + ". Expected 4 or 8 or 12. Got : " + std::to_string(src.size) + "\n");
-                return DecodeError::InvalidBinary;
-            }
+            outErrReason.append("DeviceBinaryFormat::Zebin : Invalid size for argument of type " + NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::ArgType::groupCount.str() + " in context of : " + dst.kernelMetadata.kernelName + ". Expected 4 or 8 or 12. Got : " + std::to_string(src.size) + "\n");
+            return DecodeError::InvalidBinary;
+        }
+        break;
+    }
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeGlobalSize: {
+        using GroupSizeT = uint32_t;
+        if (false == setVecArgIndicesBasedOnSize<GroupSizeT>(dst.payloadMappings.dispatchTraits.globalWorkSize, src.size, src.offset)) {
+            outErrReason.append("DeviceBinaryFormat::Zebin : Invalid size for argument of type " + NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::ArgType::globalSize.str() + " in context of : " + dst.kernelMetadata.kernelName + ". Expected 4 or 8 or 12. Got : " + std::to_string(src.size) + "\n");
+            return DecodeError::InvalidBinary;
+        }
+        break;
+    }
+
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeEnqueuedLocalSize: {
+        using GroupSizeT = uint32_t;
+        if (false == setVecArgIndicesBasedOnSize<GroupSizeT>(dst.payloadMappings.dispatchTraits.enqueuedLocalWorkSize, src.size, src.offset)) {
+            outErrReason.append("DeviceBinaryFormat::Zebin : Invalid size for argument of type " + NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::ArgType::enqueuedLocalSize.str() + " in context of : " + dst.kernelMetadata.kernelName + ". Expected 4 or 8 or 12. Got : " + std::to_string(src.size) + "\n");
+            return DecodeError::InvalidBinary;
        }
        break;
    }
--- a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
+++ b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
@@ -509,15 +509,17 @@ TEST(ReadEnumCheckedArgType, GivenValidStringRepresentationThenParseItCorrectly)
    NEO::Yaml::Token tokPackedLocalIds(packedLocalIds, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokLocalId(localId, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokLocalSize(localSize, NEO::Yaml::Token::Token::LiteralString);
-    NEO::Yaml::Token tokGroupSize(groupSize, NEO::Yaml::Token::Token::LiteralString);
+    NEO::Yaml::Token tokGroupCount(groupCount, NEO::Yaml::Token::Token::LiteralString);
+    NEO::Yaml::Token tokGlobalSize(globalSize, NEO::Yaml::Token::Token::LiteralString);
+    NEO::Yaml::Token tokEnqueuedLocalSize(enqueuedLocalSize, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokGlobalIdOffset(globalIdOffset, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokPrivateBaseStateless(privateBaseStateless, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokArgByValue(argByvalue, NEO::Yaml::Token::Token::LiteralString);
    NEO::Yaml::Token tokArgByPointer(argBypointer, NEO::Yaml::Token::Token::LiteralString);

    using ArgType = NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgType;
-    ArgType enumPackedLocalIds, enumLocalId, enumLocalSize, enumGroupSize, enumGlobalIdOffset,
-        enumPrivateBaseStateless, enumArgByValue, enumArgByPointer;
+    ArgType enumPackedLocalIds, enumLocalId, enumLocalSize, enumGroupCount, enumGlobalSize,
+        enumEnqueuedLocalSize, enumGlobalIdOffset, enumPrivateBaseStateless, enumArgByValue, enumArgByPointer;
    std::string errors;
    bool success;

@@ -536,10 +538,20 @@ TEST(ReadEnumCheckedArgType, GivenValidStringRepresentationThenParseItCorrectly)
    EXPECT_TRUE(errors.empty()) << errors;
    EXPECT_EQ(ArgType::ArgTypeLocalSize, enumLocalSize);

-    success = NEO::readEnumChecked(&tokGroupSize, enumGroupSize, "some_kernel", errors);
+    success = NEO::readEnumChecked(&tokGroupCount, enumGroupCount, "some_kernel", errors);
    EXPECT_TRUE(success);
    EXPECT_TRUE(errors.empty()) << errors;
-    EXPECT_EQ(ArgType::ArgTypeGroupSize, enumGroupSize);
+    EXPECT_EQ(ArgType::ArgTypeGroupCount, enumGroupCount);
+
+    success = NEO::readEnumChecked(&tokGlobalSize, enumGlobalSize, "some_kernel", errors);
+    EXPECT_TRUE(success);
+    EXPECT_TRUE(errors.empty()) << errors;
+    EXPECT_EQ(ArgType::ArgTypeGlobalSize, enumGlobalSize);
+
+    success = NEO::readEnumChecked(&tokEnqueuedLocalSize, enumEnqueuedLocalSize, "some_kernel", errors);
+    EXPECT_TRUE(success);
+    EXPECT_TRUE(errors.empty()) << errors;
+    EXPECT_EQ(ArgType::ArgTypeEnqueuedLocalSize, enumEnqueuedLocalSize);

    success = NEO::readEnumChecked(&tokGlobalIdOffset, enumGlobalIdOffset, "some_kernel", errors);
    EXPECT_TRUE(success);
@@ -2468,14 +2480,14 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGlobaIdOffsetWhenArgSi
    }
 }

-TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupSizeWhenArgSizeIsInvalidThenFails) {
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupCountWhenArgSizeIsInvalidThenFails) {
    NEO::ConstStringRef zeinfo = R"===(
        kernels:
            - name : some_kernel
              execution_env:   
                simd_size: 32
              payload_arguments: 
-                - arg_type : group_size
+                - arg_type : group_count
                  offset : 16
                  size : 7
 )===";
@@ -2497,11 +2509,11 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupSizeWhenArgSizeIs
    auto &kernelNode = *parser.createChildrenRange(*parser.findNodeWithKeyDfs("kernels")).begin();
    auto err = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
    EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
-    EXPECT_STREQ("DeviceBinaryFormat::Zebin : Invalid size for argument of type group_size in context of : some_kernel. Expected 4 or 8 or 12. Got : 7\n", errors.c_str());
+    EXPECT_STREQ("DeviceBinaryFormat::Zebin : Invalid size for argument of type group_count in context of : some_kernel. Expected 4 or 8 or 12. Got : 7\n", errors.c_str());
    EXPECT_TRUE(warnings.empty()) << warnings;
 }

-TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupSizeWhenArgSizeValidThenPopulatesKernelDescriptor) {
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupCountWhenArgSizeValidThenPopulatesKernelDescriptor) {
    uint32_t vectorSizes[] = {4, 8, 12};

    for (auto vectorSize : vectorSizes) {
@@ -2511,7 +2523,7 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupSizeWhenArgSizeVa
              execution_env:   
                simd_size: 32
              payload_arguments: 
-                - arg_type : group_size
+                - arg_type : group_count
                  offset : 16
                  size : )===" +
                             std::to_string(vectorSize) + R"===(
@@ -2544,3 +2556,157 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGroupSizeWhenArgSizeVa
        }
    }
 }
+
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeEnqueuedLocalSizeWhenArgSizeIsInvalidThenFails) {
+    NEO::ConstStringRef zeinfo = R"===(
+        kernels:
+            - name : some_kernel
+              execution_env:   
+                simd_size: 32
+              payload_arguments: 
+                - arg_type : enqueued_local_size
+                  offset : 16
+                  size : 7
+)===";
+    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::InvalidBinary, err);
+    EXPECT_STREQ("DeviceBinaryFormat::Zebin : Invalid size for argument of type enqueued_local_size in context of : some_kernel. Expected 4 or 8 or 12. Got : 7\n", errors.c_str());
+    EXPECT_TRUE(warnings.empty()) << warnings;
+}
+
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeEnqueuedLocalSizeWhenArgSizeValidThenPopulatesKernelDescriptor) {
+    uint32_t vectorSizes[] = {4, 8, 12};
+
+    for (auto vectorSize : vectorSizes) {
+        std::string zeinfo = R"===(
+        kernels:
+            - name : some_kernel
+              execution_env:   
+                simd_size: 32
+              payload_arguments: 
+                - arg_type : enqueued_local_size
+                  offset : 16
+                  size : )===" +
+                             std::to_string(vectorSize) + R"===(
+        )===";
+        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());
+        for (uint32_t i = 0; i < vectorSize / sizeof(uint32_t); ++i) {
+            EXPECT_EQ(16 + sizeof(uint32_t) * i, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[i])
+                << " vectorSize : " << vectorSize << ", idx : " << i;
+        }
+    }
+}
+
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGlobalSizeWhenArgSizeIsInvalidThenFails) {
+    NEO::ConstStringRef zeinfo = R"===(
+        kernels:
+            - name : some_kernel
+              execution_env:   
+                simd_size: 32
+              payload_arguments: 
+                - arg_type : global_size
+                  offset : 16
+                  size : 7
+)===";
+    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::InvalidBinary, err);
+    EXPECT_STREQ("DeviceBinaryFormat::Zebin : Invalid size for argument of type global_size in context of : some_kernel. Expected 4 or 8 or 12. Got : 7\n", errors.c_str());
+    EXPECT_TRUE(warnings.empty()) << warnings;
+}
+
+TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeGlobalSizeWhenArgSizeValidThenPopulatesKernelDescriptor) {
+    uint32_t vectorSizes[] = {4, 8, 12};
+
+    for (auto vectorSize : vectorSizes) {
+        std::string zeinfo = R"===(
+        kernels:
+            - name : some_kernel
+              execution_env:   
+                simd_size: 32
+              payload_arguments: 
+                - arg_type : global_size
+                  offset : 16
+                  size : )===" +
+                             std::to_string(vectorSize) + R"===(
+        )===";
+        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());
+        for (uint32_t i = 0; i < vectorSize / sizeof(uint32_t); ++i) {
+            EXPECT_EQ(16 + sizeof(uint32_t) * i, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.dispatchTraits.globalWorkSize[i])
+                << " vectorSize : " << vectorSize << ", idx : " << i;
+        }
+    }
+}