GMM Global Context removal (#62)

* Phase 1: As part of global and static code removal- GMM policy, plaformInfo and texture class updated to have pGmmGlobal contextas part of it

* Updating the GMM #define to make sure it uses parameterized GMMlib Context

* Replace pGmmGlobalContext with member variable with pGmmLibContext in all GMM cache policy files

* Replace pGmmGlobalContext with pGmmLibContext in all Platform Class related API

* Remove any remaining use of pGmmGlobalContext

* Phase 2: Update Macros to use pGmmLibContext (local) instead of global pGmmGlobalContext

* Replace pGmmGlobalContext with pGmmUMDLibContext/pGmmKMDLibContext in GMM_RESOURCE_INFO class and its member functions

* All KMD level pGmmGlobalContext global variable is removed and replaced with pGmmLibContext

* Phase 3: Add support for Multi-Adapter in GMM UMD Library and replace pGmmGloContext to pGmmLibContext

* Make GMM UMD DLL Initialize and Destroy APIs backward compatible for SingleAdapter use case

* Phase 4: Enable and add support for Multi-Adapter ULT for GMM UMD DLL in GMM ULT

* Update the Entry-Level Init and destroy APIs

* Phase 5: Remove the pGmmGlobalContext Global and its dependencies

* Initial cleanup of KMD code

* Updating variable data type and License Info

Author: johnmach

Source/GmmLib/CMakeLists.txt

@@ -269,7 +269,6 @@ set(SOURCES_
   ${BS_DIR_GMMLIB}/Texture/GmmTextureOffset.cpp
   ${BS_DIR_GMMLIB}/GlobalInfo/GmmInfo.cpp
   ${BS_DIR_GMMLIB}/Utility/CpuSwizzleBlt/CpuSwizzleBlt.c
-  ${BS_DIR_GMMLIB}/Utility/GmmLibObject.cpp
   ${BS_DIR_GMMLIB}/Utility/GmmLog/GmmLog.cpp
   ${BS_DIR_GMMLIB}/Utility/GmmUtility.cpp
 )

Source/GmmLib/CachePolicy/GmmCachePolicy.cpp

@@ -26,30 +26,32 @@ OTHER DEALINGS IN THE SOFTWARE.
 /////////////////////////////////////////////////////////////////////////////////////
 /// C Wrapper function for GmmLib::GmmCachePolicyGetPteType
 /// @see           GmmLib::GmmCachePolicyCommon::CachePolicyGetPteType()
-///
+//
+/// @param[in]     pLibContext: pGmmLibContext
 /// @param[in]     Usage: type of usage
 ///
 /// @return        GMM_PTE_CACHE_CONTROL_BITS:Populated PTE
 ///
 /////////////////////////////////////////////////////////////////////////////////////
-GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmCachePolicyGetPteType(GMM_RESOURCE_USAGE_TYPE Usage)
+GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmCachePolicyGetPteType(void *pLibContext, GMM_RESOURCE_USAGE_TYPE Usage)
 {
-    return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetPteType(Usage);
+    GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetPteType(Usage);
 }
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// C Wrapper function for GmmLib::GmmCachePolicyIsUsagePTECached
 /// @see           GmmLib::GmmCachePolicyCommon::CachePolicyIsUsagePTECached()
 ///
+/// @param[in]     pLibContext: pGmmLibContext
 /// @param[in]     Usage: type of usage
 ///
 /// @return        1 if the usage PTE entry is set for cached, 0 otherwise.
 /////////////////////////////////////////////////////////////////////////////////////
-uint8_t GMM_STDCALL GmmCachePolicyIsUsagePTECached(GMM_RESOURCE_USAGE_TYPE Usage)
+uint8_t GMM_STDCALL GmmCachePolicyIsUsagePTECached(void *pLibContext, GMM_RESOURCE_USAGE_TYPE Usage)
 {
-    return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyIsUsagePTECached(Usage);
+    GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    return pGmmLibContext->GetCachePolicyObj()->CachePolicyIsUsagePTECached(Usage);
 }
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// C wrapper for GmmLib::GmmResourceInfoCommon::GetCachePolicyUsage.
 /// @see        GmmLib::GmmResourceInfoCommon::GetCachePolicyUsage()
@@ -85,9 +87,10 @@ void GMM_STDCALL GmmCachePolicyOverrideResourceUsage(GMM_RESOURCE_INFO *pResInfo
 /// @return        MEMORY_OBJECT_CONTROL_STATE: Gen adjusted MOCS structure (cache
 ///                                             policy) for the given buffer use.
 /////////////////////////////////////////////////////////////////////////////////////
-MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
+MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(void *pLibContext, GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
 {
-    return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetMemoryObject(pResInfo, Usage);
+    GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetMemoryObject(pResInfo, Usage);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -100,58 +103,61 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(GMM_RESOUR
 ///  @return        MEMORY_OBJECT_CONTROL_STATE: Populated memory object
 ///
 /////////////////////////////////////////////////////////////////////////////////////
-MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetOriginalMemoryObject(GMM_RESOURCE_INFO *pResInfo)
+MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetOriginalMemoryObject(void *pLibContext, GMM_RESOURCE_INFO *pResInfo)
 {
-    return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetOriginalMemoryObject(pResInfo);
+    GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetOriginalMemoryObject(pResInfo);
 }
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// C Wrapper function for GmmCachePolicy::GmmGetWantedMemoryType.
 /// @see            GmmLib::GmmCachePolicy::GetWantedMemoryType()
 ///
 /// @param[in]      CachePolicy:cache policy for a usage
+/// @param[in]     pLibContext: pGmmLibContext
 ///
 /// @return         wanted memory type
 /////////////////////////////////////////////////////////////////////////////////////
-GMM_GFX_MEMORY_TYPE GmmGetWantedMemoryType(GMM_CACHE_POLICY_ELEMENT CachePolicy)
+GMM_GFX_MEMORY_TYPE GmmGetWantedMemoryType(void *pLibContext, GMM_CACHE_POLICY_ELEMENT CachePolicy)
 {
-    return pGmmGlobalContext->GetCachePolicyObj()->GetWantedMemoryType(CachePolicy);
+    GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    return pGmmLibContext->GetCachePolicyObj()->GetWantedMemoryType(CachePolicy);
 }
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// Returns count of current MOCS values for MOCS Table programming at GMM boot
 ///
-/// @param[in]  none:
+/// @param[in]     pLibContext: pGmmLibContext
 /// @return     uint32_t  no of mocs register required to program
 /////////////////////////////////////////////////////////////////////////////////////
-uint32_t GMM_STDCALL GmmCachePolicyGetMaxMocsIndex(void)
+uint32_t GMM_STDCALL GmmCachePolicyGetMaxMocsIndex(void *pLibContext)
 {
-    GMM_CACHE_POLICY *          pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
-    GmmLib::GmmGen9CachePolicy *ptr          = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
+    GMM_LIB_CONTEXT *           pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    GMM_CACHE_POLICY *          pCachePolicy   = pGmmLibContext->GetCachePolicyObj();
+    GmmLib::GmmGen9CachePolicy *ptr            = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
     return ptr->CurrentMaxMocsIndex;
 }
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// Returns count of current L1 HDC MOCS values for MOCS Table programming at GMM boot
 ///
-/// @param[in]  none:
+/// @param[in]     pLibContext: pGmmLibContext
 /// @return     uint32_t  max L1 hdc mocs index needed to program
 /////////////////////////////////////////////////////////////////////////////////////
-uint32_t GMM_STDCALL GmmCachePolicyGetMaxL1HdcMocsIndex(void)
+uint32_t GMM_STDCALL GmmCachePolicyGetMaxL1HdcMocsIndex(void *pLibContext)
 {
-    GMM_CACHE_POLICY *          pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
-    GmmLib::GmmGen9CachePolicy *ptr          = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
+    GMM_LIB_CONTEXT *           pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    GMM_CACHE_POLICY *          pCachePolicy   = pGmmLibContext->GetCachePolicyObj();
+    GmmLib::GmmGen9CachePolicy *ptr            = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
     return ptr->CurrentMaxL1HdcMocsIndex;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// Returns count of current Special MOCS values for MOCS Table programming at GMM boot
 ///
-/// @param[in]  none:
+/// @param[in]     pLibContext: pGmmLibContext
 /// @return     uint32_t  max special mocs index needed to program
 /////////////////////////////////////////////////////////////////////////////////////
-uint32_t GMM_STDCALL GmmCachePolicyGetMaxSpecialMocsIndex(void)
+uint32_t GMM_STDCALL GmmCachePolicyGetMaxSpecialMocsIndex(void *pLibContext)
 {
-    GMM_CACHE_POLICY *pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
+    GMM_LIB_CONTEXT * pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
+    GMM_CACHE_POLICY *pCachePolicy   = pGmmLibContext->GetCachePolicyObj();
     return pCachePolicy->GetMaxSpecialMocsIndex();
-}
+}

Source/GmmLib/CachePolicy/GmmCachePolicyCommon.cpp

@@ -23,15 +23,14 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Internal/Common/GmmLibInc.h"
 #include "External/Common/GmmCachePolicy.h"
 
-int32_t GmmLib::GmmCachePolicyCommon::RefCount = 0;
-
 /////////////////////////////////////////////////////////////////////////////////////
 /// Constructor for the GmmCachePolicyCommon Class, initializes the CachePolicy
 /// @param[in]         pCachePolicy
 /////////////////////////////////////////////////////////////////////////////////////
-GmmLib::GmmCachePolicyCommon::GmmCachePolicyCommon(GMM_CACHE_POLICY_ELEMENT *pCachePolicy)
+GmmLib::GmmCachePolicyCommon::GmmCachePolicyCommon(GMM_CACHE_POLICY_ELEMENT *pCachePolicy, Context *pGmmLibContext)
 {
-    this->pCachePolicy = pCachePolicy;
+    this->pCachePolicy   = pCachePolicy;
+    this->pGmmLibContext = pGmmLibContext;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -70,8 +69,8 @@ GMM_GFX_MEMORY_TYPE GmmLib::GmmCachePolicyCommon::GetWantedMemoryType(GMM_CACHE_
 /////////////////////////////////////////////////////////////////////////////////////
 MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetOriginalMemoryObject(GMM_RESOURCE_INFO *pResInfo)
 {
-    MEMORY_OBJECT_CONTROL_STATE MOCS = pGmmGlobalContext->GetCachePolicyElement(GMM_RESOURCE_USAGE_UNKNOWN).MemoryObjectOverride;
-
+    MEMORY_OBJECT_CONTROL_STATE MOCS = pGmmLibContext->GetCachePolicyElement(GMM_RESOURCE_USAGE_UNKNOWN).MemoryObjectOverride;
+   
     if(pResInfo)
     {
         MOCS = pResInfo->GetMOCS();
@@ -94,9 +93,8 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolic
 MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetMemoryObject(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
 {
     const GMM_CACHE_POLICY_ELEMENT *CachePolicy = NULL;
-    __GMM_ASSERT(pGmmGlobalContext->GetCachePolicyElement(Usage).Initialized);
-    CachePolicy = pGmmGlobalContext->GetCachePolicyUsage();
-
+    __GMM_ASSERT(pGmmLibContext->GetCachePolicyElement(Usage).Initialized);
+    CachePolicy = pGmmLibContext->GetCachePolicyUsage();
     // Prevent wrong Usage for XAdapter resources. UMD does not call GetMemoryObject on shader resources but,
     // when they add it someone could call it without knowing the restriction.
     if(pResInfo &&
@@ -129,6 +127,6 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolic
 /////////////////////////////////////////////////////////////////////////////////////
 GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetPteType(GMM_RESOURCE_USAGE_TYPE Usage)
 {
-    __GMM_ASSERT(pGmmGlobalContext->GetCachePolicyElement(Usage).Initialized);
-    return pGmmGlobalContext->GetCachePolicyElement(Usage).PTE;
+    __GMM_ASSERT(pGmmLibContext->GetCachePolicyElement(Usage).Initialized);
+    return pGmmLibContext->GetCachePolicyElement(Usage).PTE;
 }

Source/GmmLib/CachePolicy/GmmCachePolicyConditionals.h

@@ -20,18 +20,18 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 ============================================================================*/
 
-#define PRODUCT(X)  (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) == IGFX_##X)
+#define ISPRODUCT(X)  (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_##X)
 
-#define FROMPRODUCT(X)  (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) >= IGFX_##X)
+#define FROMPRODUCT(X)  (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) >= IGFX_##X)
 
-#define SKU(FtrXxx) (pGmmGlobalContext->GetSkuTable().FtrXxx != 0)
+#define SKU(FtrXxx) (pGmmLibContext->GetSkuTable().FtrXxx != 0)
 
-#define WA(WaXxx)   (pGmmGlobalContext->GetWaTable().WaXxx != 0)
+#define WA(WaXxx)   (pGmmLibContext->GetWaTable().WaXxx != 0)
 
 // Underscored to prevent name collision with the GMM_CACHE_POLICY_ELEMENT fields named L3 and LLC
-#define _L3           (pGmmGlobalContext->GetGtSysInfo()->L3CacheSizeInKb)
-#define _LLC          (pGmmGlobalContext->GetGtSysInfo()->LLCCacheSizeInKb)
-#define _ELLC         (pGmmGlobalContext->GetGtSysInfo()->EdramSizeInKb)
+#define _L3           (pGmmLibContext->GetGtSysInfo()->L3CacheSizeInKb)
+#define _LLC          (pGmmLibContext->GetGtSysInfo()->LLCCacheSizeInKb)
+#define _ELLC         (pGmmLibContext->GetGtSysInfo()->EdramSizeInKb)
 #define CAM$          (SKU(FtrCameraCaptureCaching))
 
 // Units are already in KB in the system information, so these helper macros need to account for that

Source/GmmLib/CachePolicy/GmmGen10CachePolicy.cpp

@@ -67,7 +67,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::InitCachePolicy()
 
         uint32_t                      CurrentMaxIndex        = 0;
         uint32_t                      CurrentMaxHDCL1Index   = GMM_GEN10_HDCL1_MOCS_INDEX_START - 1; // define constant
-        GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = pGmmGlobalContext->GetCachePolicyTlbElement();
+        GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = pGmmLibContext->GetCachePolicyTlbElement();
 
         // index 0 is uncached.
         {
@@ -91,7 +91,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::InitCachePolicy()
             bool                         CachePolicyError = false;
             int32_t                      CPTblIdx         = -1;
             uint32_t                     j                = 0;
-            uint32_t                     PTEValue         = 0;
+            uint64_t                     PTEValue         = 0;
             GMM_CACHE_POLICY_TBL_ELEMENT UsageEle         = {0};
             UsageEle.LeCC.Reserved                        = 0; // Reserved bits zeroe'd, this is so we
                                                                // we can compare the unioned LeCC.DwordValue.
@@ -224,7 +224,8 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::InitCachePolicy()
                 CachePolicyError = true;
             }
 
-            pCachePolicy[Usage].PTE.DwordValue = PTEValue;
+            pCachePolicy[Usage].PTE.DwordValue     = PTEValue & 0xFFFFFFFF;
+            pCachePolicy[Usage].PTE.HighDwordValue = 0;
 
             pCachePolicy[Usage].MemoryObjectOverride.Gen10.Index = CPTblIdx;
 
@@ -254,7 +255,10 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetPATInitWA()
     GMM_STATUS Status = GMM_SUCCESS;
 
 #if(defined(__GMM_KMD__))
-    
+    if(pGmmLibContext->GetGtSysInfoPtr()->EdramSizeInKb)
+    {
+        const_cast<WA_TABLE &>(pGmmLibContext->GetWaTable()).WaNoMocsEllcOnly = 1;
+    }
 #else
     Status = GMM_ERROR;
 #endif
@@ -346,10 +350,9 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
     uint8_t              Age                        = 1;
     uint8_t              ServiceClass               = 0;
     int32_t *            pPrivatePATTableMemoryType = NULL;
-    pPrivatePATTableMemoryType                      = pGmmGlobalContext->GetPrivatePATTableMemoryType();
-
-    __GMM_ASSERT(pGmmGlobalContext->GetSkuTable().FtrIA32eGfxPTEs);
+    pPrivatePATTableMemoryType                      = pGmmLibContext->GetPrivatePATTableMemoryType();
 
+    __GMM_ASSERT(pGmmLibContext->GetSkuTable().FtrIA32eGfxPTEs);
     for(i = 0; i < GMM_NUM_GFX_PAT_TYPES; i++)
     {
         pPrivatePATTableMemoryType[i] = -1;
@@ -360,7 +363,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
     {
         GMM_PRIVATE_PAT PAT = {0};
 
-        if(pGmmGlobalContext->GetWaTable().FtrMemTypeMocsDeferPAT)
+	if(pGmmLibContext->GetWaTable().WaNoMocsEllcOnly)
         {
             GfxTargetCache = GMM_GFX_TC_ELLC_ONLY;
         }
@@ -372,12 +375,12 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
         switch(i)
         {
             case PAT0:
-                if(pGmmGlobalContext->GetWaTable().WaGttPat0)
-                {
-                    if(pGmmGlobalContext->GetWaTable().WaGttPat0WB)
-                    {
+                if(pGmmLibContext->GetWaTable().WaGttPat0)
+		{
+                    if(pGmmLibContext->GetWaTable().WaGttPat0WB)			 
+	            {
                         GfxMemType = GMM_GFX_WB;
-                        if(GFX_IS_ATOM_PLATFORM)
+                        if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
                         {
                             PAT.PreGen10.Snoop = 1;
                         }
@@ -392,7 +395,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
                 else // if GTT is not tied to PAT0 then WaGttPat0WB is NA
                 {
                     GfxMemType = GMM_GFX_WB;
-                    if(GFX_IS_ATOM_PLATFORM)
+                    if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
                     {
                         PAT.PreGen10.Snoop = 1;
                     }
@@ -401,10 +404,10 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
                 break;
 
             case PAT1:
-                if(pGmmGlobalContext->GetWaTable().WaGttPat0 && !pGmmGlobalContext->GetWaTable().WaGttPat0WB)
+                if(pGmmLibContext->GetWaTable().WaGttPat0 && !pGmmLibContext->GetWaTable().WaGttPat0WB)		
                 {
                     GfxMemType = GMM_GFX_WB;
-                    if(GFX_IS_ATOM_PLATFORM)
+                    if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
                     {
                         PAT.PreGen10.Snoop = 1;
                     }
@@ -460,4 +463,4 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
     Status = GMM_ERROR;
 #endif
     return Status;
-}
+}

Source/GmmLib/CachePolicy/GmmGen10CachePolicy.h

@@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define FBLLC (SKU(FtrFrameBufferLLC))
 
 //eDRAM-Only caching, for a usage that might be encrypted, must use ENCRYPTED_PARTIALS_EDRAM
-#define ENCRYPTED_PARTIALS_EDRAM (EDRAM && !(pGmmGlobalContext->GetWaTable().WaEncryptedEdramOnlyPartials))
+#define ENCRYPTED_PARTIALS_EDRAM (EDRAM && !(pGmmLibContext->GetWaTable().WaEncryptedEdramOnlyPartials))
 
 // Cache Policy Definition
 // AOM = Do not allocate on miss (0 = allocate on miss [normal cache behavior], 1 = don't allocate on miss)