Reland ZEBIN: Add per-function zeinfo with name and execution env.

Provide the barrier count information and other required fields in
execution env for each external function in .ze_info section.

Author: petechou

IGC/AdaptorOCL/OCL/sp/zebin_builder.cpp

@@ -85,6 +85,7 @@ void ZEBinaryBuilder::createKernel(
     addPayloadArgsAndBTI(annotations, zeKernel);
     addMemoryBuffer(annotations, zeKernel);
     addGTPinInfo(annotations);
+    addFunctionAttrs(annotations);
     if (!visaasm.empty())
         addKernelVISAAsm(annotations.m_kernelName, visaasm);
     if (isProgramDebuggable)
@@ -123,6 +124,29 @@ void ZEBinaryBuilder::addGTPinInfo(const IGC::SOpenCLKernelInfo& annotations)
     }
 }
 
+void ZEBinaryBuilder::addFunctionAttrs(const IGC::SOpenCLKernelInfo& annotations)
+{
+    // get function attribute list from the current process SKernelProgram
+    auto funcAttrs = [](int simdSize, const IGC::SKernelProgram& program) {
+        if (simdSize == 8)
+            return program.simd8.m_funcAttrs;
+        else if (simdSize == 16)
+            return program.simd16.m_funcAttrs;
+        else if (simdSize == 32)
+            return program.simd32.m_funcAttrs;
+        else
+            return program.simd1.m_funcAttrs;
+    } (annotations.m_executionEnivronment.CompiledSIMDSize,
+       annotations.m_kernelProgram);
+
+    for (auto& funcAttr : funcAttrs) {
+        if (!funcAttr.f_isKernel && funcAttr.f_isExternal) {
+            zeInfoFunction& zeFunction = mZEInfoBuilder.createFunction(funcAttr.f_name);
+            addFunctionExecEnv(annotations, funcAttr, zeFunction);
+        }
+    }
+}
+
 void ZEBinaryBuilder::addProgramScopeInfo(const IGC::SOpenCLProgramInfo& programInfo)
 {
     addGlobalConstants(programInfo);
@@ -493,6 +517,18 @@ void ZEBinaryBuilder::addKernelExecEnv(const SOpenCLKernelInfo& annotations,
     }
 }
 
+void ZEBinaryBuilder::addFunctionExecEnv(const SOpenCLKernelInfo& annotations,
+    const vISA::ZEFuncAttribEntry& zeFuncAttr,
+    zeInfoFunction& zeFunction)
+{
+    // TODO: Currently we only set barrier count and other required information
+    // such as GRF count and SIMD size in per-function execution environment.
+    zeInfoExecutionEnv& env = zeFunction.execution_env;
+    env.grf_count = annotations.m_executionEnivronment.NumGRFRequired;
+    env.simd_size = annotations.m_executionEnivronment.CompiledSIMDSize;
+    env.barrier_count = zeFuncAttr.f_BarrierCount;
+}
+
 void ZEBinaryBuilder::addLocalIds(uint32_t simdSize, uint32_t grfSize,
     bool has_local_id_x, bool has_local_id_y, bool has_local_id_z,
     zebin::zeInfoKernel& zeinfoKernel)

IGC/AdaptorOCL/OCL/sp/zebin_builder.hpp

@@ -25,6 +25,7 @@ namespace IGC
 namespace vISA
 {
     struct ZESymEntry;
+    struct ZEFuncAttribEntry;
 }
 
 namespace iOpenCL
@@ -110,10 +111,15 @@ class ZEBinaryBuilder : DisallowCopy
         const std::string& kernelName, const char* kernelBinary,
         unsigned int kernelBinarySize);
 
-    /// add execution environment
+    /// add kernel execution environment
     void addKernelExecEnv(const IGC::SOpenCLKernelInfo& annotations,
                           zebin::zeInfoKernel& zeinfoKernel);
 
+    /// add execution environment for external function
+    void addFunctionExecEnv(const IGC::SOpenCLKernelInfo& annotations,
+                            const vISA::ZEFuncAttribEntry& zeFuncAttr,
+                            zebin::zeInfoFunction& zeFunction);
+
     /// add experimental properties
     void addKernelExperimentalProperties(const IGC::SOpenCLKernelInfo& annotations,
         zebin::zeInfoKernel& zeinfoKernel);
@@ -160,6 +166,9 @@ class ZEBinaryBuilder : DisallowCopy
     /// into gtpin_info section
     void addGTPinInfo(const IGC::SOpenCLKernelInfo& annotations);
 
+    /// Add function attributes for external functions.
+    void addFunctionAttrs(const IGC::SOpenCLKernelInfo& annotations);
+
     /// ------------ Verifier sub-functions ------------
     bool hasSystemKernel(
         const IGC::OpenCLProgramContext* clContext,

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -5629,7 +5629,10 @@ namespace IGC
             visaFunc->GetJitInfo(jitInfo);
             entry.f_spillMemPerThread = jitInfo->spillMemUsed;
 
-            attrs.emplace_back(entry.f_isKernel, entry.f_hasBarrier, entry.f_privateMemPerThread,
+            uint8_t isExternal = F->hasFnAttribute("referenced-indirectly") ? 1 : 0;
+            // Set per-function barrier count from vISA information.
+            uint32_t barrierCnt = jitInfo->usesBarrier;
+            attrs.emplace_back(entry.f_isKernel, isExternal, barrierCnt, entry.f_privateMemPerThread,
                 entry.f_spillMemPerThread, F->getName().str());
             attribTable.push_back(entry);
         }
@@ -6230,7 +6233,7 @@ namespace IGC
                 pOutput->m_funcRelocationTableEntries);
         }
 
-        if (IGC_IS_FLAG_ENABLED(EnableRuntimeFuncAttributePatching))
+        if (IGC_IS_FLAG_ENABLED(EnableRuntimeFuncAttributePatching) || ZEBinEnabled)
         {
             CreateFuncAttributeTable(pOutput->m_funcAttributeTable,
                 pOutput->m_funcAttributeTableSize,

IGC/ZEBinWriter/zebin/source/ZEELFObjectBuilder.cpp

@@ -942,6 +942,15 @@ zeInfoKernel& ZEInfoBuilder::createKernel(const std::string& name)
     return k;
 }
 
+// createFunction - create a zeInfoFunction and add it into zeInfoContainer
+zeInfoFunction& ZEInfoBuilder::createFunction(const std::string& name)
+{
+    mContainer.functions.emplace_back();
+    zeInfoFunction& f = mContainer.functions.back();
+    f.name = name;
+    return f;
+}
+
 bool ZEInfoBuilder::empty() const
 {
     return mContainer.kernels.empty();

IGC/ZEBinWriter/zebin/source/ZEELFObjectBuilder.hpp

@@ -395,6 +395,9 @@ class ZEInfoBuilder {
     // createKernel - create a zeInfoKernel and add it into zeInfoContainer
     zeInfoKernel& createKernel(const std::string& name);
 
+    // createFunction - create a zeInfoFunction and add it into zeInfoContainer
+    zeInfoFunction& createFunction(const std::string& name);
+
     // addGlobalHostAccessSymbol - create a zeInfo global_host_access_table section
     // which is used by Runtime to identify a global variable based on host name
     void addGlobalHostAccessSymbol(const std::string& device_name, const std::string& host_name);

IGC/ZEBinWriter/zebin/source/autogen/ZEInfo.hpp

@@ -138,6 +138,10 @@ typedef std::vector<zeInfoBindingTableIndex> BindingTableIndicesTy;
 typedef std::vector<zeInfoPerThreadMemoryBuffer> PerThreadMemoryBuffersTy;
 struct zeInfoKernel
 {
+    bool operator==(const zeInfoKernel& other) const
+    {
+        return name == other.name && execution_env == other.execution_env && payload_arguments == other.payload_arguments && per_thread_payload_arguments == other.per_thread_payload_arguments && binding_table_indices == other.binding_table_indices && per_thread_memory_buffers == other.per_thread_memory_buffers && experimental_properties == other.experimental_properties && debug_env == other.debug_env;
+    }
     zeinfo_str_t name;
     zeInfoExecutionEnv execution_env;
     PayloadArgumentsTy payload_arguments;
@@ -147,16 +151,31 @@ struct zeInfoKernel
     zeInfoExperimentalProperties experimental_properties;
     zeInfoDebugEnv debug_env;
 };
+struct zeInfoFunction
+{
+    bool operator==(const zeInfoFunction& other) const
+    {
+        return name == other.name && execution_env == other.execution_env;
+    }
+    zeinfo_str_t name;
+    zeInfoExecutionEnv execution_env;
+};
 typedef std::vector<zeInfoKernel> KernelsTy;
+typedef std::vector<zeInfoFunction> FunctionsTy;
 typedef std::vector<zeInfoHostAccess> HostAccessesTy;
 struct zeInfoContainer
 {
+    bool operator==(const zeInfoContainer& other) const
+    {
+        return version == other.version && kernels == other.kernels && functions == other.functions && global_host_access_table == other.global_host_access_table;
+    }
     zeinfo_str_t version;
     KernelsTy kernels;
+    FunctionsTy functions;
     HostAccessesTy global_host_access_table;
 };
 struct PreDefinedAttrGetter{
-    static zeinfo_str_t getVersionNumber() { return "1.12"; }
+    static zeinfo_str_t getVersionNumber() { return "1.13"; }
 
     enum class ArgThreadSchedulingMode {
         age_based,

IGC/ZEBinWriter/zebin/source/autogen/ZEInfoYAML.cpp

@@ -23,6 +23,7 @@ void MappingTraits<zeInfoContainer>::mapping(IO& io, zeInfoContainer& info)
 {
     io.mapRequired("version", info.version);
     io.mapRequired("kernels", info.kernels);
+    io.mapOptional("functions", info.functions, FunctionsTy());
     io.mapOptional("global_host_access_table", info.global_host_access_table, HostAccessesTy());
 }
 void MappingTraits<zeInfoKernel>::mapping(IO& io, zeInfoKernel& info)
@@ -36,6 +37,11 @@ void MappingTraits<zeInfoKernel>::mapping(IO& io, zeInfoKernel& info)
     io.mapOptional("experimental_properties", info.experimental_properties, zeInfoExperimentalProperties());
     io.mapOptional("debug_env", info.debug_env, zeInfoDebugEnv());
 }
+void MappingTraits<zeInfoFunction>::mapping(IO& io, zeInfoFunction& info)
+{
+    io.mapRequired("name", info.name);
+    io.mapRequired("execution_env", info.execution_env);
+}
 void MappingTraits<zeInfoExecutionEnv>::mapping(IO& io, zeInfoExecutionEnv& info)
 {
     io.mapOptional("barrier_count", info.barrier_count, 0);

IGC/ZEBinWriter/zebin/source/autogen/ZEInfoYAML.hpp

@@ -30,6 +30,7 @@ SPDX-License-Identifier: MIT
 #include "common/LLVMWarningsPop.hpp"
 #endif
 LLVM_YAML_IS_SEQUENCE_VECTOR(zebin::zeInfoKernel)
+LLVM_YAML_IS_SEQUENCE_VECTOR(zebin::zeInfoFunction)
 LLVM_YAML_IS_SEQUENCE_VECTOR(zebin::zeInfoPayloadArgument)
 LLVM_YAML_IS_SEQUENCE_VECTOR(zebin::zeInfoPerThreadPayloadArgument)
 LLVM_YAML_IS_SEQUENCE_VECTOR(zebin::zeInfoBindingTableIndex)
@@ -46,6 +47,10 @@ namespace llvm {
             static void mapping(IO& io, zebin::zeInfoKernel& info);
         };
         template<>
+        struct MappingTraits<zebin::zeInfoFunction> {
+            static void mapping(IO& io, zebin::zeInfoFunction& info);
+        };
+        template<>
         struct MappingTraits<zebin::zeInfoExecutionEnv> {
             static void mapping(IO& io, zebin::zeInfoExecutionEnv& info);
         };

IGC/ZEBinWriter/zebin/spec/zeinfo.md

@@ -7,7 +7,7 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ==========================-->
 
 # ZE Info
-Version 1.12
+Version 1.13
 
 ## Grammar
 
@@ -35,6 +35,7 @@ All **literals** have one of the following types:
 | ----- | ----- | ----- | ----- |
 | version | str | Required | ZE Info version number. See Version above. |
 | kernels | KernelsTy | Required | vector |
+| functions | FunctionsTy | Optional | vector |
 | global_host_access_table | HostAccessesTy | Optional | vector |
 <!--- Container --->
 
@@ -66,15 +67,20 @@ functions:
     attribute_seq
 ~~~
 
+| Attribute | Type | Required/Optional | Description |
+| ----- | ----- | ------ | ----- |
+| name | str | Required | |
+| execution_env | ExecutionEnv | Required | |
+<!--- Function Functions --->
+
 Function attribute represents a non-kernel function's information. A ze_info
 section may contains more than one function's attributes, each is
 represented in a function attribute. The name attribute in function represent the
-kernel's name.
+function name.
 
-Function attributes may only present when the function can be externally or
-indirectly called.
+Function attributes may only present when the function can be externally called.
 
-The attributes that are supported in function are: **name** and **Memory Buffer**.
+The attributes that are supported in function are: **name** and **Execution Environment**.
 
 ## Execution Environment
 
@@ -293,6 +299,7 @@ Format: \<_Major number_\>.\<_Minor number_\>
 - Minor number: Increase when backward-compatible features are added. For example, add new attributes.
 
 ## Change Note
+- **Version 1.13**: Add functions with the name and execution env.
 - **Version 1.12**: Add global_host_access_table to container.
 - **Version 1.11**: Add require_disable_eufusion attribute.
 - **Version 1.10**: Add thread_scheduling_mode to execution_env.

visa/include/RelocationInfo.h

@@ -109,15 +109,17 @@ struct ZERelocEntry {
 /// ZEFuncAttribEntry - A function attribute entry that will later be transformed to ZE binary format
 struct ZEFuncAttribEntry {
     uint8_t     f_isKernel;      // Is the function a kernel
-    uint8_t     f_hasBarrier;    // Does the function use barriers
+    uint8_t     f_isExternal;    // Is the function external
+    uint32_t    f_BarrierCount;  // Number of barriers used by the function
     uint32_t    f_privateMemPerThread; // Total private memory (in bytes) used by this function per thread
     uint32_t    f_spillMemPerThread;  // Spill mem used (in bytes) in scratch space for this function
     std::string f_name; // The function's name
 
-    ZEFuncAttribEntry(uint8_t isKernel, uint8_t hasBarrier, uint32_t privateMemPerThread,
-        uint32_t spillMemPerThread, std::string funcName)
+    ZEFuncAttribEntry(uint8_t isKernel, uint8_t isExternal, uint32_t barrierCount,
+        uint32_t privateMemPerThread, uint32_t spillMemPerThread, std::string funcName)
         : f_isKernel(isKernel),
-          f_hasBarrier(hasBarrier),
+          f_isExternal(isExternal),
+          f_BarrierCount(barrierCount),
           f_privateMemPerThread(privateMemPerThread),
           f_spillMemPerThread(spillMemPerThread),
           f_name(funcName)