Write IGC program output to ZE binary, disable by default

Change-Id: I6a9b6a906a58147787ca77374865368c293e10ad

Author: DianaChen

IGC/AdaptorOCL/CLElfLib/CLElfTypes.h

@@ -38,10 +38,6 @@ Abstract:  Defines the types used for ELF headers/sections.  This uses
     #include <inttypes.h>
 #endif
 
-#if defined(__linux__)
-    #include "elf.h"
-#endif
-
 #include <stddef.h>
 
 namespace CLElfLib

IGC/AdaptorOCL/OCL/KernelAnnotations.hpp

@@ -298,6 +298,13 @@ struct ExecutionEnivronment
     //legacy design:not used
     //new design:   hold private memory used by shader if non-ZERO
     DWORD  PerThreadScratchSpaceSlot1                 = 0;
+    // Size in bytes of the stateless memory requirement for allocating
+    // private variables.
+    // This field is added for zebin
+    // The same information for path token based format is passed in
+    // PrivateMemSizeAnnotation which will point to a PrivateInputAnnotation
+    // that contains the size
+    DWORD  PerThreadPrivateOnStatelessSize            = 0;
     //legacy design:not used
     //new design:   hold private memory used by shader if non-ZERO
     DWORD  SumFixedTGSMSizes                          = 0;

IGC/AdaptorOCL/OCL/sp/sp_g8.h

@@ -79,6 +79,8 @@ class DisallowCopy
     DisallowCopy& operator=(const DisallowCopy&);
 };
 
+/// CGen8OpenCLStateProcessor - Provides services to create (legacy) patch token
+/// based binary from given SProgramOutput information
 class CGen8OpenCLStateProcessor : DisallowCopy
 {
 

IGC/AdaptorOCL/OCL/sp/spp_g8.cpp

@@ -226,6 +226,67 @@ void overrideOCLKernelBinary(
     KernBin->Write(Buf.get(), newBinarySize);
 }
 
+
+void CGen8OpenCLProgram::GetZEBinary(
+    llvm::raw_pwrite_stream& programBinary, unsigned pointerSizeInBytes)
+{
+    auto isValidShader = [&](IGC::COpenCLKernel* shader)->bool
+    {
+        return (shader && shader->ProgramOutput()->m_programSize > 0);
+    };
+
+    ZEBinaryBuilder zebuilder(m_Platform, pointerSizeInBytes, m_pContext->m_programInfo);
+
+    for (auto pKernel : m_ShaderProgramList)
+    {
+        IGC::COpenCLKernel* simd8Shader = static_cast<IGC::COpenCLKernel*>(pKernel->GetShader(SIMDMode::SIMD8));
+        IGC::COpenCLKernel* simd16Shader = static_cast<IGC::COpenCLKernel*>(pKernel->GetShader(SIMDMode::SIMD16));
+        IGC::COpenCLKernel* simd32Shader = static_cast<IGC::COpenCLKernel*>(pKernel->GetShader(SIMDMode::SIMD32));
+
+        // Determine how many simd modes we have per kernel
+        // FIXME: We actually expect only one simd mode per kernel. There should not be multiple SIMD mode available
+        // for one kernel (runtime cannot support that). So these check can be simplified
+        std::vector<IGC::COpenCLKernel*> kernelVec;
+        if (m_pContext->m_DriverInfo.sendMultipleSIMDModes() && (m_pContext->getModuleMetaData()->csInfo.forcedSIMDSize == 0))
+        {
+            // For multiple SIMD modes, send SIMD modes in descending order
+            if (isValidShader(simd32Shader))
+                kernelVec.push_back(simd32Shader);
+            if (isValidShader(simd16Shader))
+                kernelVec.push_back(simd16Shader);
+            if (isValidShader(simd8Shader))
+                kernelVec.push_back(simd8Shader);
+        }
+        else
+        {
+            if (isValidShader(simd32Shader))
+                kernelVec.push_back(simd32Shader);
+            else if (isValidShader(simd16Shader))
+                kernelVec.push_back(simd16Shader);
+            else if (isValidShader(simd8Shader))
+                kernelVec.push_back(simd8Shader);
+        }
+
+        for (auto kernel : kernelVec)
+        {
+            IGC::SProgramOutput* pOutput = kernel->ProgramOutput();
+
+            zebuilder.createKernel(
+                (const char*)pOutput->m_programBin,
+                pOutput->m_programSize,
+                kernel->m_kernelInfo,
+                kernel->getGRFSize());
+
+            // FIXME: Handle IGC_IS_FLAG_ENABLED(ShaderDumpEnable) and
+            // IGC_IS_FLAG_ENABLED(ShaderOverride)
+
+            // ... Create the debug data binary streams
+        }
+    }
+
+    zebuilder.getBinaryObject(programBinary);
+}
+
 void CGen8OpenCLProgram::CreateKernelBinaries()
 {
     auto isValidShader = [&](IGC::COpenCLKernel* shader)->bool

IGC/AdaptorOCL/OCL/sp/spp_g8.h

@@ -33,6 +33,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "../util/BinaryStream.h"
 #include "usc.h"
 #include "sp_g8.h"
+#include "zebin_builder.hpp"
 
 namespace IGC
 {
@@ -64,23 +65,35 @@ class CGen8OpenCLProgramBase : DisallowCopy {
     explicit CGen8OpenCLProgramBase(PLATFORM platform);
     virtual ~CGen8OpenCLProgramBase();
 
+    /// GetProgramBinary - getting legacy (Patch token based) binary format
+    /// Write program header and the already written patch token info
+    /// and kernels' binary to programBinary. Must be called after
+    /// CGen8OpenCLProgram::CreateKernelBinaries or CGen8CMProgram::CreateKernelBinaries
     RETVAL GetProgramBinary(Util::BinaryStream& programBinary,
         unsigned pointerSizeInBytes);
-
+    /// GetProgramDebugData - get debug data binary for legacy (Patch token based)
+    /// binary format
     RETVAL GetProgramDebugData(Util::BinaryStream& programDebugData);
-
+    /// CreateProgramScopePatchStream - get program scope patch token for legacy
+    /// (Patch token based) binary format
     void CreateProgramScopePatchStream(const IGC::SOpenCLProgramInfo& programInfo);
 
-    // Used to store per-kernel binary streams and kernelInfo
+    // For per-kernel binary streams and kernelInfo
     std::vector<KernelData> m_KernelBinaries;
 
     USC::SSystemThreadKernelOutput* m_pSystemThreadKernelOutput = nullptr;
 
     PLATFORM getPlatform() const { return m_Platform; }
 
+public:
+    // GetZEBinary - get ZE binary object
+    virtual void GetZEBinary(Util::BinaryStream& programBinary,
+        unsigned pointerSizeInBytes) {}
+
 protected:
     PLATFORM m_Platform;
     CGen8OpenCLStateProcessor m_StateProcessor;
+    // For serialized patch token information
     Util::BinaryStream* m_ProgramScopePatchStream = nullptr;
 };
 
@@ -91,8 +104,14 @@ class CGen8OpenCLProgram : public CGen8OpenCLProgramBase
 
     ~CGen8OpenCLProgram();
 
+    /// API for getting legacy (Patch token based) binary
+    /// CreateKernelBinaries - write patch token information and gen binary to
+    /// m_ProgramScopePatchStream and m_KernelBinaries
     void CreateKernelBinaries();
 
+    /// getZEBinary - create ZE Binary
+    void GetZEBinary(llvm::raw_pwrite_stream& programBinary, unsigned pointerSizeInBytes);
+
     // Used to track the kernel info from CodeGen
     std::vector<IGC::CShaderProgram*> m_ShaderProgramList;