Refactoring cache control

Refactoring cache control input.

Author: gkluczek

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -9393,7 +9393,7 @@ namespace IGC
         AtomicOp atomic_op, ResourceDescriptor* resource,
         CVariable* pU, CVariable* pV, CVariable* pR,
         CVariable* pSrc0, CVariable* pSrc1, CVariable* pDst,
-        unsigned elemSize, LSC_ADDR_SIZE addr_size)
+        unsigned elemSize, LSC_ADDR_SIZE addr_size, LSC_CACHE_OPTS cacheOpts)
     {
         // DG2: SIMD8, PVC: SIMD16, Xe2: SIMD32
         VISA_Exec_Size execSize = visaExecSize(m_encoderState.m_simdSize);
@@ -9414,7 +9414,6 @@ namespace IGC
 
         VISA_EMask_Ctrl mask = ConvertMaskToVisaType(m_encoderState.m_mask, m_encoderState.m_noMask);
         VISA_VectorOpnd* globalOffsetOpnd = GetVISALSCSurfaceOpnd(resource->m_surfaceType, resource->m_resource);
-        LSC_CACHE_OPTS cache{ LSC_CACHING_DEFAULT, LSC_CACHING_DEFAULT };
         LSC_DATA_SHAPE dataShape{};
         dataShape.size = LSC_GetElementSize(elemSize);
         dataShape.order = LSC_DATA_ORDER_NONTRANSPOSE;
@@ -9425,7 +9424,7 @@ namespace IGC
             predOpnd,
             execSize,
             mask,
-            cache,
+            cacheOpts,
             getLSCAddrType(resource),
             addr_size,
             dataShape,

IGC/Compiler/CISACodeGen/CISABuilder.hpp

@@ -333,7 +333,7 @@ namespace IGC
             AtomicOp subOp, ResourceDescriptor* resource,
             CVariable* pU, CVariable* pV, CVariable* pR,
             CVariable* pSrc0, CVariable* pSrc1, CVariable* pSrcDst,
-            unsigned elemSize, LSC_ADDR_SIZE addr_size);
+            unsigned elemSize, LSC_ADDR_SIZE addr_size, LSC_CACHE_OPTS cacheOpts);
 
 
         void LSC_Typed2dBlock(

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -14685,11 +14685,12 @@ void EmitPass::emitScalarAtomics(llvm::Instruction *pInst,
     }
     if (shouldGenerateLSC(pInst))
     {
+        auto cacheOpts = LSC_DEFAULT_CACHING;
         if (pU || pV || pR)
         {
             m_encoder->LSC_TypedAtomic(uniformAtomicOp, &resource, pU, pV, pR,
                                        pFinalAtomicSrcVal, nullptr /*src1*/,
-                                       pReturnVal, bitWidth, LSC_ADDR_SIZE_32b);
+                                       pReturnVal, bitWidth, LSC_ADDR_SIZE_32b, cacheOpts);
         }
         else
         {
@@ -14704,7 +14705,7 @@ void EmitPass::emitScalarAtomics(llvm::Instruction *pInst,
                 addrSize,
                 immOffset,
                 immScale,
-                LSC_DEFAULT_CACHING);
+                cacheOpts);
         }
     }
     else
@@ -14823,6 +14824,7 @@ void EmitPass::emitScalarAtomicLoad(
             pDstAddr ? pDstAddr->getName() : CName::NONE) : nullptr;
     if (shouldGenerateLSC(pInst))
     {
+        auto cacheOpts = LSC_DEFAULT_CACHING;
         if (pU || pV || pR)
         {
             m_encoder->LSC_TypedAtomic(
@@ -14835,7 +14837,8 @@ void EmitPass::emitScalarAtomicLoad(
                 nullptr /*src1*/,
                 atomicDst,
                 bitWidth,
-                LSC_ADDR_SIZE_32b);
+                LSC_ADDR_SIZE_32b,
+                cacheOpts);
         }
         else
         {
@@ -14850,7 +14853,7 @@ void EmitPass::emitScalarAtomicLoad(
                 addrSize,
                 immOffset,
                 immScale,
-                LSC_DEFAULT_CACHING);
+                cacheOpts);
         }
     }
     else
@@ -15213,10 +15216,11 @@ void EmitPass::emitAtomicRaw(llvm::GenIntrinsicInst *pInst, Value *dstAddr,
             else
             {
                 if (shouldGenerateLSC()) {
+                    auto cacheOpts = LSC_DEFAULT_CACHING;
                     m_encoder->LSC_AtomicRaw(atomic_op, pDst,
                                              pDstAddr, pSrc0, pSrc1, bitwidth,
                                              &resource, addrSize, immOffsetVal,
-                                             immScaleVal, LSC_DEFAULT_CACHING);
+                                             immScaleVal, cacheOpts);
                 }
                 else
                 {
@@ -15263,10 +15267,11 @@ void EmitPass::emitAtomicRaw(llvm::GenIntrinsicInst *pInst, Value *dstAddr,
             CVariable* flag = nullptr;
             bool needLoop = ResourceLoopHeader(resource, flag, label);
             if (shouldGenerateLSC(pInst)) {
+                auto cacheOpts = LSC_DEFAULT_CACHING;
                 m_encoder->LSC_AtomicRaw(atomic_op, pDst,
                                          pDstAddr, pSrc0, pSrc1, bitwidth,
                                          &resource, addrSize, immOffsetVal,
-                                         immScaleVal, LSC_DEFAULT_CACHING);
+                                         immScaleVal, cacheOpts);
             }
             else
             {
@@ -19566,10 +19571,11 @@ void EmitPass::emitLSCAtomicTyped(llvm::GenIntrinsicInst* inst)
         uint regsPerAddrChannel = 32 * numLanes(instWidth) / 8 / getGRFSize();
         uint regsPerDataChannel = eltSizeInBits * numLanes(instWidth) / 8 / getGRFSize();
         LSC_ADDR_SIZE addrSize = LSC_ADDR_SIZE_32b;
+        auto cacheOpts = LSC_DEFAULT_CACHING;
         if (!needsSplit)
         {
             m_encoder->SetPredicate(flag);
-            m_encoder->LSC_TypedAtomic(atomic_op, &resource, pU, pV, pR, pSrc0, pSrc1, returnsImmValue ? m_destination : nullptr, eltSizeInBits, addrSize);
+            m_encoder->LSC_TypedAtomic(atomic_op, &resource, pU, pV, pR, pSrc0, pSrc1, returnsImmValue ? m_destination : nullptr, eltSizeInBits, addrSize, cacheOpts);
             m_encoder->Push();
         }
         else
@@ -19590,7 +19596,7 @@ void EmitPass::emitLSCAtomicTyped(llvm::GenIntrinsicInst* inst)
                 setSIMDSizeMask(m_encoder, m_currShader, i);
                 m_encoder->SetSrcSubVar(0, i * regsPerAddrChannel);
                 m_encoder->SetSrcSubVar(1, i * regsPerDataChannel);
-                m_encoder->LSC_TypedAtomic(atomic_op, &resource, pU, pV, pR, pSrc0, pSrc1, tempdst[i], eltSizeInBits, addrSize);
+                m_encoder->LSC_TypedAtomic(atomic_op, &resource, pU, pV, pR, pSrc0, pSrc1, tempdst[i], eltSizeInBits, addrSize, cacheOpts);
                 m_encoder->Push();
             }
         }