initial support of L0 binary in cmc

dmitryryintel · sys_zuul · commit 9b8606fbc9ee · 2020-07-14T07:14:54.000-07:00
Change-Id: I7fbdf5b33ae8b51536e12a4305df4bafc7893aa5
diff --git a/IGC/AdaptorOCL/OCL/sp/spp_g8.cpp b/IGC/AdaptorOCL/OCL/sp/spp_g8.cpp
@@ -404,4 +404,20 @@ void CGen8CMProgram::CreateKernelBinaries()
     }
 }
 
+void CGen8CMProgram::GetZEBinary(
+    llvm::raw_pwrite_stream& programBinary, unsigned pointerSizeInBytes)
+{
+    ZEBinaryBuilder zebuilder{m_Platform, pointerSizeInBytes == 8, *m_programInfo};
+
+    for (auto *kernel : m_kernels)
+    {
+        zebuilder.createKernel(
+            reinterpret_cast<const char*>(kernel->m_prog.m_programBin),
+            kernel->m_prog.m_programSize,
+            kernel->m_kernelInfo,
+            kernel->m_GRFSizeInBytes);
+    }
+    zebuilder.getBinaryObject(programBinary);
+}
+
 } // namespace iOpenCL
diff --git a/IGC/AdaptorOCL/OCL/sp/spp_g8.h b/IGC/AdaptorOCL/OCL/sp/spp_g8.h
@@ -127,6 +127,8 @@ class CGen8CMProgram : public CGen8OpenCLProgramBase {
     // Produce the final ELF binary with the given CM kernels
     // in OpenCL format.
     void CreateKernelBinaries();
+    void GetZEBinary(llvm::raw_pwrite_stream& programBinary,
+        unsigned pointerSizeInBytes) override;
 
     // CM kernel list.
     std::vector<cmc::CMKernel*> m_kernels;
diff --git a/IGC/AdaptorOCL/cmc.cpp b/IGC/AdaptorOCL/cmc.cpp
@@ -85,6 +85,38 @@ CMKernel::~CMKernel()
     delete m_btiLayout.getModifiableLayout();
 }
 
+static zebin::PreDefinedAttrGetter::ArgType getZEArgType(iOpenCL::DATA_PARAMETER_TOKEN type) {
+    switch(type) {
+    case iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE:
+        return zebin::PreDefinedAttrGetter::ArgType::local_size;
+    case iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET:
+        return zebin::PreDefinedAttrGetter::ArgType::global_id_offset;
+    case iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS:
+        // copied from OCL behavior
+        return zebin::PreDefinedAttrGetter::ArgType::group_size;
+    default:
+        IGC_ASSERT_MESSAGE(0, "unsupported argument type");
+        return zebin::PreDefinedAttrGetter::ArgType::arg_byvalue;
+    }
+}
+
+static zebin::PreDefinedAttrGetter::ArgAccessType getZEArgAccessType(cmc_access_kind accessKind)
+{
+    switch(accessKind)
+    {
+    case cmc_access_kind::read_only:
+        return zebin::PreDefinedAttrGetter::ArgAccessType::readonly;
+    case cmc_access_kind::write_only:
+        return zebin::PreDefinedAttrGetter::ArgAccessType::writeonly;
+    case cmc_access_kind::read_write:
+        return zebin::PreDefinedAttrGetter::ArgAccessType::readwrite;
+    case cmc_access_kind::undef:
+    default:
+        IGC_ASSERT_MESSAGE(0, "invalid access type");
+        return zebin::PreDefinedAttrGetter::ArgAccessType::readwrite;
+    }
+}
+
 void CMKernel::createConstArgumentAnnotation(unsigned argNo, unsigned sizeInBytes, unsigned payloadPosition)
 {
     iOpenCL::ConstantArgumentAnnotation* constInput = new iOpenCL::ConstantArgumentAnnotation;
@@ -98,6 +130,10 @@ void CMKernel::createConstArgumentAnnotation(unsigned argNo, unsigned sizeInByte
     constInput->LocationCount = 0;
     constInput->IsEmulationArgument = false;
     m_kernelInfo.m_constantArgumentAnnotation.push_back(constInput);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+            zebin::ZEInfoBuilder::addPayloadArgumentByValue(m_kernelInfo.m_zePayloadArgs,
+                payloadPosition, sizeInBytes, argNo);
 }
 
 // TODO: this is incomplete.
@@ -118,6 +154,9 @@ void CMKernel::createSamplerAnnotation(unsigned argNo)
     samplerArg->PayloadPosition = 0;
 
     m_kernelInfo.m_samplerArgument.push_back(samplerArg);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+        IGC_ASSERT_MESSAGE(0, "not yet supported for L0 binary");
 }
 
 void CMKernel::createImageAnnotation(unsigned argNo, unsigned BTI, unsigned dim, bool isWriteable)
@@ -145,44 +184,44 @@ void CMKernel::createImageAnnotation(unsigned argNo, unsigned BTI, unsigned dim,
     imageInput->PayloadPosition = 0;
     imageInput->Writeable = isWriteable;
     m_kernelInfo.m_imageInputAnnotations.push_back(imageInput);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+        IGC_ASSERT_MESSAGE(0, "not yet supported for L0 binary");
 }
 
 void CMKernel::createImplicitArgumentsAnnotation(unsigned payloadPosition)
 {
-    for (int i = 0; i < 6; ++i) {
-        iOpenCL::ConstantInputAnnotation* constInput = new iOpenCL::ConstantInputAnnotation;
-        DWORD sizeInBytes = iOpenCL::DATA_PARAMETER_DATA_SIZE;
-
-        constInput->AnnotationSize = sizeof(constInput);
-        constInput->ConstantType = (i < 3 ? iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET
-                                          : iOpenCL::DATA_PARAMETER_LOCAL_WORK_SIZE);
-        constInput->Offset = (i % 3) * sizeInBytes;
-        constInput->PayloadPosition = payloadPosition;
-        constInput->PayloadSizeInBytes = sizeInBytes;
-        constInput->ArgumentNumber = 0;
-        constInput->LocationIndex = 0;
-        constInput->LocationCount = 0;
-        m_kernelInfo.m_constantInputAnnotation.push_back(constInput);
-
-        payloadPosition += sizeInBytes;
-    }
+    createSizeAnnotation(payloadPosition, iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET);
+    payloadPosition += 3 * iOpenCL::DATA_PARAMETER_DATA_SIZE;
+    createSizeAnnotation(payloadPosition, iOpenCL::DATA_PARAMETER_LOCAL_WORK_SIZE);
 }
 
-void CMKernel::createPointerGlobalAnnotation(unsigned argNo, unsigned byteSize, unsigned payloadPosition, int BTI)
+void CMKernel::createPointerGlobalAnnotation(const cmc_arg_info &argInfo)
 {
     iOpenCL::PointerArgumentAnnotation* ptrAnnotation = new iOpenCL::PointerArgumentAnnotation;
     ptrAnnotation->IsStateless = true;
     ptrAnnotation->IsBindlessAccess = false;
     ptrAnnotation->AddressSpace = iOpenCL::KERNEL_ARGUMENT_ADDRESS_SPACE_GLOBAL;
     ptrAnnotation->AnnotationSize = sizeof(ptrAnnotation);
-    ptrAnnotation->ArgumentNumber = argNo;
-    ptrAnnotation->BindingTableIndex = BTI;
-    ptrAnnotation->PayloadPosition = payloadPosition;
-    ptrAnnotation->PayloadSizeInBytes = byteSize;
+    ptrAnnotation->ArgumentNumber = argInfo.index;
+    ptrAnnotation->BindingTableIndex = argInfo.BTI;
+    ptrAnnotation->PayloadPosition = argInfo.offset;
+    ptrAnnotation->PayloadSizeInBytes = argInfo.sizeInBytes;
     ptrAnnotation->LocationIndex = 0;
     ptrAnnotation->LocationCount = 0;
     ptrAnnotation->IsEmulationArgument = false;
     m_kernelInfo.m_pointerArgument.push_back(ptrAnnotation);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+    {
+        zebin::ZEInfoBuilder::addPayloadArgumentByPointer(m_kernelInfo.m_zePayloadArgs,
+            argInfo.offset, argInfo.sizeInBytes, argInfo.index,
+            zebin::PreDefinedAttrGetter::ArgAddrMode::stateless,
+            zebin::PreDefinedAttrGetter::ArgAddrSpace::global,
+            getZEArgAccessType(argInfo.access));
+        zebin::ZEInfoBuilder::addBindingTableIndex(m_kernelInfo.m_zeBTIArgs,
+            argInfo.BTI, argInfo.index);
+    }
 }
 
 void CMKernel::createPrivateBaseAnnotation(
@@ -201,9 +240,12 @@ void CMKernel::createPrivateBaseAnnotation(
   ptrAnnotation->PayloadPosition = payloadPosition;
   ptrAnnotation->PayloadSizeInBytes = byteSize;
   m_kernelInfo.m_pointerInput.push_back(ptrAnnotation);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+        IGC_ASSERT_MESSAGE(0, "not yet supported for L0 binary");
 }
 
-void CMKernel::createBufferStatefulAnnotation(unsigned argNo)
+void CMKernel::createBufferStatefulAnnotation(unsigned argNo, cmc_access_kind accessKind)
 {
     iOpenCL::ConstantInputAnnotation* constInput = new iOpenCL::ConstantInputAnnotation;
 
@@ -216,11 +258,24 @@ void CMKernel::createBufferStatefulAnnotation(unsigned argNo)
     constInput->LocationIndex = 0;
     constInput->LocationCount = 0;
     m_kernelInfo.m_constantInputAnnotation.push_back(constInput);
+
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+    {
+        zebin::ZEInfoBuilder::addPayloadArgumentByPointer(m_kernelInfo.m_zePayloadArgs,
+            0, 0, argNo,
+            zebin::PreDefinedAttrGetter::ArgAddrMode::stateful,
+            zebin::PreDefinedAttrGetter::ArgAddrSpace::global,
+            getZEArgAccessType(accessKind));
+    }
 }
 
-void CMKernel::createSizeAnnotation(unsigned payloadPosition, int32_t Type)
+void CMKernel::createSizeAnnotation(unsigned initPayloadPosition,
+                                    iOpenCL::DATA_PARAMETER_TOKEN Type)
 {
-    for (int i = 0; i < 3; ++i) {
+    for (int i = 0, payloadPosition = initPayloadPosition;
+         i < 3;
+         ++i, payloadPosition += iOpenCL::DATA_PARAMETER_DATA_SIZE)
+    {
         iOpenCL::ConstantInputAnnotation* constInput = new iOpenCL::ConstantInputAnnotation;
         DWORD sizeInBytes = iOpenCL::DATA_PARAMETER_DATA_SIZE;
 
@@ -233,9 +288,11 @@ void CMKernel::createSizeAnnotation(unsigned payloadPosition, int32_t Type)
         constInput->LocationIndex = 0;
         constInput->LocationCount = 0;
         m_kernelInfo.m_constantInputAnnotation.push_back(constInput);
-
-        payloadPosition += sizeInBytes;
     }
+    if (IGC_IS_FLAG_ENABLED(EnableZEBinary))
+        zebin::ZEInfoBuilder::addPayloadArgumentImplicit(m_kernelInfo.m_zePayloadArgs,
+            getZEArgType(Type), initPayloadPosition,
+            iOpenCL::DATA_PARAMETER_DATA_SIZE * 3);
 }
 
 // TODO: refactor this function with the OCL part.
@@ -391,30 +448,31 @@ static void generatePatchTokens_v2(const cmc_kernel_info_v2 *info,
 
     for (unsigned i = 0; i < info->num_args; ++i) {
         IGC_ASSERT(info->arg_descs);
-        cmc_arg_info& AI = info->arg_descs[i];
+        cmc_arg_info AI = info->arg_descs[i];
         if (AI.offset > 0)
             maxArgEnd = std::max(AI.offset + AI.sizeInBytes, maxArgEnd);
         bool isWriteable = AI.access != cmc_access_kind::read_only;
+        AI.offset -= constantPayloadStart;
 
         switch (AI.kind) {
         default:
             break;
         case cmc_arg_kind::General:
-            kernel.createConstArgumentAnnotation(AI.index, AI.sizeInBytes, AI.offset - constantPayloadStart);
+            kernel.createConstArgumentAnnotation(AI.index, AI.sizeInBytes, AI.offset);
             break;
         case cmc_arg_kind::LocalSize:
-            kernel.createSizeAnnotation(AI.offset - constantPayloadStart, iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE);
+            kernel.createSizeAnnotation(AI.offset, iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE);
             break;
         case cmc_arg_kind::GroupCount:
-            kernel.createSizeAnnotation(AI.offset - constantPayloadStart, iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS);
+            kernel.createSizeAnnotation(AI.offset, iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS);
             break;
         case cmc_arg_kind::Buffer:
-            kernel.createPointerGlobalAnnotation(AI.index, AI.sizeInBytes, AI.offset - constantPayloadStart, AI.BTI);
-            kernel.createBufferStatefulAnnotation(AI.index);
+            kernel.createPointerGlobalAnnotation(AI);
+            kernel.createBufferStatefulAnnotation(AI.index, AI.access);
             kernel.m_kernelInfo.m_argIndexMap[AI.index] = AI.BTI;
             break;
         case cmc_arg_kind::SVM:
-            kernel.createPointerGlobalAnnotation(AI.index, AI.sizeInBytes, AI.offset - constantPayloadStart, AI.BTI);
+            kernel.createPointerGlobalAnnotation(AI);
             kernel.m_kernelInfo.m_argIndexMap[AI.index] = AI.BTI;
             break;
         case cmc_arg_kind::Sampler:
@@ -438,14 +496,14 @@ static void generatePatchTokens_v2(const cmc_kernel_info_v2 *info,
             kernel.m_kernelInfo.m_printfBufferAnnotation->AnnotationSize = sizeof(kernel.m_kernelInfo.m_printfBufferAnnotation);
             kernel.m_kernelInfo.m_argIndexMap[AI.index] = AI.BTI;
             kernel.m_kernelInfo.m_printfBufferAnnotation->ArgumentNumber = AI.index;
-            kernel.m_kernelInfo.m_printfBufferAnnotation->PayloadPosition = AI.offset - constantPayloadStart;
+            kernel.m_kernelInfo.m_printfBufferAnnotation->PayloadPosition = AI.offset;
             kernel.m_kernelInfo.m_printfBufferAnnotation->Index = 0;
             kernel.m_kernelInfo.m_printfBufferAnnotation->DataSize = 8;
             break;
         case cmc_arg_kind::PrivateBase:
             if (info->StatelessPrivateMemSize) {
                 kernel.createPrivateBaseAnnotation(AI.index, AI.sizeInBytes,
-                    AI.offset - constantPayloadStart, AI.BTI, info->StatelessPrivateMemSize);
+                    AI.offset, AI.BTI, info->StatelessPrivateMemSize);
                 kernel.m_kernelInfo.m_argIndexMap[AI.index] = AI.BTI;
             }
             break;
@@ -484,6 +542,7 @@ static void populateKernelInfo_v2(const cmc_kernel_info_v2* info,
                                   llvm::ArrayRef<uint8_t> genBin,
                                   CMKernel& kernel)
 {
+    kernel.m_GRFSizeInBytes = info->GRFByteSize;
     // ExecutionEnivronment:
     //
     auto& kInfo = kernel.m_kernelInfo;
diff --git a/IGC/AdaptorOCL/cmc.h b/IGC/AdaptorOCL/cmc.h
@@ -55,6 +55,7 @@ class CMKernel {
     IGC::SOpenCLKernelInfo m_kernelInfo;
     IGC::SProgramOutput m_prog;
     IGC::COCLBTILayout m_btiLayout;
+    uint32_t m_GRFSizeInBytes;
 
     // General argument
     void createConstArgumentAnnotation(unsigned argNo,
@@ -68,20 +69,18 @@ class CMKernel {
                                 bool isWriteable);
 
     // add a pointer patch token.
-    void createPointerGlobalAnnotation(unsigned argNo,
-                                       unsigned byteSize,
-                                       unsigned payloadPosition,
-                                       int BTI);
+    void createPointerGlobalAnnotation(const cmc_arg_info &argInfo);
 
     void createPrivateBaseAnnotation(unsigned argNo, unsigned byteSize,
                                      unsigned payloadPosition, int BTI,
                                      unsigned statelessPrivateMemSize);
 
     // add a stateful buffer patch token.
-    void createBufferStatefulAnnotation(unsigned argNo);
+    void createBufferStatefulAnnotation(unsigned argNo,
+                                        cmc_access_kind accessKind);
 
     // Local or global size
-    void createSizeAnnotation(unsigned payloadPosition, int32_t type);
+    void createSizeAnnotation(unsigned payloadPosition, iOpenCL::DATA_PARAMETER_TOKEN type);
 
     // Global work offset/local work size
     void createImplicitArgumentsAnnotation(unsigned payloadPosition);
