Zebin per_thread_memory_buffers

jchodor · Compute-Runtime-Automation · commit 36d350c8fcaa · 2020-08-31T15:09:49.000+02:00
Change-Id: I66074ac9f1d5b1417dfad5c044149e86ab9aad1d
diff --git a/shared/source/device_binary_format/elf/zebin_elf.h b/shared/source/device_binary_format/elf/zebin_elf.h
@@ -89,6 +89,7 @@ static constexpr ConstStringRef executionEnv("execution_env");
 static constexpr ConstStringRef payloadArguments("payload_arguments");
 static constexpr ConstStringRef bindingTableIndices("binding_table_indices");
 static constexpr ConstStringRef perThreadPayloadArguments("per_thread_payload_arguments");
+static constexpr ConstStringRef perThreadMemoryBuffers("per_thread_memory_buffers");
 
 namespace ExecutionEnv {
 static constexpr ConstStringRef actualKernelStartOffset("actual_kernel_start_offset");
@@ -164,6 +165,22 @@ static constexpr ConstStringRef packedLocalIds("packed_local_ids");
 static constexpr ConstStringRef localId("local_id");
 } // namespace ArgType
 } // namespace PerThreadPayloadArgument
+
+namespace PerThreadMemoryBuffer {
+static constexpr ConstStringRef allocationType("type");
+static constexpr ConstStringRef memoryUsage("usage");
+static constexpr ConstStringRef size("size");
+namespace AllocationType {
+static constexpr ConstStringRef global("global");
+static constexpr ConstStringRef scratch("scratch");
+static constexpr ConstStringRef slm("slm");
+} // namespace AllocationType
+namespace MemoryUsage {
+static constexpr ConstStringRef privateSpace("private_space");
+static constexpr ConstStringRef spillFillSpace("spill_fill_space");
+static constexpr ConstStringRef singleSpace("single_space");
+} // namespace MemoryUsage
+} // namespace PerThreadMemoryBuffer
 } // namespace Kernel
 } // namespace Tags
 
@@ -329,6 +346,32 @@ struct BindingTableEntryBaseT {
 };
 } // namespace BindingTableEntry
 
+namespace PerThreadMemoryBuffer {
+enum AllocationType : uint8_t {
+    AllocationTypeUnknown = 0,
+    AllocationTypeGlobal,
+    AllocationTypeScratch,
+    AllocationTypeSlm
+};
+
+enum MemoryUsage : uint8_t {
+    MemoryUsageUnknown = 0,
+    MemoryUsagePrivateSpace,
+    MemoryUsageSpillFillSpace,
+    MemoryUsageSingleSpace
+};
+
+using SizeT = int32_t;
+using AllocationTypeT = AllocationType;
+using MemoryUsageT = MemoryUsage;
+
+struct PerThreadMemoryBufferBaseT {
+    AllocationType allocationType = AllocationTypeUnknown;
+    MemoryUsageT memoryUsage = MemoryUsageUnknown;
+    SizeT size = 0U;
+};
+} // namespace PerThreadMemoryBuffer
+
 } // namespace Kernel
 
 } // namespace Types
diff --git a/shared/source/device_binary_format/zebin_decoder.cpp b/shared/source/device_binary_format/zebin_decoder.cpp
@@ -116,6 +116,8 @@ void extractZeInfoKernelSections(const NEO::Yaml::YamlParser &parser, const NEO:
             outZeInfoKernelSections.perThreadPayloadArgumentsNd.push_back(&kernelMetadataNd);
         } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::bindingTableIndices == key) {
             outZeInfoKernelSections.bindingTableIndicesNd.push_back(&kernelMetadataNd);
+        } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::perThreadMemoryBuffers == key) {
+            outZeInfoKernelSections.perThreadMemoryBuffersNd.push_back(&kernelMetadataNd);
         } else {
             outWarning.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unknown entry \"" + parser.readKey(kernelMetadataNd).str() + "\" in context of : " + context.str() + "\n");
         }
@@ -128,6 +130,7 @@ DecodeError validateZeInfoKernelSectionsCount(const ZeInfoKernelSections &outZeI
     valid &= validateZebinSectionsCountAtMost(outZeInfoKernelSections.payloadArgumentsNd, NEO::Elf::ZebinKernelMetadata::Tags::Kernel::payloadArguments, 1U, outErrReason, outWarning);
     valid &= validateZebinSectionsCountAtMost(outZeInfoKernelSections.perThreadPayloadArgumentsNd, NEO::Elf::ZebinKernelMetadata::Tags::Kernel::perThreadPayloadArguments, 1U, outErrReason, outWarning);
     valid &= validateZebinSectionsCountAtMost(outZeInfoKernelSections.bindingTableIndicesNd, NEO::Elf::ZebinKernelMetadata::Tags::Kernel::bindingTableIndices, 1U, outErrReason, outWarning);
+    valid &= validateZebinSectionsCountAtMost(outZeInfoKernelSections.perThreadMemoryBuffersNd, NEO::Elf::ZebinKernelMetadata::Tags::Kernel::perThreadMemoryBuffers, 1U, outErrReason, outWarning);
 
     return valid ? DecodeError::Success : DecodeError::InvalidBinary;
 }
@@ -306,6 +309,54 @@ bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Ty
     return true;
 }
 
+bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::AllocationType &out,
+                     ConstStringRef context, std::string &outErrReason) {
+    if (nullptr == token) {
+        return false;
+    }
+
+    using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::AllocationType;
+    using AllocType = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::AllocationType;
+    auto tokenValue = token->cstrref();
+
+    if (global == tokenValue) {
+        out = AllocType::AllocationTypeGlobal;
+    } else if (scratch == tokenValue) {
+        out = AllocType::AllocationTypeScratch;
+    } else if (slm == tokenValue) {
+        out = AllocType::AllocationTypeSlm;
+    } else {
+        outErrReason.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unhandled \"" + tokenValue.str() + "\" per-thread memory buffer allocation type in context of " + context.str() + "\n");
+        return false;
+    }
+
+    return true;
+}
+
+bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::MemoryUsage &out,
+                     ConstStringRef context, std::string &outErrReason) {
+    if (nullptr == token) {
+        return false;
+    }
+
+    using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::MemoryUsage;
+    using Usage = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::MemoryUsage;
+    auto tokenValue = token->cstrref();
+
+    if (privateSpace == tokenValue) {
+        out = Usage::MemoryUsagePrivateSpace;
+    } else if (spillFillSpace == tokenValue) {
+        out = Usage::MemoryUsageSpillFillSpace;
+    } else if (singleSpace == tokenValue) {
+        out = Usage::MemoryUsageSingleSpace;
+    } else {
+        outErrReason.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unhandled \"" + tokenValue.str() + "\" per-thread memory buffer usage type in context of " + context.str() + "\n");
+        return false;
+    }
+
+    return true;
+}
+
 DecodeError readZeInfoPerThreadPayloadArguments(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
                                                 ZeInfoPerThreadPayloadArguments &outPerThreadPayloadArguments,
                                                 ConstStringRef context,
@@ -401,6 +452,32 @@ DecodeError readZeInfoBindingTableIndices(const NEO::Yaml::YamlParser &parser, c
     return validBindingTableEntries ? DecodeError::Success : DecodeError::InvalidBinary;
 }
 
+DecodeError readZeInfoPerThreadMemoryBuffers(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
+                                             ZeInfoPerThreadMemoryBuffers &outPerThreadMemoryBuffers,
+                                             ConstStringRef context,
+                                             std::string &outErrReason, std::string &outWarning) {
+    bool validBuffer = true;
+    for (const auto &perThreadMemoryBufferNd : parser.createChildrenRange(node)) {
+        outPerThreadMemoryBuffers.resize(outPerThreadMemoryBuffers.size() + 1);
+        auto &perThreadMemoryBufferMetadata = *outPerThreadMemoryBuffers.rbegin();
+        for (const auto &perThreadMemoryBufferMemberNd : parser.createChildrenRange(perThreadMemoryBufferNd)) {
+            auto key = parser.readKey(perThreadMemoryBufferMemberNd);
+            if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::allocationType == key) {
+                auto allocationTypeToken = parser.getValueToken(perThreadMemoryBufferMemberNd);
+                validBuffer &= readEnumChecked(allocationTypeToken, perThreadMemoryBufferMetadata.allocationType, context, outErrReason);
+            } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::memoryUsage == key) {
+                auto memoryUsageToken = parser.getValueToken(perThreadMemoryBufferMemberNd);
+                validBuffer &= readEnumChecked(memoryUsageToken, perThreadMemoryBufferMetadata.memoryUsage, context, outErrReason);
+            } else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::size == key) {
+                validBuffer &= readZeInfoValueChecked(parser, perThreadMemoryBufferMemberNd, perThreadMemoryBufferMetadata.size, context, outErrReason);
+            } else {
+                outWarning.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unknown entry \"" + key.str() + "\" for per-thread memory buffer in context of " + context.str() + "\n");
+            }
+        }
+    }
+    return validBuffer ? DecodeError::Success : DecodeError::InvalidBinary;
+}
+
 template <typename ElSize, size_t Len>
 bool setVecArgIndicesBasedOnSize(CrossThreadDataOffset (&vec)[Len], size_t vecSize, CrossThreadDataOffset baseOffset) {
     switch (vecSize) {
@@ -423,7 +500,7 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
                                        std::string &outErrReason, std::string &outWarning) {
     switch (src.argType) {
     default:
-        outErrReason.append("DeviceBinaryFormat::Zebin : Invalid arg type in per thread data section in context of : " + dst.kernelMetadata.kernelName + ".\n");
+        outErrReason.append("DeviceBinaryFormat::Zebin : Invalid arg type in per-thread data section in context of : " + dst.kernelMetadata.kernelName + ".\n");
         return DecodeError::InvalidBinary;
     case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeLocalId: {
         if (src.offset != 0) {
@@ -603,6 +680,34 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
     return DecodeError::Success;
 }
 
+NEO::DecodeError populateKernelDescriptor(const NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::PerThreadMemoryBufferBaseT &src, NEO::KernelDescriptor &dst,
+                                          std::string &outErrReason, std::string &outWarning) {
+    using namespace NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer;
+    using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::AllocationType;
+    using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::MemoryUsage;
+    switch (src.allocationType) {
+    default:
+        outErrReason.append("DeviceBinaryFormat::Zebin : Invalid per-thread memory buffer allocation type in context of : " + dst.kernelMetadata.kernelName + ".\n");
+        return DecodeError::InvalidBinary;
+    case AllocationTypeGlobal:
+        if (MemoryUsagePrivateSpace != src.memoryUsage) {
+            outErrReason.append("DeviceBinaryFormat::Zebin : Invalid per-thread memory buffer memory usage type for " + global.str() + " allocation type in context of : " + dst.kernelMetadata.kernelName + ". Expected : " + privateSpace.str() + ".\n");
+            return DecodeError::InvalidBinary;
+        }
+
+        dst.kernelAttributes.perThreadPrivateMemorySize = src.size;
+        break;
+    case AllocationTypeScratch:
+        if (0 != dst.kernelAttributes.perThreadScratchSize[0]) {
+            outErrReason.append("DeviceBinaryFormat::Zebin : Invalid duplicated scratch buffer entry in context of : " + dst.kernelMetadata.kernelName + ".\n");
+            return DecodeError::InvalidBinary;
+        }
+        dst.kernelAttributes.perThreadScratchSize[0] = src.size;
+        break;
+    }
+    return DecodeError::Success;
+}
+
 NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<NEO::Elf::EI_CLASS_64> &elf, NEO::ZebinSections &zebinSections,
                                           NEO::Yaml::YamlParser &yamlParser, const NEO::Yaml::Node &kernelNd, std::string &outErrReason, std::string &outWarning) {
     auto kernelInfo = std::make_unique<NEO::KernelInfo>();
@@ -642,6 +747,15 @@ NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<N
         }
     }
 
+    ZeInfoPerThreadMemoryBuffers perThreadMemoryBuffers;
+    if (false == zeInfokernelSections.perThreadMemoryBuffersNd.empty()) {
+        auto perThreadMemoryBuffersErr = readZeInfoPerThreadMemoryBuffers(yamlParser, *zeInfokernelSections.perThreadMemoryBuffersNd[0], perThreadMemoryBuffers,
+                                                                          kernelDescriptor.kernelMetadata.kernelName, outErrReason, outWarning);
+        if (DecodeError::Success != perThreadMemoryBuffersErr) {
+            return perThreadMemoryBuffersErr;
+        }
+    }
+
     kernelDescriptor.kernelAttributes.hasBarriers = execEnv.barrierCount;
     kernelDescriptor.kernelAttributes.flags.usesBarriers = (kernelDescriptor.kernelAttributes.hasBarriers > 0U);
     kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = execEnv.disableMidThreadPreemption;
@@ -684,6 +798,13 @@ NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<N
         }
     }
 
+    for (const auto &memBuff : perThreadMemoryBuffers) {
+        auto decodeErr = populateKernelDescriptor(memBuff, kernelDescriptor, outErrReason, outWarning);
+        if (DecodeError::Success != decodeErr) {
+            return decodeErr;
+        }
+    }
+
     if (NEO::DebugManager.flags.ZebinAppendElws.get()) {
         kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[0] = alignDown(crossThreadDataSize + 12, 32);
         kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[1] = kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[0] + 4;
diff --git a/shared/source/device_binary_format/zebin_decoder.h b/shared/source/device_binary_format/zebin_decoder.h
@@ -33,6 +33,7 @@ struct ZeInfoKernelSections {
     UniqueNode payloadArgumentsNd;
     UniqueNode bindingTableIndicesNd;
     UniqueNode perThreadPayloadArgumentsNd;
+    UniqueNode perThreadMemoryBuffersNd;
 };
 
 DecodeError extractZebinSections(NEO::Elf::Elf<Elf::EI_CLASS_64> &elf, ZebinSections &out, std::string &outErrReason, std::string &outWarning);
@@ -50,6 +51,10 @@ bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Ty
                      ConstStringRef context, std::string &outErrReason);
 bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::AccessType &out,
                      ConstStringRef context, std::string &outErrReason);
+bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::AllocationType &out,
+                     ConstStringRef context, std::string &outErrReason);
+bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::MemoryUsage &out,
+                     ConstStringRef context, std::string &outErrReason);
 
 using ZeInfoPerThreadPayloadArguments = StackVec<NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadPayloadArgument::PerThreadPayloadArgumentBaseT, 2>;
 DecodeError readZeInfoPerThreadPayloadArguments(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
@@ -70,6 +75,12 @@ DecodeError readZeInfoBindingTableIndices(const NEO::Yaml::YamlParser &parser, c
                                           ConstStringRef context,
                                           std::string &outErrReason, std::string &outWarning);
 
+using ZeInfoPerThreadMemoryBuffers = StackVec<NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::PerThreadMemoryBufferBaseT, 8>;
+DecodeError readZeInfoPerThreadMemoryBuffers(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
+                                             ZeInfoPerThreadMemoryBuffers &outPerThreadMemoryBuffers,
+                                             ConstStringRef context,
+                                             std::string &outErrReason, std::string &outWarning);
+
 NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadPayloadArgument::PerThreadPayloadArgumentBaseT &src, NEO::KernelDescriptor &dst,
                                        std::string &outErrReason, std::string &outWarning);
 
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
