refactor

Change-Id: I0170451f52c002fc12dcf2f690194c867cff3bde

Author: Jay-Jiewu-Lu

IGC/AdaptorOCL/OCL/KernelAnnotations.hpp

@@ -278,9 +278,16 @@ struct ExecutionEnivronment
 {
     DWORD  CompiledSIMDSize                           = 0;
     DWORD  CompiledSubGroupsNumber                    = 0;
-    DWORD  PerThreadSpillFillSize                     = 0;
+    //legacy design:hold all ScratchSpaceUsage
+    //new design:   hold spillfill+callstack+GTPin
+    //Todo: rename it to m_PerThreadScratchSpaceSlot0
     DWORD  PerThreadScratchSpace                      = 0;
-    DWORD  PerThreadScratchUseGtpin                   = 0;
+    //DWORD  PerThreadScratchUseGtpin                   = 0;
+    //legacy design:not used
+    //new design:   hold private memory used by shader if non-ZERO
+    DWORD  PerThreadScratchSpaceSlot1                 = 0;
+    //legacy design:not used
+    //new design:   hold private memory used by shader if non-ZERO
     DWORD  SumFixedTGSMSizes                          = 0;
     bool   HasDeviceEnqueue                           = false;
     bool   HasBarriers                                = false;

IGC/AdaptorOCL/OCL/Patch/patch_parser.cpp

@@ -707,6 +707,24 @@ void DebugPatchList(
             }
             break;
 
+        case iOpenCL::PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1:
+        {
+            const iOpenCL::SPatchMediaVFEState* pPatchItem =
+                (const iOpenCL::SPatchMediaVFEState*)pHeader;
+
+            ICBE_DPF_STR(output, GFXDBG_HARDWARE,
+                "PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1 (%08X) (size = %d)\n",
+                pPatchItem->Token,
+                pPatchItem->Size);
+            ICBE_DPF_STR(output, GFXDBG_HARDWARE,
+                "\tScratchSpaceOffset = %d\n",
+                pPatchItem->ScratchSpaceOffset);
+            ICBE_DPF_STR(output, GFXDBG_HARDWARE,
+                "\tPerThreadScratchSpaceSlot1 = %d\n",
+                pPatchItem->PerThreadScratchSpace);
+        }
+        break;
+
         case iOpenCL::PATCH_TOKEN_MEDIA_INTERFACE_DESCRIPTOR_LOAD:
             {
                 const iOpenCL::SPatchMediaInterfaceDescriptorLoad* pPatchItem =
@@ -849,6 +867,9 @@ void DebugPatchList(
                 ICBE_DPF_STR( output, GFXDBG_HARDWARE,
                     "\tUsesStatelessSpillFill = %s\n",
                     pPatchItem->UsesStatelessSpillFill ? "true" : "false" );
+                ICBE_DPF_STR(output, GFXDBG_HARDWARE,
+                    "\tUsesMultiScratchSpaces = %s\n",
+                    pPatchItem->UsesMultiScratchSpaces ? "true" : "false");
                 ICBE_DPF_STR( output, GFXDBG_HARDWARE,
                     "\tIsCoherent = %s\n",
                     pPatchItem->IsCoherent ? "true" : "false" );

IGC/AdaptorOCL/OCL/sp/sp_g8.cpp

@@ -1181,8 +1181,7 @@ RETVAL CGen8OpenCLStateProcessor::CreatePatchList(
     // Patch for MEDIA_VFE_STATE
     if( retValue.Success )
     {
-      const DWORD perThreadScratchSpaceSizeInBytes = annotations.m_executionEnivronment.PerThreadSpillFillSize
-        + annotations.m_executionEnivronment.PerThreadScratchSpace + annotations.m_executionEnivronment.PerThreadScratchUseGtpin;
+      const DWORD perThreadScratchSpaceSizeInBytes = annotations.m_executionEnivronment.PerThreadScratchSpace;
       if (perThreadScratchSpaceSizeInBytes > 0)
         {
             iOpenCL::SPatchMediaVFEState    patch;
@@ -1204,6 +1203,31 @@ RETVAL CGen8OpenCLStateProcessor::CreatePatchList(
         }
     }
 
+    // Patch for MEDIA_VFE_STATE slot1
+    if (retValue.Success)
+    {
+        const DWORD perThreadScratchSpaceSizeInBytes = annotations.m_executionEnivronment.PerThreadScratchSpaceSlot1;
+        if (perThreadScratchSpaceSizeInBytes > 0)
+        {
+            iOpenCL::SPatchMediaVFEState    patch;
+
+            memset(&patch, 0, sizeof(patch));
+
+            patch.Token = iOpenCL::PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1;
+            patch.Size = sizeof(patch);
+            patch.ScratchSpaceOffset = 0;
+
+            patch.PerThreadScratchSpace =
+                iSTD::RoundPower2(
+                    iSTD::Max(perThreadScratchSpaceSizeInBytes,
+                        static_cast<DWORD>(sizeof(KILOBYTE))));
+
+            retValue = AddPatchItem(
+                patch,
+                membuf);
+        }
+    }
+
     // Patch for MEDIA_INTERFACE_DESCRIPTOR_LOAD
     if( retValue.Success )
     {
@@ -1954,9 +1978,8 @@ RETVAL CGen8OpenCLStateProcessor::CreatePatchList(
         patch.HasBarriers                       = annotations.m_executionEnivronment.HasBarriers;
         patch.DisableMidThreadPreemption        = annotations.m_executionEnivronment.DisableMidThreadPreemption;
 
-
-        patch.UsesStatelessSpillFill = (annotations.m_executionEnivronment.PerThreadSpillFillSize > 0)
-          || (annotations.m_executionEnivronment.PerThreadScratchSpace > 0) || (annotations.m_executionEnivronment.PerThreadScratchUseGtpin > 0);
+        patch.UsesStatelessSpillFill = (annotations.m_executionEnivronment.PerThreadScratchSpace > 0);
+        patch.UsesMultiScratchSpaces = false;
 
         patch.HasDeviceEnqueue = (bool)hasDeviceEnqueue;
 

IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_list.h

@@ -34,7 +34,7 @@ Abstract:   Contains common patch structure definitions
 namespace iOpenCL
 {
 
-const uint32_t CURRENT_ICBE_VERSION = 1058;
+const uint32_t CURRENT_ICBE_VERSION = 1059;
 
 const uint32_t MAGIC_CL = 0x494E5443;      // 'I', 'N', 'T', 'C'
 const uint32_t INVALID_INDEX = 0xFFFFFFFF;
@@ -150,12 +150,13 @@ enum PATCH_TOKEN
     PATCH_TOKEN_GTPIN_INFO,                                        // 52  @SPatchItemHeader@
     PATCH_TOKEN_PROGRAM_SYMBOL_TABLE,                             // 53  @SPatchFunctionTableInfo@
     PATCH_TOKEN_PROGRAM_RELOCATION_TABLE,                         // 54  @SPatchFunctionTableInfo@
+    PATCH_TOKEN_MEDIA_VFE_STATE_SLOT1,                            // 55  @SPatchMediaVFEState of slot1@
 
     NUM_PATCH_TOKENS
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert( NUM_PATCH_TOKENS == 55, "NUM_PATCH_TOKENS has invalid value");
+static_assert( NUM_PATCH_TOKENS == 56, "NUM_PATCH_TOKENS has invalid value");
 
 /*****************************************************************************\
 ENUM: IMAGE_MEMORY_OBJECT_TYPE

IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_shared.h

@@ -199,6 +199,7 @@ struct SPatchExecutionEnvironment :
     uint32_t    MayAccessUndeclaredResource;
     uint32_t    UsesFencesForReadWriteImages;
     uint32_t    UsesStatelessSpillFill;
+    uint32_t    UsesMultiScratchSpaces;
     uint32_t    IsCoherent;
     uint32_t    IsInitializer;
     uint32_t    IsFinalizer;
@@ -211,7 +212,7 @@ struct SPatchExecutionEnvironment :
 };
 
 // Update CURRENT_ICBE_VERSION when modifying the patch list
-static_assert(sizeof(SPatchExecutionEnvironment) == (92 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
+static_assert(sizeof(SPatchExecutionEnvironment) == (96 + sizeof(SPatchItemHeader)), "The size of SPatchExecutionEnvironment is not what is expected");
 
 /*****************************************************************************\
 STRUCT: SPatchString

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -4670,7 +4670,7 @@ void CEncoder::Compile()
         pOutput->m_scratchSpaceUsedBySpills = jitInfo->spillMemUsed;
     }
 
-    pOutput->setScratchPrivateUsage(m_program->m_ScratchSpaceSize, m_program->m_Platform->maxPerThreadScratchSpace());
+    pOutput->setScratchSpaceUsedByShader(m_program->m_ScratchSpaceSize);
 
     pOutput->m_scratchSpaceUsedByGtpin = jitInfo->numBytesScratchGtpin;
 

IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp

@@ -1598,9 +1598,8 @@ unsigned int COpenCLKernel::getSumFixedTGSMSizes(Function* F)
 
 void COpenCLKernel::FillKernel()
 {
-    m_kernelInfo.m_executionEnivronment.PerThreadSpillFillSize = ProgramOutput()->m_scratchSpaceUsedBySpills;
-    m_kernelInfo.m_executionEnivronment.PerThreadScratchSpace = ProgramOutput()->m_scratchSpaceUsedByShader;
-    m_kernelInfo.m_executionEnivronment.PerThreadScratchUseGtpin = ProgramOutput()->m_scratchSpaceUsedByGtpin;
+    m_kernelInfo.m_executionEnivronment.PerThreadScratchSpace = ProgramOutput()->getScratchSpaceUsageInSlot0();
+    m_kernelInfo.m_executionEnivronment.PerThreadScratchSpaceSlot1 = ProgramOutput()->getScratchSpaceUsageInSlot1();
     m_kernelInfo.m_kernelProgram.NOSBufferSize = m_NOSBufferSize / getGRFSize(); // in 256 bits
     m_kernelInfo.m_kernelProgram.ConstantBufferLength = m_ConstantBufferLength / getGRFSize(); // in 256 bits
     m_kernelInfo.m_kernelProgram.MaxNumberOfThreads = m_Platform->getMaxGPGPUShaderThreads();
@@ -1904,8 +1903,10 @@ static bool SetKernelProgram(COpenCLKernel* shader, DWORD simdMode)
     {
         if (simdMode == 32)
         {
-            shader->m_kernelInfo.m_executionEnivronment.PerThreadSpillFillSize =
-                shader->ProgramOutput()->m_scratchSpaceUsedBySpills;
+            //why do we need this? we will get all output in GatherDataForDriver(...)
+            //remove it to avoid messy logics
+            //shader->m_kernelInfo.m_executionEnivronment.PerThreadSpillFillSize =
+            //    shader->ProgramOutput()->m_scratchSpaceUsedBySpills;
             shader->m_kernelInfo.m_kernelProgram.simd32 = *shader->ProgramOutput();
         }
         else if (simdMode == 16)

IGC/Compiler/CISACodeGen/PixelShaderCodeGen.cpp

@@ -1190,8 +1190,6 @@ namespace IGC
             cps.m_scratchSpaceUsedBySpills + ps.m_scratchSpaceUsedBySpills;
         linked.m_scratchSpaceUsedByGtpin =
             cps.m_scratchSpaceUsedByGtpin + ps.m_scratchSpaceUsedByGtpin;
-        linked.m_scratchSpaceUsedByStateless =
-            cps.m_scratchSpaceUsedByStateless + ps.m_scratchSpaceUsedByStateless;
         linked.m_programSize = iSTD::Align(linked.m_unpaddedProgramSize, 64);
         linked.m_programBin = IGC::aligned_malloc(linked.m_programSize, 16);
         // Copy coarse phase

IGC/Compiler/CodeGenPublic.h

@@ -93,8 +93,7 @@ namespace IGC
         unsigned int    m_unpaddedProgramSize;      //<! program size without padding used for binary linking
         unsigned int    m_startReg;                 //<! Which GRF to start with
         unsigned int    m_scratchSpaceUsedBySpills; //<! amount of scratch space needed for shader spilling
-        unsigned int    m_scratchSpaceUsedByShader; //<! amount of scratch space needed by shader if allocated in scratchspace
-        unsigned int    m_scratchSpaceUsedByStateless; //<! amount of scratch space needed by shader if allocated in stateless surface
+        unsigned int    m_scratchSpaceUsedByShader; //<! amount of scratch space needed by shader
         unsigned int    m_scratchSpaceUsedByGtpin; //<! amount of scratch space used by gtpin
         void*           m_debugDataVISA;            //<! VISA debug data (source -> VISA)
         unsigned int    m_debugDataVISASize;        //<! Number of bytes of VISA debug data
@@ -114,7 +113,8 @@ namespace IGC
         //false means all of them are together
         bool            m_separatePvtSpill = false;
         bool            m_roundPower2KBytes = false;
-
+        unsigned int m_scratchSpaceSizeLimit = 0;
+    
         void Destroy()
         {
             if (m_programBin)
@@ -131,48 +131,48 @@ namespace IGC
             }
         }
 
-        void setSeparatePvtSpill(bool setSeparatePvtSpillT, bool roundPower2KBytes)
+        void init(bool setSeparatePvtSpillT, bool roundPower2KBytes, unsigned int scratchSpaceSizeLimitT)
         {
             m_separatePvtSpill = setSeparatePvtSpillT;
             m_roundPower2KBytes = roundPower2KBytes;
+            m_scratchSpaceSizeLimit = scratchSpaceSizeLimitT;
         }
 
-        unsigned int getScratchSpaceUsage() const
+        //InSlot0
+        //Todo: rename later
+        unsigned int getScratchSpaceUsageInSlot0() const
         {
-            unsigned int size = m_scratchSpaceUsedBySpills + m_scratchSpaceUsedByGtpin + (m_separatePvtSpill ? 0 : m_scratchSpaceUsedByShader);
-            if (m_roundPower2KBytes)
-            {
-                size = roundPower2KBbyte(size);
-            } 
-            return size;
+            return roundSize(m_scratchSpaceUsedBySpills + m_scratchSpaceUsedByGtpin + (m_separatePvtSpill ? 0 : m_scratchSpaceUsedByShader));
         }
 
-        unsigned int getScratchPrivateUsage() const
+        unsigned int getScratchSpaceUsageInSlot1() const
         {
-            return (m_separatePvtSpill ? m_scratchSpaceUsedByShader : 0);
+            return roundSize((m_separatePvtSpill && m_scratchSpaceUsedByShader <= m_scratchSpaceSizeLimit) ? m_scratchSpaceUsedByShader : 0);
         }
 
-        void setScratchPrivateUsage(unsigned int scratchPrivateUsage, unsigned int scratchSpaceSizeLimit)
+        unsigned int getScratchSpaceUsageInStateless() const
         {
-            if (m_separatePvtSpill && scratchPrivateUsage > scratchSpaceSizeLimit)
-            {
-                m_scratchSpaceUsedByStateless = scratchPrivateUsage;
-            }
-            else
-            {
-                m_scratchSpaceUsedByShader = scratchPrivateUsage;
-            }
+            return ((m_separatePvtSpill && m_scratchSpaceUsedByShader > m_scratchSpaceSizeLimit) ? m_scratchSpaceUsedByShader : 0);
         }
 
-        unsigned int getStatelessPrivateUsage() const
+        void setScratchSpaceUsedByShader(unsigned int scratchSpaceUsedByShader)
         {
-            return (m_separatePvtSpill ? m_scratchSpaceUsedByStateless : 0);
+            m_scratchSpaceUsedByShader = scratchSpaceUsedByShader;
         }
-    private:
-        unsigned int roundPower2KBbyte(unsigned int size) const
+private:
+    unsigned int roundSize(unsigned int size) const
+    {
+        if (m_roundPower2KBytes)
         {
-            return (size ? iSTD::RoundPower2(iSTD::Max(int_cast<DWORD>(size), static_cast<DWORD>(sizeof(KILOBYTE)))) : 0);
+            size = roundPower2KBbyte(size);
         }
+        return size;
+    }
+
+    unsigned int roundPower2KBbyte(unsigned int size) const
+    {
+        return (size ? iSTD::RoundPower2(iSTD::Max(int_cast<DWORD>(size), static_cast<DWORD>(sizeof(KILOBYTE)))) : 0);
+    }
 
     };
 

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp

@@ -359,7 +359,8 @@ bool PrivateMemoryResolution::safeToUseScratchSpace(llvm::Module &M) const
    if (modMD.compOpt.OptDisable
        || !Ctx.m_DriverInfo.usesScratchSpacePrivateMemory()
        || (Ctx.type == ShaderType::OPENCL_SHADER
-           && !Ctx.platform.useScratchSpaceForOCL()))
+           && !Ctx.platform.useScratchSpaceForOCL()
+           ))
    {
      return false;
    }