DG1 Upstream
First patch for DG1 Unembargoed
Change-Id: I43b4f47bba2b6c672af920e13bcd58a4c18ac22b
diff --git a/Source/GmmLib/CMakeLists.txt b/Source/GmmLib/CMakeLists.txt
index 2007073..cc655be 100644
--- a/Source/GmmLib/CMakeLists.txt
+++ b/Source/GmmLib/CMakeLists.txt
@@ -177,11 +177,13 @@
${BS_DIR_GMMLIB}/CachePolicy/GmmGen10CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen11CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen12CachePolicy.h
+ ${BS_DIR_GMMLIB}/CachePolicy/GmmGen12dGPUCachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen8CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen9CachePolicy.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen10.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen11.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen12.h
+ ${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen8.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen9.h
${BS_DIR_GMMLIB}/inc/External/Common/GmmCachePolicy.h
@@ -243,6 +245,7 @@
${BS_DIR_GMMLIB}/CachePolicy/GmmGen10CachePolicy.cpp
${BS_DIR_GMMLIB}/CachePolicy/GmmGen11CachePolicy.cpp
${BS_DIR_GMMLIB}/CachePolicy/GmmGen12CachePolicy.cpp
+ ${BS_DIR_GMMLIB}/CachePolicy/GmmGen12dGPUCachePolicy.cpp
${BS_DIR_GMMLIB}/Platform/GmmGen11Platform.cpp
${BS_DIR_GMMLIB}/Platform/GmmGen12Platform.cpp
${BS_DIR_GMMLIB}/Platform/GmmGen8Platform.cpp
@@ -286,6 +289,7 @@
${BS_DIR_GMMLIB}/CachePolicy/GmmGen10CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen11CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen12CachePolicy.h
+ ${BS_DIR_GMMLIB}/CachePolicy/GmmGen12dGPUCachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen8CachePolicy.h
${BS_DIR_GMMLIB}/CachePolicy/GmmGen9CachePolicy.h
)
@@ -347,6 +351,7 @@
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen10.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen11.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen12.h
+ ${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen8.h
${BS_DIR_GMMLIB}/inc/External/Common/CachePolicy/GmmCachePolicyGen9.h
)
diff --git a/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.cpp b/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.cpp
new file mode 100644
index 0000000..460bc70
--- /dev/null
+++ b/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.cpp
@@ -0,0 +1,328 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+
+
+#include "Internal/Common/GmmLibInc.h"
+#include "External/Common/GmmCachePolicy.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen10.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen11.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen12.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h"
+
+//=============================================================================
+//
+// Function: IsSpecialMOCSUsage
+//
+// Desc: This function returns special(hw-reserved) MocsIdx based on usage
+//
+// Parameters: usage -> Resource usage type
+// UpdateMOCS -> True if MOCS Table must be updated, ow false
+//
+// Return: int32_t
+//
+//-----------------------------------------------------------------------------
+int32_t GmmLib::GmmGen12dGPUCachePolicy::IsSpecialMOCSUsage(GMM_RESOURCE_USAGE_TYPE Usage, bool &UpdateMOCS)
+{
+ int32_t MocsIdx = -1;
+ UpdateMOCS = true;
+
+ switch(Usage)
+ {
+ case GMM_RESOURCE_USAGE_CCS:
+ __GMM_ASSERT(pCachePolicy[Usage].L3 == 0) //Architecturally, CCS isn't L3-cacheable.
+ MocsIdx = 60;
+ break;
+ case GMM_RESOURCE_USAGE_MOCS_62:
+ __GMM_ASSERT(pCachePolicy[Usage].L3 == 0); //Architecturally, TR/Aux-TT node isn't L3-cacheable.
+ MocsIdx = 62;
+ break;
+ case GMM_RESOURCE_USAGE_L3_EVICTION:
+ MocsIdx = 63;
+ break;
+ case GMM_RESOURCE_USAGE_L3_EVICTION_SPECIAL:
+ case GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE:
+ MocsIdx = 61;
+ break;
+ default:
+ UpdateMOCS = false;
+ break;
+ }
+
+ return MocsIdx;
+}
+
+//=============================================================================
+//
+// Function: __GmmGen12dGPUInitCachePolicy
+//
+// Desc: This function initializes the cache policy
+//
+// Parameters: pCachePolicy -> Ptr to array to be populated with the
+// mapping of usages -> cache settings.
+//
+// Return: GMM_STATUS
+//
+//-----------------------------------------------------------------------------
+GMM_STATUS GmmLib::GmmGen12dGPUCachePolicy::InitCachePolicy()
+{
+
+ __GMM_ASSERTPTR(pCachePolicy, GMM_ERROR);
+
+#define DEFINE_CACHE_ELEMENT(usage, l3, l3_scc, hdcl1) DEFINE_CP_ELEMENT(usage, 0, 0, l3, 0, 0, 0, 0, l3_scc, 0, 0, 0, hdcl1, 0, 0, 0, 0)
+
+#include "GmmGen12dGPUCachePolicy.h"
+
+#define L3_UNCACHEABLE (0x1)
+#define L3_WB_CACHEABLE (0x3)
+
+#define DISABLE_SKIP_CACHING_CONTROL (0x0)
+#define ENABLE_SKIP_CACHING_CONTROL (0x1)
+
+#define DISABLE_SELF_SNOOP_OVERRIDE (0x0)
+#define CLASS_SERVICE_ZERO (0x0)
+#define GMM_GEN12_MAX_NUMBER_MOCS_INDEXES (60) // On TGL last four (#60-#63) are reserved by h/w, few? are sw configurable though (#60)
+ {
+ SetUpMOCSTable();
+ }
+
+ {
+ // Define index of cache element
+ uint32_t Usage = 0;
+
+#if(_WIN32 && (_DEBUG || _RELEASE_INTERNAL))
+ void *pKmdGmmContext = NULL;
+#if(defined(__GMM_KMD__))
+ pKmdGmmContext = pGmmGlobalContext->GetGmmKmdContext();
+#endif
+
+ OverrideCachePolicy(pKmdGmmContext);
+#endif
+
+ // Process the cache policy and fill in the look up table
+ for(; Usage < GMM_RESOURCE_USAGE_MAX; Usage++)
+ {
+ bool CachePolicyError = false;
+ bool SpecialMOCS = false;
+ int32_t CPTblIdx = -1;
+ uint32_t j = 0;
+ uint32_t PTEValue = 0;
+ GMM_CACHE_POLICY_TBL_ELEMENT UsageEle = {0};
+ uint32_t StartMocsIdx = 0;
+
+ switch(GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform))
+ {
+ case IGFX_DG1:
+ StartMocsIdx = 1; // Index 0 is reserved for Error
+ break;
+ default:
+ StartMocsIdx = 1;
+ break;
+ }
+
+ // No Special MOCS handling for next platform
+ if(GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) <= IGFX_DG1)
+ {
+ CPTblIdx = IsSpecialMOCSUsage((GMM_RESOURCE_USAGE_TYPE)Usage, SpecialMOCS);
+ }
+
+ // Applicable upto only
+ if(pCachePolicy[Usage].HDCL1 &&
+ (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) <= IGFX_DG1))
+ {
+ UsageEle.HDCL1 = 1;
+ }
+
+ UsageEle.L3.Reserved = 0; // Reserved bits zeroe'd, this is so we
+ // we can compare the unioned L3.UshortValue.
+ UsageEle.L3.ESC = DISABLE_SKIP_CACHING_CONTROL;
+ UsageEle.L3.SCC = 0;
+ UsageEle.L3.Cacheability = pCachePolicy[Usage].L3 ? L3_WB_CACHEABLE : L3_UNCACHEABLE;
+
+ if(pCachePolicy[Usage].L3_SCC)
+ {
+ UsageEle.L3.ESC = ENABLE_SKIP_CACHING_CONTROL;
+ UsageEle.L3.SCC = (uint16_t)pCachePolicy[Usage].L3_SCC;
+ }
+
+ //Special-case MOCS handling for MOCS Table Index 60-63
+ if(CPTblIdx >= GMM_GEN12_MAX_NUMBER_MOCS_INDEXES)
+ {
+ GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmGlobalContext->GetCachePolicyTlbElement()[CPTblIdx];
+
+ if(SpecialMOCS &&
+ !(TblEle->L3.UshortValue == UsageEle.L3.UshortValue))
+ {
+ //Assert if being overwritten!
+ __GMM_ASSERT(TblEle->L3.UshortValue == 0);
+
+ }
+ }
+ //For HDC L1 caching, MOCS Table index 48-59 should be used
+ else if(UsageEle.HDCL1)
+ {
+ for(j = GMM_GEN10_HDCL1_MOCS_INDEX_START; j <= CurrentMaxL1HdcMocsIndex; j++)
+ {
+ GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmGlobalContext->GetCachePolicyTlbElement()[j];
+ if(TblEle->L3.UshortValue == UsageEle.L3.UshortValue &&
+ TblEle->HDCL1 == UsageEle.HDCL1)
+ {
+ CPTblIdx = j;
+ break;
+ }
+ }
+ }
+ else
+ {
+ for(j = StartMocsIdx; j <= CurrentMaxMocsIndex; j++)
+ {
+ if(pCachePolicy[Usage].L3 == 0)
+ {
+ CPTblIdx = StartMocsIdx;
+ break;
+ }
+ else
+ {
+ GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmGlobalContext->GetCachePolicyTlbElement()[j];
+ if(TblEle->L3.UshortValue == UsageEle.L3.UshortValue)
+ {
+ CPTblIdx = j;
+ break;
+ }
+ }
+ }
+ }
+
+ // Didn't find the caching settings in one of the already programmed lookup table entries.
+ // Need to add a new lookup table entry.
+ if(CPTblIdx == -1)
+ {
+
+ {
+ GMM_ASSERTDPF(false, "CRITICAL ERROR: Cache Policy Usage value specified by Client is not defined in Fixed MOCS Table!");
+
+ CachePolicyError = true;
+ GMM_ASSERTDPF(
+ "Cache Policy Init Error: Invalid Cache Programming, too many unique caching combinations"
+ "(we only support GMM_GEN_MAX_NUMBER_MOCS_INDEXES = %d)",
+ CurrentMaxMocsIndex);
+
+ // Set cache policy index to uncached.
+ CPTblIdx = StartMocsIdx;
+ }
+ }
+
+ // PTE entries do not control caching on SKL+ (for legacy context)
+ if(!GetUsagePTEValue(pCachePolicy[Usage], Usage, &PTEValue))
+ {
+ CachePolicyError = true;
+ }
+
+ pCachePolicy[Usage].PTE.DwordValue = PTEValue;
+
+ pCachePolicy[Usage].MemoryObjectOverride.Gen12.Index = CPTblIdx;
+
+ pCachePolicy[Usage].Override = ALWAYS_OVERRIDE;
+
+ if(CachePolicyError)
+ {
+ GMM_ASSERTDPF("Cache Policy Init Error: Invalid Cache Programming - Element %d", Usage);
+ }
+ }
+ }
+
+ return GMM_SUCCESS;
+}
+
+#pragma optimize("", on)
+//=============================================================================
+//
+// Function: SetUpMOCSTable
+//
+// Desc: For Gen12dGPU, Define new Fixed MOCS table
+//
+// Parameters:
+//
+// Return: GMM_STATUS
+//
+//-----------------------------------------------------------------------------
+void GmmLib::GmmGen12dGPUCachePolicy::SetUpMOCSTable()
+{
+ GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = &(pGmmGlobalContext->GetCachePolicyTlbElement()[0]);
+ CurrentMaxL1HdcMocsIndex = 0;
+ CurrentMaxSpecialMocsIndex = 0;
+
+#define GMM_DEFINE_MOCS(Index, L3_ESC, L3_SCC, L3_CC, _HDCL1) \
+ { \
+ pCachePolicyTlbElement[Index].L3.ESC = L3_ESC; \
+ pCachePolicyTlbElement[Index].L3.SCC = L3_SCC; \
+ pCachePolicyTlbElement[Index].L3.Cacheability = L3_CC; \
+ pCachePolicyTlbElement[Index].LeCC.Cacheability = 1; \
+ pCachePolicyTlbElement[Index].LeCC.TargetCache = 0; \
+ pCachePolicyTlbElement[Index].LeCC.LRUM = 0; \
+ pCachePolicyTlbElement[Index].LeCC.AOM = 0; \
+ pCachePolicyTlbElement[Index].LeCC.ESC = 0; \
+ pCachePolicyTlbElement[Index].LeCC.SCC = 0; \
+ pCachePolicyTlbElement[Index].LeCC.PFM = 0; \
+ pCachePolicyTlbElement[Index].LeCC.SCF = 0; \
+ pCachePolicyTlbElement[Index].LeCC.CoS = CLASS_SERVICE_ZERO; \
+ pCachePolicyTlbElement[Index].LeCC.SelfSnoop = DISABLE_SELF_SNOOP_OVERRIDE; \
+ pCachePolicyTlbElement[Index].HDCL1 = _HDCL1; \
+ }
+
+ // clang-format off
+
+ if (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) == IGFX_DG1)
+ {
+ //Default MOCS Table
+ for(int index = 0; index < GMM_MAX_NUMBER_MOCS_INDEXES; index++)
+ { // Index ESC SCC L3CC HDCL1
+ GMM_DEFINE_MOCS( index , 0 , 0 , 3 , 0 )
+ }
+ // Fixed MOCS Table
+ // Index ESC SCC L3CC HDCL1
+ GMM_DEFINE_MOCS( 0 , 0 , 0 , 1 , 0 )
+ GMM_DEFINE_MOCS( 1 , 0 , 0 , 1 , 0 )
+ GMM_DEFINE_MOCS( 2 , 0 , 0 , 0 , 0 )
+ GMM_DEFINE_MOCS( 3 , 0 , 0 , 0 , 0 )
+ GMM_DEFINE_MOCS( 4 , 0 , 0 , 0 , 0 )
+ GMM_DEFINE_MOCS( 5 , 0 , 0 , 3 , 0 )
+ GMM_DEFINE_MOCS( 6 , 1 , 1 , 3 , 0 )
+ GMM_DEFINE_MOCS( 7 , 1 , 3 , 3 , 0 )
+ GMM_DEFINE_MOCS( 8 , 1 , 7 , 3 , 0 )
+ GMM_DEFINE_MOCS( 48 , 0 , 0 , 3 , 1 )
+ GMM_DEFINE_MOCS( 49 , 0 , 0 , 1 , 1 )
+ GMM_DEFINE_MOCS( 60 , 0 , 0 , 1 , 0 )
+ GMM_DEFINE_MOCS( 61 , 0 , 0 , 1 , 0 )
+ GMM_DEFINE_MOCS( 62 , 0 , 0 , 1 , 0 )
+ GMM_DEFINE_MOCS( 63 , 0 , 0 , 1 , 0 )
+
+ CurrentMaxMocsIndex = 8;
+ CurrentMaxL1HdcMocsIndex = 49;
+ CurrentMaxSpecialMocsIndex = 63;
+
+ }
+
+// clang-format on
+
+
+#undef GMM_DEFINE_MOCS
+}
diff --git a/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.h b/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.h
new file mode 100644
index 0000000..5b242a5
--- /dev/null
+++ b/Source/GmmLib/CachePolicy/GmmGen12dGPUCachePolicy.h
@@ -0,0 +1,284 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+
+
+#include "GmmCachePolicyConditionals.h"
+
+#define EDRAM (SKU(FtrEDram))
+#define FBLLC (SKU(FtrFrameBufferLLC))
+
+// Cache Policy Definition
+// L3_SCC = L3 skip caching control (disabled if L3_SCC = 0)
+// HDCL1 = HDC L1 cache control (1 = cached in HDC L1, 0 = not cached in HDC L1)
+// Faster PushWrite(Gen10+) used iff !WT, eLLC-only cacheable - Globally visible surface (eg display surface) should be marked WT
+//**************************************************************************************************************************************************/
+// USAGE TYPE , L3 , L3_SCC, HDCL1)
+/***************************************************************************************************************************************************/
+
+// KMD Usages
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_BATCH_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_COMP_FRAME_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CONTEXT_SWITCH_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CURSOR , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DISPLAY_STATIC_IMG_FOR_SMOOTH_ROTATION_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DUMMY_PAGE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_GDI_SURFACE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_GENERIC_KMD_RESOURCE , 0 , 0 , 0);
+// GMM_RESOURCE_USAGE_GFX_RING is only used if WaEnableRingHostMapping is enabled.
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_GFX_RING , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_GTT_TRANSFER_REGION , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HW_CONTEXT , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STATE_MANAGER_KERNEL_STATE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_KMD_STAGING_SURFACE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MBM_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_NNDI_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OVERLAY_MBM , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PRIMARY_SURFACE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SCREEN_PROTECTION_INTERMEDIATE_SURFACE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SHADOW_SURFACE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SM_SCRATCH_STATE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STATUS_PAGE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TIMER_PERF_QUEUE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_UNKNOWN , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_UNMAP_PAGING_RESERVED_GTT_DMA_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VSC_BATCH_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_WA_BATCH_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_KMD_OCA_BUFFER , 0 , 0 , 0);
+
+//
+// 3D Usages
+//
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_UMD_BATCH_BUFFER , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_BINDING_TABLE_POOL , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CCS , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CONSTANT_BUFFER_POOL , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DEPTH_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DISPLAYABLE_RENDER_TARGET , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_GATHER_POOL , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_SURFACE_STATE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_DYNAMIC_STATE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_GENERAL_STATE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_GENERAL_STATE_UC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_STATELESS_DATA_PORT , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_INDIRECT_OBJECT , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HEAP_INSTRUCTION , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HIZ , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_INDEX_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_INDEX_BUFFER_L3_COHERENT_UC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_INDEX_BUFFER_L3_CACHED , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MCS , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PUSH_CONSTANT_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PULL_CONSTANT_BUFFER , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_QUERY , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_RENDER_TARGET , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SHADER_RESOURCE , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STAGING , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STENCIL_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STREAM_OUTPUT_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILE_POOL , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SHADER_RESOURCE_LLC_BYPASS , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MOCS_62 , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_L3_EVICTION , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_L3_EVICTION_SPECIAL , 0 , 0 , 0);
+
+// Tiled Resource
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_DEPTH_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_HIZ , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_MCS , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_CCS , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_RENDER_TARGET , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_RENDER_TARGET_AND_SHADER_RESOURCE , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_SHADER_RESOURCE , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILED_UAV , 1 , 0 , 0);
+
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_UAV , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VERTEX_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VERTEX_BUFFER_L3_COHERENT_UC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VERTEX_BUFFER_L3_CACHED , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OGL_WSTN_VERTEX_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_POSH_VERTEX_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_RENDER_TARGET_AND_SHADER_RESOURCE , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_WDDM_HISTORY_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CONTEXT_SAVE_RESTORE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PTBR_PAGE_POOL , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PTBR_BATCH_BUFFER , 1 , 0 , 0);
+
+//
+// CM USAGES
+//
+// USAGE TYPE , L3 , L3_SCC, HDCL1)
+DEFINE_CACHE_ELEMENT(CM_RESOURCE_USAGE_SurfaceState, 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(CM_RESOURCE_USAGE_L1_Enabled_SurfaceState, 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(CM_RESOURCE_USAGE_StateHeap, 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(CM_RESOURCE_USAGE_NO_L3_SurfaceState, 0 , 0 , 1);
+DEFINE_CACHE_ELEMENT(CM_RESOURCE_USAGE_NO_CACHE_SurfaceState, 0 , 0 , 0);
+
+//
+// MP USAGES
+//
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_BEGIN, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_DEFAULT, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_DEFAULT_FF, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_DEFAULT_RCS, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_SurfaceState, 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_SurfaceState_FF, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_SurfaceState_RCS, 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MP_RESOURCE_USAGE_END, 0 , 0 , 0);
+
+// MHW - SFC
+DEFINE_CACHE_ELEMENT(MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface, 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface, 0 , 0 , 0);
+
+//Media GMM Resource USAGES
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_POST_DEBLOCKING_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_STREAMOUT_DATA_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MACROBLOCK_STATUS_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_BITPLANE_READ_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_AACSBIT_VECTOR_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_CURR_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_REF_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_FF , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE_DST , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PAK_OBJECT_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_FLATNESS_CHECK_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MBENC_CURBE_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VDENC_STREAMIN_CODEC , 0 , 0 , 0);
+
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_MD_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_SAO_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_MV_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC , 0 , 0 , 0);
+
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SSE_SRC_PIXEL_ROW_STORE_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SLICE_STATE_STREAM_OUT_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CABAC_SYNTAX_STREAM_OUT_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PRED_COL_STORE_BUFFER_CODEC , 0 , 0 , 0);
+
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_UNCACHED , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ELLC_ONLY , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_ONLY , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ELLC_LLC_L3 , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE , 0 , 0 , 0);
+
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_BRC_HISTORY_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_SOFTWARE_SCOREBOARD_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MV_DISTORTION_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_4XME_DISTORTION_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_INTRA_DISTORTION_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MB_STATS_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_PAK_STATS_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_READ_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_PIC_STATE_WRITE_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_COMBINED_ENC_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_BRC_CONSTANT_DATA_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_INTERMEDIATE_CU_RECORD_SURFACE_ENCODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_SCRATCH_ENCODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_LCU_LEVEL_DATA_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_INPUT_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_HISTORY_OUTPUT_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_DEBUG_ENCODE , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_CONSTANT_TABLE_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_CU_RECORD_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_MV_TEMPORAL_BUFFER_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_CU_PACKET_FOR_PAK_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED1_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_ENC_BCOMBINED2_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_FRAME_STATS_STREAMOUT_DATA_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_LINE_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_TILE_COLUMN_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_MD_TILE_LINE_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_MD_TILE_COLUMN_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_SAO_TILE_LINE_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HCP_SAO_TILE_COLUMN_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_VP9_PROBABILITY_COUNTER_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_HUC_VIRTUAL_ADDR_REGION_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SIZE_STREAMOUT_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_COMPRESSED_HEADER_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_PROBABILITY_DELTA_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILE_RECORD_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_TILE_SIZE_STAS_BUFFER_CODEC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MAD_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_PAK_IMAGESTATE_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MBENC_BRC_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_MB_BRC_CONST_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_BRC_MB_QP_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_BRC_ROI_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_MBDISABLE_SKIPMAP_CODEC , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_SLICE_MAP_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_WP_DOWNSAMPLED_ENCODE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE , 0 , 0 , 0);
+
+/**********************************************************************************/
+
+//
+// OCL Usages
+//
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_BUFFER_CSR_UC , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_IMAGE , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_INLINE_CONST , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_INLINE_CONST_HDC , 1 , 0 , 1);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_SCRATCH , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_PRIVATE_MEM , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_PRINTF_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER_CACHELINE_MISALIGNED , 0 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_ISH_HEAP_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_TAG_MEMORY_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_TEXTURE_BUFFER , 1 , 0 , 0);
+DEFINE_CACHE_ELEMENT(GMM_RESOURCE_USAGE_OCL_SELF_SNOOP_BUFFER , 1 , 0 , 0);
+/**********************************************************************************/
+
+// Cross Adapter
+DEFINE_CACHE_ELEMENT( GMM_RESOURCE_USAGE_XADAPTER_SHARED_RESOURCE , 0 , 0 , 0);
+/**********************************************************************************/
+
+#include "GmmCachePolicyUndefineConditionals.h"
+
diff --git a/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp b/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp
index a2fbd4e..1cc87d3 100644
--- a/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp
+++ b/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp
@@ -52,6 +52,20 @@
Ignore64KBPadding = true;
}
+ if(pGmmGlobalContext->GetSkuTable().FtrLocalMemory)
+ {
+ Ignore64KBPadding |= (Surf.Flags.Info.NonLocalOnly || (Surf.Flags.Info.Shared && !Surf.Flags.Info.NotLockable));
+ }
+ else
+ {
+ // The final padded size cannot be larger then a set percentage of the original size
+ if((Surf.Flags.Info.NoOptimizationPadding && !GFX_IS_ALIGNED(Size, GMM_KBYTE(64))) /*Surface is not 64kb aligned*/ ||
+ (!Surf.Flags.Info.NoOptimizationPadding && (((Size * (100 + pGmmGlobalContext->GetAllowedPaddingFor64KbPagesPercentage())) / 100) < GFX_ALIGN(Size, GMM_KBYTE(64)))) /*10% padding TBC */)
+ {
+ Ignore64KBPadding |= true;
+ }
+ }
+
// If 64KB paging is enabled pad out the resource to 64KB alignment
if(pGmmGlobalContext->GetSkuTable().FtrWddm2_1_64kbPages &&
// Ignore the padding for the above VirtualPadding or ESM cases
@@ -62,13 +76,7 @@
(Surf.Alignment.BaseAlignment == GMM_KBYTE(32)) ||
(Surf.Alignment.BaseAlignment == GMM_KBYTE(16)) ||
(Surf.Alignment.BaseAlignment == GMM_KBYTE(8)) ||
- (Surf.Alignment.BaseAlignment == GMM_KBYTE(4))) &&
- // The final padded size cannot be larger then a set percentage of the original size
- ((!Surf.Flags.Info.NoOptimizationPadding &&
- ((Size * (100 + pGmmGlobalContext->GetAllowedPaddingFor64KbPagesPercentage())) / 100) >= GFX_ALIGN(Size, GMM_KBYTE(64))) ||
- (Surf.Flags.Info.NoOptimizationPadding && GFX_IS_ALIGNED(Size, GMM_KBYTE(64))))
-
- )
+ (Surf.Alignment.BaseAlignment == GMM_KBYTE(4))))
{
return 1;
}
@@ -336,6 +344,11 @@
}
}
+ if(Is64KBPageSuitable() && pGmmGlobalContext->GetSkuTable().FtrLocalMemory)
+ {
+ Surf.Alignment.BaseAlignment = GMM_KBYTE(64);
+ }
+
GMM_DPF_EXIT;
return GMM_SUCCESS;
diff --git a/Source/GmmLib/Resource/GmmResourceInfoCommonEx.cpp b/Source/GmmLib/Resource/GmmResourceInfoCommonEx.cpp
index 8020f53..afe33c3 100644
--- a/Source/GmmLib/Resource/GmmResourceInfoCommonEx.cpp
+++ b/Source/GmmLib/Resource/GmmResourceInfoCommonEx.cpp
@@ -347,6 +347,57 @@
goto ERROR_CASE;
}
+
+ if(pGmmGlobalContext->GetSkuTable().FtrLocalMemory)
+ {
+ GMM_ASSERTDPF(((Surf.Flags.Info.NonLocalOnly && Surf.Flags.Info.LocalOnly) == 0),
+ "Incorrect segment preference, cannot be both local and system memory.");
+
+ if(Surf.Flags.Gpu.Overlay ||
+ Surf.Flags.Gpu.FlipChain)
+ {
+ if(Surf.Flags.Info.NonLocalOnly)
+ {
+ GMM_ASSERTDPF(0, "Overlay and FlipChain cannot be in system memory.");
+ goto ERROR_CASE;
+ }
+ Surf.Flags.Info.LocalOnly = 1;
+ Surf.Flags.Info.NonLocalOnly = 0;
+ }
+
+ if(!Surf.Flags.Info.NotLockable &&
+ Surf.Flags.Info.Shared)
+ {
+ if(Surf.Flags.Info.LocalOnly)
+ {
+ GMM_ASSERTDPF(0, "Lockable Shared cannot be in local memory.");
+ goto ERROR_CASE;
+ }
+ Surf.Flags.Info.LocalOnly = 0;
+ Surf.Flags.Info.NonLocalOnly = 1;
+ }
+
+ if(Surf.Flags.Gpu.CameraCapture)
+ {
+ if(Surf.Flags.Info.LocalOnly)
+ {
+ GMM_ASSERTDPF(0, "CameraCapture cannot be in local memory.");
+ }
+ Surf.Flags.Info.LocalOnly = 0;
+ Surf.Flags.Info.NonLocalOnly = 1;
+ }
+
+ if(!Surf.Flags.Info.NonLocalOnly &&
+ (!pGmmGlobalContext->GetSkuTable().FtrLocalMemoryAllows4KB))
+ {
+ Surf.Flags.Info.LocalOnly = true;
+ }
+ }
+ else
+ {
+ Surf.Flags.Info.LocalOnly = false; //Zero out on iGPU
+ }
+
if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) < IGFX_GEN8_CORE) &&
Surf.Flags.Info.TiledW)
{
diff --git a/Source/GmmLib/ULT/CMakeLists.txt b/Source/GmmLib/ULT/CMakeLists.txt
index e5c2f21..bc9b093 100644
--- a/Source/GmmLib/ULT/CMakeLists.txt
+++ b/Source/GmmLib/ULT/CMakeLists.txt
@@ -28,7 +28,9 @@
GmmGen11CachePolicyULT.h
GmmGen11ResourceULT.h
GmmGen12ResourceULT.h
+ GmmGen12dGPUResourceULT.h
GmmGen12CachePolicyULT.h
+ GmmGen12dGPUCachePolicyULT.h
GmmGen9CachePolicyULT.h
GmmGen9ResourceULT.h
GmmResourceULT.h
@@ -44,8 +46,10 @@
GmmGen10ResourceULT.cpp
GmmGen11CachePolicyULT.cpp
GmmGen12CachePolicyULT.cpp
+ GmmGen12dGPUCachePolicyULT.cpp
GmmGen11ResourceULT.cpp
GmmGen12ResourceULT.cpp
+ GmmGen12dGPUResourceULT.cpp
GmmGen9CachePolicyULT.cpp
GmmGen9ResourceULT.cpp
GmmResourceCpuBltULT.cpp
@@ -61,13 +65,14 @@
GmmGen10CachePolicyULT.cpp
GmmGen11CachePolicyULT.cpp
GmmGen12CachePolicyULT.cpp
+ GmmGen12dGPUCachePolicyULT.cpp
)
source_group("Source Files\\Resource" FILES
GmmGen10ResourceULT.cpp
GmmGen11ResourceULT.cpp
GmmGen12ResourceULT.cpp
-
+ GmmGen12dGPUResourceULT.cpp
GmmGen9ResourceULT.cpp
GmmResourceCpuBltULT.cpp
GmmResourceULT.cpp
@@ -86,6 +91,7 @@
GmmGen10CachePolicyULT.h
GmmGen11CachePolicyULT.h
GmmGen12CachePolicyULT.h
+ GmmGen12dGPUCachePolicyULT.h
GmmGen9CachePolicyULT.h
)
@@ -93,6 +99,7 @@
GmmGen10ResourceULT.h
GmmGen11ResourceULT.h
GmmGen12ResourceULT.h
+ GmmGen12dGPUResourceULT.h
GmmGen9ResourceULT.h
GmmResourceULT.h
)
diff --git a/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.cpp b/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.cpp
new file mode 100644
index 0000000..a19b76c
--- /dev/null
+++ b/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.cpp
@@ -0,0 +1,167 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+
+#include "GmmGen12dGPUCachePolicyULT.h"
+
+using namespace std;
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// Sets up common environment for Cache Policy fixture tests. this is called once per
+/// test case before executing all tests under resource fixture test case.
+/// It also calls SetupTestCase from CommonULT to initialize global context and others.
+///
+/////////////////////////////////////////////////////////////////////////////////////
+void CTestGen12dGPUCachePolicy::SetUpTestCase()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// cleans up once all the tests finish execution. It also calls TearDownTestCase
+/// from CommonULT to destroy global context and others.
+///
+/////////////////////////////////////////////////////////////////////////////////////
+void CTestGen12dGPUCachePolicy::TearDownTestCase()
+{
+}
+
+void CTestGen12dGPUCachePolicy::SetUpGen12dGPUVariant(PRODUCT_FAMILY platform)
+{
+ printf("%s\n", __FUNCTION__);
+
+ GfxPlatform.eProductFamily = platform;
+
+ GfxPlatform.eRenderCoreFamily = IGFX_GEN12_CORE;
+
+ pGfxAdapterInfo = (ADAPTER_INFO *)malloc(sizeof(ADAPTER_INFO));
+ if(pGfxAdapterInfo)
+ {
+ memset(pGfxAdapterInfo, 0, sizeof(ADAPTER_INFO));
+
+ pGfxAdapterInfo->SkuTable.FtrLinearCCS = 1; //legacy y =>0 - test both
+ pGfxAdapterInfo->SkuTable.FtrStandardMipTailFormat = 1;
+ pGfxAdapterInfo->SkuTable.FtrTileY = 1;
+ pGfxAdapterInfo->SkuTable.FtrLocalMemory = 1;
+ CommonULT::SetUpTestCase();
+ }
+}
+
+void CTestGen12dGPUCachePolicy::TearDownGen12dGPUVariant()
+{
+ printf("%s\n", __FUNCTION__);
+
+ CommonULT::TearDownTestCase();
+}
+
+TEST_F(CTestGen12dGPUCachePolicy, TestGen12dGPU_DG1CachePolicy)
+{
+ SetUpGen12dGPUVariant(IGFX_DG1);
+
+ CheckL3Gen12dGPUCachePolicy();
+
+ TearDownGen12dGPUVariant();
+}
+
+void CTestGen12dGPUCachePolicy::CheckSpecialMocs(uint32_t Usage,
+ uint32_t AssignedMocsIdx,
+ GMM_CACHE_POLICY_ELEMENT ClientRequest)
+{
+ if(Usage == GMM_RESOURCE_USAGE_CCS) //60
+ {
+ EXPECT_EQ(AssignedMocsIdx, 60) << "Usage# " << Usage << ": Incorrect Index for CCS";
+ EXPECT_EQ(0, ClientRequest.L3) << "Usage# " << Usage << ": Incorrect L3 cacheability for CCS";
+ }
+ else if(Usage == GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE) // 61
+ {
+ EXPECT_EQ(AssignedMocsIdx, 61) << "Usage# " << Usage << ": Incorrect Index for CCS";
+ EXPECT_EQ(0, ClientRequest.L3) << "Usage# " << Usage << ": Incorrect L3 cacheability for CCS";
+ }
+ else if(Usage == GMM_RESOURCE_USAGE_MOCS_62) //62
+ {
+ EXPECT_EQ(AssignedMocsIdx, 62) << "Usage# " << Usage << ": Incorrect Index for MOCS_62";
+ EXPECT_EQ(0, ClientRequest.L3) << "Usage# " << Usage << ": Incorrect L3 cacheability for MOCS#62";
+ }
+}
+
+void CTestGen12dGPUCachePolicy::CheckMocsIdxHDCL1(uint32_t Usage,
+ uint32_t AssignedMocsIdx,
+ GMM_CACHE_POLICY_ELEMENT ClientRequest)
+{
+#define GMM_GEN12_MAX_NUMBER_MOCS_INDEXES (60) // On TGL last four (#60-#63) are reserved by h/w, few? are sw configurable though (#60)
+
+ // Check of assigned Index setting is appropriate for HDCL1 setting
+ if(ClientRequest.HDCL1)
+ {
+ EXPECT_GE(AssignedMocsIdx, GMM_GEN10_HDCL1_MOCS_INDEX_START) << "Usage# " << Usage << ": Index must be greater than " << GMM_GEN10_HDCL1_MOCS_INDEX_START - 1 << " for HDCL1 setting. AssignedMocs: " << AssignedMocsIdx;
+ EXPECT_LT(AssignedMocsIdx, GMM_GEN12_MAX_NUMBER_MOCS_INDEXES) << "Usage# " << Usage << ": Index must be less than " << GMM_GEN12_MAX_NUMBER_MOCS_INDEXES << "for HDCL1 setting";
+ }
+ else if(AssignedMocsIdx < GMM_GEN12_MAX_NUMBER_MOCS_INDEXES)
+ {
+ EXPECT_LT(AssignedMocsIdx, GMM_GEN10_HDCL1_MOCS_INDEX_START) << "Usage# " << Usage << ": Incorrect Index for HDCL1 setting";
+ }
+}
+
+void CTestGen12dGPUCachePolicy::CheckL3Gen12dGPUCachePolicy()
+{
+ const uint32_t L3_WB_CACHEABLE = 0x3;
+ const uint32_t L3_UNCACHEABLE = 0x1;
+
+ // Check Usage MOCS index against MOCS settings
+ for(uint32_t Usage = GMM_RESOURCE_USAGE_UNKNOWN; Usage < GMM_RESOURCE_USAGE_MAX; Usage++)
+ {
+ GMM_CACHE_POLICY_ELEMENT ClientRequest = pGmmULTClientContext->GetCachePolicyElement((GMM_RESOURCE_USAGE_TYPE)Usage);
+ uint32_t AssignedMocsIdx = ClientRequest.MemoryObjectOverride.Gen12.Index;
+ GMM_CACHE_POLICY_TBL_ELEMENT Mocs = pGmmULTClientContext->GetCachePolicyTlbElement(AssignedMocsIdx);
+ uint32_t StartMocsIdx = 1;
+
+ //printf("Usage: %d --> Index: [%d]\n", Usage, AssignedMocsIdx);
+
+ if(StartMocsIdx == 1)
+ {
+ EXPECT_NE(0, AssignedMocsIdx) << "Usage# " << Usage << ": Misprogramming MOCS - Index 0 is reserved for Error";
+ }
+
+ EXPECT_EQ(0, Mocs.L3.ESC) << "Usage# " << Usage << ": ESC is non-zero";
+ EXPECT_EQ(0, Mocs.L3.SCC) << "Usage# " << Usage << ": SCC is non-zero";
+ EXPECT_EQ(0, Mocs.L3.Reserved) << "Usage# " << Usage << ": Reserved field is non-zero";
+ // Check if Mocs Index is not greater than GMM_MAX_NUMBER_MOCS_INDEXES
+ EXPECT_GT(GMM_MAX_NUMBER_MOCS_INDEXES, AssignedMocsIdx) << "Usage# " << Usage << ": MOCS Index greater than MAX allowed (63)";
+
+ if(GfxPlatform.eProductFamily <= IGFX_DG1)
+ {
+ CheckMocsIdxHDCL1(Usage, AssignedMocsIdx, ClientRequest);
+ }
+
+ if(GfxPlatform.eProductFamily <= IGFX_DG1)
+ {
+ CheckSpecialMocs(Usage, AssignedMocsIdx, ClientRequest);
+ }
+
+ if(ClientRequest.L3)
+ {
+ EXPECT_EQ(L3_WB_CACHEABLE, Mocs.L3.Cacheability) << "Usage# " << Usage << ": Incorrect L3 cachebility setting";
+ }
+ else
+ {
+ EXPECT_EQ(L3_UNCACHEABLE, Mocs.L3.Cacheability) << "Usage# " << Usage << ": Incorrect L3 cachebility setting";
+ }
+ }
+}
diff --git a/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.h b/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.h
new file mode 100644
index 0000000..8d0776e
--- /dev/null
+++ b/Source/GmmLib/ULT/GmmGen12dGPUCachePolicyULT.h
@@ -0,0 +1,45 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+
+#pragma once
+
+#include "GmmCachePolicyULT.h"
+
+class CTestGen12dGPUCachePolicy : public CTestCachePolicy
+{
+protected:
+ virtual void SetUpGen12dGPUVariant(PRODUCT_FAMILY);
+ virtual void TearDownGen12dGPUVariant();
+ virtual void CheckL3Gen12dGPUCachePolicy();
+ virtual void CheckSpecialMocs(uint32_t Usage,
+ uint32_t AssignedMocsIdx,
+ GMM_CACHE_POLICY_ELEMENT ClientRequest);
+
+ virtual void CheckMocsIdxHDCL1(uint32_t Usage,
+ uint32_t AssignedMocsIdx,
+ GMM_CACHE_POLICY_ELEMENT ClientRequest);
+
+public:
+ static void SetUpTestCase();
+ static void TearDownTestCase();
+};
+#pragma once
diff --git a/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.cpp b/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.cpp
new file mode 100644
index 0000000..f7ae8b1
--- /dev/null
+++ b/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.cpp
@@ -0,0 +1,2762 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+
+#include "GmmGen12dGPUResourceULT.h"
+
+using namespace std;
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// Sets up common environment for Resource fixture tests. this is called once per
+/// test case before executing all tests under resource fixture test case.
+// It also calls SetupTestCase from CommonULT to initialize global context and others.
+///
+/// @see CTestGen12dGPUResource::SetUpTestCase()
+///
+/////////////////////////////////////////////////////////////////////////////////////
+void CTestGen12dGPUResource::SetUpTestCase()
+{
+ printf("%s\n", __FUNCTION__);
+ GfxPlatform.eProductFamily = IGFX_DG1;
+ GfxPlatform.eRenderCoreFamily = IGFX_GEN12_CORE;
+
+ pGfxAdapterInfo = (ADAPTER_INFO *)malloc(sizeof(ADAPTER_INFO));
+ if(pGfxAdapterInfo)
+ {
+ memset(pGfxAdapterInfo, 0, sizeof(ADAPTER_INFO));
+
+ pGfxAdapterInfo->SkuTable.FtrLinearCCS = 1; //legacy y =>0 - test both
+ pGfxAdapterInfo->SkuTable.FtrStandardMipTailFormat = 1;
+ pGfxAdapterInfo->SkuTable.FtrTileY = 1;
+ CommonULT::SetUpTestCase();
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// cleans up once all the tests finish execution. It also calls TearDownTestCase
+/// from CommonULT to destroy global context and others.
+///
+/// @see CTestGen12dGPUResource::TearDownTestCase()
+/////////////////////////////////////////////////////////////////////////////////////
+void CTestGen12dGPUResource::TearDownTestCase()
+{
+ printf("%s\n", __FUNCTION__);
+
+ CommonULT::TearDownTestCase();
+}
+
+TEST_F(CTestGen12dGPUResource, DISABLED_Test1DLinearResource)
+{
+ // Horizontal pixel alignment
+ const uint32_t HAlign[] = {128, 64, 32, 16, 8}; //128Bytes/(bpp>>3)
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_1D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.Linear = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+
+ // Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign[i]);
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+
+ // Allocate more than 1 page
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1001;
+ gmmParams.BaseHeight = 1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign[i]);
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 1D Linear Resource Arrays
+TEST_F(CTestGen12dGPUResource, DISABLED_Test1DLinearResourceArrays)
+{
+ // Horizontal pixel alignment
+ const uint32_t HAlign[] = {128, 64, 32, 16, 8}; //128Bytes/(bpp>>3)
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_1D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.Linear = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.ArraySize = 4;
+
+ // Allocate more than 1 page
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1001;
+ gmmParams.BaseHeight = 1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign[i]);
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes * gmmParams.ArraySize, PAGE_SIZE);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<true>(ResourceInfo, AlignedWidth);
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 1D Mipped Linear Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test1DLinearResourceMips)
+{
+ // Horizontal pixel alignment
+ const uint32_t HAlign[] = {128, 64, 32, 16, 8}; //128Bytes/(bpp>>3)
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_1D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.Linear = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.MaxLod = 5;
+
+ // Allocate 256x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x100;
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign[i]);
+ for(int mip = 1; mip <= gmmParams.MaxLod; mip++)
+ {
+ // Since 1D doesn't have a height, mips are just based on width
+ AlignedWidth += GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> mip, HAlign[i]);
+ }
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ // Mip0 should be at offset 0. X/Y/Z Offset should be 0 for linear.
+ GMM_REQ_OFFSET_INFO OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.MipLevel = 0; //Mip 0
+ ResourceInfo->GetOffset(OffsetInfo);
+ EXPECT_EQ(0, OffsetInfo.Render.Offset64);
+ EXPECT_EQ(0, OffsetInfo.Render.XOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset);
+
+ // All mips should be right after one another linearly
+ uint32_t StartOfMip = 0;
+ for(int mip = 1; mip <= gmmParams.MaxLod; mip++)
+ {
+ OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.MipLevel = mip;
+ ResourceInfo->GetOffset(OffsetInfo);
+ StartOfMip += GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> (mip - 1), HAlign[i]) * GetBppValue(bpp);
+ EXPECT_EQ(StartOfMip, OffsetInfo.Render.Offset64);
+ EXPECT_EQ(0, OffsetInfo.Render.XOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset);
+ }
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 1D Mipped TileYS Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test1DTileTiledResourceMips)
+{
+ const uint32_t TileSize[TEST_BPP_MAX] = {65536, 32768, 16384, 8192, 4096};
+ const uint32_t Mts[TEST_BPP_MAX] = {16384, 8192, 4096, 2048, 1024};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_1D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Gpu.TiledResource = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.MaxLod = 5;
+
+ // Allocate all mips in 1 tile or multiple tiles, depending on the bpp
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 16 * 1024; // 16K is the max width you can specify
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t MaxMip;
+ uint32_t MipTailStart = gmmParams.MaxLod;
+ for(MaxMip = 0; MaxMip <= gmmParams.MaxLod; MaxMip++)
+ {
+ if((gmmParams.BaseWidth64 >> MaxMip) <= Mts[i])
+ {
+ MipTailStart = MaxMip;
+ break;
+ }
+ }
+
+ uint32_t AlignedWidth = 0;
+ for(int mip = 0; mip <= MaxMip; mip++)
+ {
+ // Since 1D doesn't have a height, mips are just based on width
+ AlignedWidth += GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> mip, TileSize[i]);
+ ;
+ }
+
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<true>(ResourceInfo, TileSize[i]);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for 1D
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ // All mips should be right after one another linearly, until the miptail
+ uint32_t StartOfMip = 0;
+ int mip;
+ for(mip = 0; mip < MaxMip; mip++)
+ {
+ GMM_REQ_OFFSET_INFO OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.MipLevel = mip;
+ ResourceInfo->GetOffset(OffsetInfo);
+ StartOfMip += (mip == 0 ? 0 : GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> (mip - 1), TileSize[i]) * GetBppValue(bpp));
+ EXPECT_EQ(StartOfMip, OffsetInfo.Render.Offset64);
+ EXPECT_EQ(0, OffsetInfo.Render.XOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset);
+ }
+
+ uint32_t MipTailOffsets[GMM_ULT_MAX_MIPMAP] = {32768, 16384, 8192, 4096, 2048, 1536, 1280, 1024, 768, 512, 256, 0, 64, 128, 196};
+ // Check for offset inside miptails.
+ EXPECT_EQ(MipTailStart, ResourceInfo->GetPackedMipTailStartLod());
+ StartOfMip += GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> (mip - 1), TileSize[i]) * GetBppValue(bpp); // Start of MipTail
+ for(int slot = 0; mip <= gmmParams.MaxLod; mip++, slot++)
+ {
+ GMM_REQ_OFFSET_INFO OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.MipLevel = mip;
+ ResourceInfo->GetOffset(OffsetInfo);
+ EXPECT_EQ(StartOfMip, OffsetInfo.Render.Offset64); // Start of Miptail
+ EXPECT_EQ(MipTailOffsets[slot], OffsetInfo.Render.XOffset); // Offset within miptail
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset);
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset);
+ }
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 2D TileYf Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test2DTileYfCompressedResource)
+{
+ const uint32_t HAlign[TEST_BPP_MAX] = {64, 64, 32, 32, 16};
+ const uint32_t VAlign[TEST_BPP_MAX] = {64, 32, 32, 16, 16};
+
+ const uint32_t TileSize[TEST_BPP_MAX][2] = {{64, 64},
+ {128, 32},
+ {128, 32},
+ {256, 16},
+ {256, 16}};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYf = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+ // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW )
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-adapter shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+
+ //Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, 4 * TileSize[i][0]); // As wide as 4 Tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 4 Tile wide
+ VerifyResourceSize<true>(ResourceInfo, 4 * GMM_KBYTE(4)); // 4 Tile Big
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4); // 2 tile big, but 4-tile pitch alignment
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[i][1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4 * 2); // 4 tile wide; and 2-tile high
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 2D TileY Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test2DTileYCompressedResource)
+{
+ const uint32_t HAlign = {16};
+ const uint32_t VAlign = {4};
+
+ const uint32_t TileSize[2] = {128, 32};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+ // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf/Y its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-adapter shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+
+ //Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, 4 * TileSize[0]); // As wide as 4 Tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 4 Tile wide
+ VerifyResourceSize<true>(ResourceInfo, 4 * GMM_KBYTE(4)); // 4 Tile Big
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4); // 2 tile big, but 4-tile pitch alignment
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4 * 2); // 4 tile wide; and 2-tile high
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 2D TileY lossless Compressed lossy Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test2DTileYLossyCompressedResource)
+{
+ const uint32_t HAlign = {4};
+ const uint32_t VAlign = {4};
+
+ const uint32_t TileSize[2] = {128, 32};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+ // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-adapter shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+
+ //Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = GMM_FORMAT_ETC2_RGB8;
+ gmmParams.BaseWidth64 = 0x80;
+ gmmParams.BaseHeight = 0x20;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, 4 * TileSize[0]); // As wide as 4 Tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 4 Tile wide
+ VerifyResourceSize<true>(ResourceInfo, 4 * GMM_KBYTE(4)); // 4 Tile Big
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = GMM_FORMAT_ETC2_RGB8;
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4); // 2 tile big, but 4-tile pitch alignment
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = GMM_FORMAT_ETC2_RGB8;
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4); // 4 tile wide; max compressed height = 0x24/4 = 9, so fits in 1 tile-height
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+ //test main surface base alignment is 16KB
+ //For Yf/Y test main surface pitch is 4-tileYF/Y aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+//Y416(64bpp -how is 10/12/16bit depth given?)
+//Y410(32bpp), Y216(64bpp), YCRCB_NORMAL(16bpp), YCRCB_SWAPUV(16bpp),
+//YCRCB_SWAPUVY(16bpp), YCRCB_SWAPY(16bpp)
+
+/// @brief ULT for Planar Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_TestPlanarYfCompressedResource)
+{
+ const uint32_t TileSize[TEST_BPP_MAX][2] = {
+ {64, 64}, {128, 32}, {128, 32}, {256, 16}, {256, 16}}; // TileYf
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ //gmmParams.Flags.Gpu.MMC = 1;
+ gmmParams.Flags.Gpu.CCS = 1;
+ gmmParams.Flags.Info.MediaCompressed = 1;
+ gmmParams.BaseWidth64 = 0x100;
+ gmmParams.BaseHeight = 0x50;
+ gmmParams.Depth = 0x1;
+ SetTileFlag(gmmParams, TEST_TILEYF); // TileYF only
+
+ //UV-Packed formats
+ GMM_RESOURCE_FORMAT Format[4] = {GMM_FORMAT_NV12, GMM_FORMAT_NV21, GMM_FORMAT_P010, GMM_FORMAT_P016};
+ for(auto fmt : Format)
+ {
+ gmmParams.Format = fmt; // 8bpp (NV12, NV21), 16bpp (P016,P010)
+
+ TEST_BPP Ybpp, UVbpp;
+ //Yf/Ys could be accessed on CPU/app where UV plane bpp is double
+ switch(pGmmULTClientContext->GetPlatformInfo().FormatTable[fmt].Element.BitsPer)
+ {
+ case 8:
+ Ybpp = TEST_BPP_8;
+ UVbpp = TEST_BPP_16;
+ break;
+ case 16:
+ Ybpp = TEST_BPP_16;
+ UVbpp = TEST_BPP_32;
+ break;
+ default:
+ return;
+ }
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+
+ /*Aux is TileY (later Linear), not redescribing, its bytes are allocated using one bpp*/
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, Ybpp);
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ //Redescribed Pitch isn't modified unless Y, UV pitch differ
+ //But, original Pitch is padded to have even Tile, hence use Ybpp ExpectedPitch
+ //to verify Pitch, but redescribed size
+ uint32_t ExpectedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 * (int)pow(2.0, Ybpp), TileSize[Ybpp][0] * 4);
+ uint32_t RedescribedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 / 2 * (int)pow(2.0, UVbpp), TileSize[UVbpp][0] * 4);
+
+ //ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, 2 * TileSize[Ybpp][0]); //pad to even tile
+ if(ExpectedPitch != RedescribedPitch)
+ {
+ ExpectedPitch = RedescribedPitch;
+ }
+
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, ExpectedPitch / TileSize[Ybpp][0]);
+
+ int YSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[Ybpp][1]) / TileSize[Ybpp][1]) *
+ RedescribedPitch / TileSize[Ybpp][0];
+ int UVSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight / 2, TileSize[UVbpp][1]) / TileSize[UVbpp][1]) *
+ RedescribedPitch / TileSize[UVbpp][0];
+
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * (YSizeInTiles + UVSizeInTiles));
+ VerifyResourceHAlign<true>(ResourceInfo, TileSize[UVbpp][0] / pow(2.0, UVbpp)); // For Yf/Ys planar redescription causes UV width, Y height alignment
+ VerifyResourceVAlign<true>(ResourceInfo, TileSize[Ybpp][1]);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-mipped surface
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4) * 2, ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS)); // Y and UV Aux are on separate tiles
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ EXPECT_EQ(GMM_KBYTE(4) * 2, AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for Planar Y Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_TestPlanarYCompressedResource)
+{
+ const uint32_t TileSize[2] = {128, 32};
+ const uint32_t HAlign = 16;
+ const uint32_t VAlign = 4;
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Gpu.RenderTarget = 1;
+ gmmParams.Flags.Gpu.MMC = 1;
+ gmmParams.Flags.Gpu.CCS = 1;
+ gmmParams.Flags.Gpu.IndirectClearColor = 1;
+ gmmParams.Flags.Info.MediaCompressed = 1;
+ gmmParams.Flags.Info.NotLockable = 1;
+ gmmParams.Flags.Info.Cacheable = 1;
+ gmmParams.BaseWidth64 = 0xB2;
+ gmmParams.BaseHeight = 0x92;
+ gmmParams.Depth = 0x1;
+ SetTileFlag(gmmParams, TEST_TILEY); // TileYF only
+
+ GMM_RESOURCE_FORMAT Format[4] = {GMM_FORMAT_NV12, GMM_FORMAT_NV21, GMM_FORMAT_P010, GMM_FORMAT_P016};
+ for(auto fmt : Format)
+ {
+ gmmParams.Format = fmt; // 8bpp (NV12, NV21), 16bpp (P016, P010)
+
+ TEST_BPP Ybpp, UVbpp;
+ //Yf/Ys could be accessed on CPU/app where UV plane bpp is double
+ switch(pGmmULTClientContext->GetPlatformInfo().FormatTable[fmt].Element.BitsPer)
+ {
+ case 8:
+ Ybpp = TEST_BPP_8;
+ UVbpp = TEST_BPP_16;
+ break;
+ case 16:
+ Ybpp = TEST_BPP_16;
+ UVbpp = TEST_BPP_32;
+ break;
+ default:
+ return;
+ }
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ //Redescribed Pitch isn't modified unless Y, UV pitch differ
+ //But, original Pitch is padded to have even Tile, hence use Ybpp ExpectedPitch
+ //to verify Pitch, but redescribed size
+ uint32_t ExpectedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 * (int)pow(2.0, Ybpp), TileSize[0] * 4);
+ uint32_t RedescribedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 / 2 * (int)pow(2.0, UVbpp), TileSize[0] * 4);
+
+ //ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, 2 * TileSize[Ybpp][0]); //pad to even tile
+ if(ExpectedPitch != RedescribedPitch)
+ {
+ ExpectedPitch = RedescribedPitch;
+ }
+
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, ExpectedPitch / TileSize[0]);
+
+ int YSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[1]) / TileSize[1]) *
+ RedescribedPitch / TileSize[0];
+ int UVSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight / 2, TileSize[1]) / TileSize[1]) *
+ RedescribedPitch / TileSize[0];
+
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * (YSizeInTiles + UVSizeInTiles)); //when main-surf planes are tile-aligned, make it verify-true
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-mipped surface
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileY aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_UV_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4) * 2, ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS)); // Y and UV Aux are on separate tiles
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for Planar Ys Compressed resource
+TEST_F(CTestGen12dGPUResource, DISABLED_TestPlanarYsCompressedResource)
+{
+ const TEST_TILE_TYPE TileTypeSupported = {TEST_TILEYS};
+
+ const uint32_t TileSize[TEST_BPP_MAX][2] = {
+ {256, 256}, {512, 128}, {512, 128}, {1024, 64}, {1024, 64}}; // TileYS
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Gpu.MMC = 1;
+ //gmmParams.Flags.Gpu.CCS = 1;
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+ gmmParams.Flags.Info.MediaCompressed = 1;
+ gmmParams.BaseWidth64 = 0x100;
+ gmmParams.BaseHeight = 0x50;
+ gmmParams.Depth = 0x1;
+ SetTileFlag(gmmParams, TEST_TILEYS); // TileYS only
+
+ GMM_RESOURCE_FORMAT Format[4] = {GMM_FORMAT_NV12, GMM_FORMAT_NV21, GMM_FORMAT_P010, GMM_FORMAT_P016};
+ for(auto fmt : Format)
+ {
+ gmmParams.Format = fmt; // 8bpp(NV12) , P016 (16bpp), P010 (16bpp), NV21(8bpp)
+
+ TEST_BPP Ybpp, UVbpp;
+ //Yf/Ys could be accessed on CPU/app where UV plane bpp is double
+ switch(pGmmULTClientContext->GetPlatformInfo().FormatTable[gmmParams.Format].Element.BitsPer)
+ {
+ case 8:
+ Ybpp = TEST_BPP_8;
+ UVbpp = TEST_BPP_16;
+ break;
+ case 16:
+ Ybpp = TEST_BPP_16;
+ UVbpp = TEST_BPP_32;
+ break;
+ default:
+ return;
+ }
+
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YS_2D, Ybpp);
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ //Redescribed Pitch isn't modified unless Y, UV pitch differ
+ //But, original Pitch is padded to have even Tile, hence use Ybpp ExpectedPitch
+ //to verify Pitch, but redescribed pitch to verify size
+ uint32_t ExpectedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 * (int)pow(2.0, Ybpp), TileSize[Ybpp][0]);
+ uint32_t RedescribedPitch = GMM_ULT_ALIGN(gmmParams.BaseWidth64 / 2 * (int)pow(2.0, UVbpp), TileSize[UVbpp][0]);
+
+ if(ExpectedPitch != RedescribedPitch)
+ {
+ ExpectedPitch = RedescribedPitch;
+ }
+ else
+ {
+ //ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, 2 * TileSize[Ybpp][0]); //pad to even tile
+ //ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, (2 * TileSize[UVbpp][0]/ (int)pow(2.0, UVbpp))); //pad to even tile
+ }
+
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, ExpectedPitch / TileSize[Ybpp][0]);
+
+ int YSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[Ybpp][1]) / TileSize[Ybpp][1]) *
+ RedescribedPitch / TileSize[Ybpp][0];
+ int UVSizeInTiles = (GMM_ULT_ALIGN(gmmParams.BaseHeight / 2, TileSize[UVbpp][1]) / TileSize[UVbpp][1]) *
+ RedescribedPitch / TileSize[UVbpp][0];
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(64) * (YSizeInTiles + UVSizeInTiles));
+ VerifyResourceHAlign<true>(ResourceInfo, TileSize[UVbpp][0] / pow(2.0, UVbpp)); // For Yf/Ys planar redescription causes UV width, Y height alignment
+ VerifyResourceVAlign<true>(ResourceInfo, TileSize[Ybpp][1]);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-mipped surface
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ //EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_UV_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4) * 2, ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS)); // Y and UV Aux are on separate tiles
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 2D arrayed compressed Resource
+TEST_F(CTestGen12dGPUResource, TestArrayedCompressedResource)
+{
+ //printf("%s\n", __FUNCTION__);
+ //Test for 3D array
+}
+
+/// @brief ULT for mip-mapped compressed Resource
+TEST_F(CTestGen12dGPUResource, TestMipMapCompressedResource)
+{
+ //printf("%s\n", __FUNCTION__);
+}
+
+/// @brief ULT for cube Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_TestCubeCompressedResource)
+{
+ //Tests 2D array
+ const uint32_t HAlign[5][TEST_BPP_MAX] = {{0}, {0}, {0}, {256, 256, 128, 128, 64}, {64, 64, 32, 32, 16}};
+ const uint32_t VAlign[5][TEST_BPP_MAX] = {{0}, {0}, {0}, {256, 128, 128, 64, 64}, {64, 32, 32, 16, 16}};
+
+ const TEST_TILE_TYPE TileTypeSupported[2] = {TEST_TILEYS, TEST_TILEYF};
+
+ const uint32_t TileSize[5][TEST_BPP_MAX][2] = {
+ {0},
+ {0},
+ {0},
+ {{256, 256}, {512, 128}, {512, 128}, {1024, 64}, {1024, 64}}, // TileYS
+ {{64, 64}, {128, 32}, {128, 32}, {256, 16}, {256, 16}}}; //TileYf
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_CUBE;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+
+ // Allocate 1x1 surface so that it occupies 1 Tile in X dimension
+ for(auto Tiling : TileTypeSupported)
+ {
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYf = (Tiling == TEST_TILEYF);
+ gmmParams.Flags.Info.TiledYs = (Tiling == TEST_TILEYS);
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+ gmmParams.Flags.Gpu.CCS = 1;
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = (Tiling == TEST_TILEYF) ? DEFINE_TILE(YF_2D, bpp) : DEFINE_TILE(YS_2D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[Tiling][i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[Tiling][i]);
+
+ uint32_t ExpectedPitch = 4 * TileSize[TEST_TILEYF][i][0];
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch); // As wide as 4 tile-YF
+ VerifyResourcePitchInTiles<true>(ResourceInfo, (Tiling == TEST_TILEYF) ? 4 : 1); // 1 tile wide
+
+ uint32_t ExpectedQPitch = VAlign[Tiling][i];
+ VerifyResourceQPitch<true>(ResourceInfo, ExpectedQPitch); // Each face should be VAlign rows apart within a tile
+
+ VerifyResourceSize<true>(ResourceInfo, // PitchInBytes * Rows where Rows = __GMM_MAX_CUBE_FACE x QPitch, then aligned to tile boundary
+ ExpectedPitch *
+ __GMM_MAX_CUBE_FACE * ExpectedQPitch);
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % ((Tiling == TEST_TILEYF) ? 4 : 1));
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+
+ for(uint32_t CubeFaceIndex = 0; CubeFaceIndex < __GMM_MAX_CUBE_FACE; CubeFaceIndex++)
+ {
+ GMM_REQ_OFFSET_INFO OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.CubeFace = static_cast<GMM_CUBE_FACE_ENUM>(CubeFaceIndex);
+ ResourceInfo->GetOffset(OffsetInfo);
+
+ EXPECT_EQ((CubeFaceIndex * ExpectedQPitch) * ExpectedPitch,
+ OffsetInfo.Render.Offset64); // Render offset is tile's base address on which cube face begins.
+ EXPECT_EQ(0, OffsetInfo.Render.XOffset); // X Offset should be 0 as cube face starts on tile boundary
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset); // Y Offset should be 0 as cube face starts on tile boundary
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset); // Z offset N/A should be 0
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X dimension.
+ // Width and Height must be equal
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+ gmmParams.Flags.Gpu.CCS = 1;
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = (Tiling == TEST_TILEYF) ? DEFINE_TILE(YF_2D, bpp) : DEFINE_TILE(YS_2D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[Tiling][i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = gmmParams.BaseWidth64; // Heigth must be equal to width.
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[Tiling][i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[Tiling][i]);
+
+ uint32_t ExpectedPitch = TileSize[Tiling][i][0] * 2 * ((Tiling == TEST_TILEYF) ? 2 : 1); // As wide as 2 tile, padded to 4 tile-pitch
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2 * ((Tiling == TEST_TILEYF) ? 2 : 1)); // 2 tile wide
+
+ uint32_t ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign[Tiling][i]);
+ VerifyResourceQPitch<true>(ResourceInfo, ExpectedQPitch); // Each face should be Valigned-BaseHeight rows apart
+
+ VerifyResourceSize<true>(ResourceInfo, // PitchInBytes * Rows where Rows = __GMM_MAX_CUBE_FACE x QPitch, then aligned to tile boundary
+ ExpectedPitch *
+ __GMM_MAX_CUBE_FACE * ExpectedQPitch);
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % ((Tiling == TEST_TILEYF) ? 4 : 1)); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+
+ for(uint32_t CubeFaceIndex = 0; CubeFaceIndex < __GMM_MAX_CUBE_FACE; CubeFaceIndex++)
+ {
+ GMM_REQ_OFFSET_INFO OffsetInfo = {};
+ OffsetInfo.ReqRender = 1;
+ OffsetInfo.CubeFace = static_cast<GMM_CUBE_FACE_ENUM>(CubeFaceIndex);
+ ResourceInfo->GetOffset(OffsetInfo);
+ EXPECT_EQ((CubeFaceIndex * ExpectedQPitch) * ExpectedPitch,
+ OffsetInfo.Render.Offset64); // Render offset is tile's base address on which cube face begins.
+ EXPECT_EQ(0, OffsetInfo.Render.XOffset); // X Offset should be 0 as cube face starts on tile boundary
+ EXPECT_EQ(0, OffsetInfo.Render.YOffset); // Y Offset should be 0 as cube face starts on tile boundary
+ EXPECT_EQ(0, OffsetInfo.Render.ZOffset); // Z offset N/A should be 0
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+ }
+}
+
+/// @brief ULT for 3D TileYs Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test3DTileYsCompressedResource)
+{
+ if(!const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ return;
+ }
+ // Horizontal/Vertical pixel alignment
+ const uint32_t HAlign[TEST_BPP_MAX] = {64, 32, 32, 32, 16};
+ const uint32_t VAlign[TEST_BPP_MAX] = {32, 32, 32, 16, 16};
+
+ const uint32_t TileSize[TEST_BPP_MAX][3] = {{64, 32, 32},
+ {64, 32, 32},
+ {128, 32, 16},
+ {256, 16, 16},
+ {256, 16, 16}};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_3D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYs = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1; // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+
+ // Allocate 1x1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YS_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0]); // As wide as 1 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 1); // 1 tile wide
+ VerifyResourceSize<false>(ResourceInfo, GMM_KBYTE(64)); // 1 tile big
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YS_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 2); // As wide as 2 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2); // 2 tile wide
+ VerifyResourceSize<false>(ResourceInfo, GMM_KBYTE(64) * 2); // 2 tile big
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YS_3D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[i][1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 2); // As wide as 2 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2); // 2 tile wide
+ VerifyResourceSize<false>(ResourceInfo, GMM_KBYTE(64) * 4); // 4 tile big
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y/Z dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YS_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[i][1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = TileSize[i][2] + 1; // 1 plane larger than 1 tile depth
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 2); // As wide as 2 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2); // 2 tile wide
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(64) * 8); // 8 tile big
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 3D TileYf Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test3DTileYfCompressedResource)
+{
+ if(!const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ return;
+ }
+ // Horizontal/Verticle pixel alignment
+ const uint32_t HAlign[TEST_BPP_MAX] = {16, 8, 8, 8, 4};
+ const uint32_t VAlign[TEST_BPP_MAX] = {16, 16, 16, 8, 8};
+ const uint32_t TileSize[TEST_BPP_MAX][3] = {{16, 16, 16},
+ {16, 16, 16},
+ {32, 16, 8},
+ {64, 8, 8},
+ {64, 8, 8}};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_3D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYf = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1; // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+
+ // Allocate 1x1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+ //gmmParams.Flags.Gpu.MMC = 0; //Turn on to check unifiedaux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ //gmmParams.BaseWidth64 = 0x30;
+ //gmmParams.BaseHeight = 0x30;
+ //gmmParams.Depth = 0x20;
+ gmmParams.BaseWidth64 = 1;
+ gmmParams.BaseHeight = 1;
+ gmmParams.Depth = 1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[i][0] * 4));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[i][0] * 4) / TileSize[i][0]);
+ VerifyResourceSize<true>(ResourceInfo, (GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[i][0] * 4) / TileSize[i][0]) *
+ (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[i][1]) / TileSize[i][1]) *
+ (GMM_ULT_ALIGN(gmmParams.Depth, TileSize[i][2]) / TileSize[i][2]) * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[i][1])));
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+ const uint32_t PitchAlignment = 32;
+
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0] * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[i][1]);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = TileSize[i][1] + 1;
+ gmmParams.Depth = 0x1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0] * 2 * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[i][1] * 2);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y/Z dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_3D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = TileSize[i][1] + 1;
+ gmmParams.Depth = TileSize[i][2] + 1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[i][0] * 4, PitchAlignment) / TileSize[i][0] * 2 * 2 * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[i][1] * 2);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_GE(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), ResourceInfo->GetSizeMainSurface() >> 8);
+ }
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 3D TileY Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test3DTileYCompressedResource)
+{
+ if(!const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ return;
+ }
+ // Horizontal/Verticle pixel alignment
+ const uint32_t HAlign = {16};
+ const uint32_t VAlign = {4};
+ const uint32_t TileSize[3] = {128, 32, 1};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_3D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1; // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+
+ // Allocate 1x1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ //gmmParams.BaseWidth64 = 0x30;
+ //gmmParams.BaseHeight = 0x30;
+ //gmmParams.Depth = 0x20;
+ gmmParams.BaseWidth64 = 1;
+ gmmParams.BaseHeight = 1;
+ gmmParams.Depth = 1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[0] * 4));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[0] * 4) / TileSize[0]);
+ VerifyResourceSize<true>(ResourceInfo, (GMM_ULT_ALIGN(gmmParams.BaseWidth64, TileSize[0] * 4) / TileSize[0]) *
+ (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[1]) / TileSize[1]) *
+ (GMM_ULT_ALIGN(gmmParams.Depth, TileSize[2]) / TileSize[2]) * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, (GMM_ULT_ALIGN(gmmParams.BaseHeight, TileSize[1])));
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+ const uint32_t PitchAlignment = 32;
+
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0] * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[1]);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = TileSize[1] + 1;
+ gmmParams.Depth = 0x1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0] * 2 * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[1] * 2);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y/Z dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1;
+ gmmParams.BaseHeight = TileSize[1] + 1;
+ gmmParams.Depth = TileSize[2] + 1;
+ const uint32_t PitchAlignment = 32;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment));
+ VerifyResourcePitchInTiles<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0]);
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(TileSize[0] * 4, PitchAlignment) / TileSize[0] * 2 * 2 * GMM_KBYTE(4));
+ VerifyResourceQPitch<true>(ResourceInfo, TileSize[1] * 2);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for 2D Yf mipped compressed resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test2DTileYfMippedCompressedResource)
+{
+ if(!const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ return;
+ }
+ const uint32_t HAlign[TEST_BPP_MAX] = {64, 64, 32, 32, 16};
+ const uint32_t VAlign[TEST_BPP_MAX] = {64, 32, 32, 16, 16};
+
+ const uint32_t TileSize[TEST_BPP_MAX][2] = {{64, 64},
+ {128, 32},
+ {128, 32},
+ {256, 16},
+ {256, 16}};
+
+ const uint32_t MtsWidth[TEST_BPP_MAX] = {32, 32, 16, 16, 8};
+ const uint32_t MtsHeight[TEST_BPP_MAX] = {64, 32, 32, 16, 16};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYf = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1; // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile (reqd by HW for perf reasons)
+ gmmParams.MaxLod = 4;
+ gmmParams.ArraySize = 4;
+
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ uint32_t AlignedWidth = 0;
+ uint32_t AlignedHeight = 0;
+ uint32_t ExpectedPitch = 0;
+ uint32_t MipTailStartLod = 0;
+ // Valigned Mip Heights
+ uint32_t Mip0Height = 0;
+ uint32_t Mip1Height = 0;
+ uint32_t Mip2Height = 0;
+ uint32_t Mip3Height = 0;
+ uint32_t Mip4Height = 0;
+ uint32_t Mip5Height = 0;
+ uint32_t Mip2Higher = 0; // Sum of aligned heights of Mip2 and above
+ uint32_t MipTailHeight = 0;
+ // Haligned Mip Widths
+ uint32_t Mip0Width = 0;
+ uint32_t Mip1Width = 0;
+ uint32_t Mip2Width = 0;
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x38;
+ gmmParams.BaseHeight = 0x38;
+
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-device shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+
+ // find the miptail start level
+ {
+ uint32_t MipWidth = gmmParams.BaseWidth64;
+ uint32_t MipHeight = gmmParams.BaseHeight;
+ while(!(MipWidth <= MtsWidth[i] && MipHeight <= MtsHeight[i]))
+ {
+ MipTailStartLod++;
+ MipWidth = (uint32_t)(GMM_ULT_MAX(1, gmmParams.BaseWidth64 >> MipTailStartLod));
+ MipHeight = GMM_ULT_MAX(1, gmmParams.BaseHeight >> MipTailStartLod);
+ }
+ }
+
+ // Mip resource Aligned Width calculation
+ Mip0Width = GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign[i]);
+ Mip0Height = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign[i]);
+
+ if(MipTailStartLod == 1)
+ {
+ EXPECT_EQ(1, ResourceInfo->GetPackedMipTailStartLod());
+ // Block height...Mip0Height + Max(Mip1Height, Sum of Mip2Height..MipnHeight)
+ Mip1Height = GMM_ULT_ALIGN(gmmParams.BaseHeight >> 1, VAlign[i]);
+ AlignedWidth = Mip0Width;
+ }
+ if(MipTailStartLod == 2)
+ {
+ EXPECT_EQ(2, ResourceInfo->GetPackedMipTailStartLod());
+ // Block height...Mip0Height + Max(Mip1Height, Sum of Mip2Height..MipnHeight)
+ Mip1Height = GMM_ULT_ALIGN(gmmParams.BaseHeight >> 1, VAlign[i]);
+ Mip2Height = Mip2Higher = GMM_ULT_ALIGN(gmmParams.BaseHeight >> 2, VAlign[i]);
+
+ Mip1Width = GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> 1, HAlign[i]);
+ Mip2Width = GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> 2, HAlign[i]);
+ AlignedWidth = GMM_ULT_MAX(Mip0Width, Mip1Width + Mip2Width);
+ }
+ if(MipTailStartLod == 3)
+ {
+ EXPECT_EQ(3, ResourceInfo->GetPackedMipTailStartLod());
+ // Block height...Mip0Height + Max(Mip1Height, Sum of Mip2Height..MipnHeight)
+ Mip1Height = GMM_ULT_ALIGN(gmmParams.BaseHeight >> 1, VAlign[i]);
+ Mip2Height = GMM_ULT_ALIGN(gmmParams.BaseHeight >> 2, VAlign[i]);
+ // Miptail started lod
+ MipTailHeight = VAlign[i];
+ Mip2Higher = Mip2Height + Mip3Height + MipTailHeight;
+
+ Mip1Width = GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> 1, HAlign[i]);
+ Mip2Width = GMM_ULT_ALIGN(gmmParams.BaseWidth64 >> 2, HAlign[i]);
+ AlignedWidth = GMM_ULT_MAX(Mip0Width, Mip1Width + Mip2Width);
+ }
+
+ uint32_t MaxHeight = GMM_ULT_MAX(Mip1Height, Mip2Higher);
+ AlignedHeight = Mip0Height + MaxHeight;
+ AlignedHeight = GMM_ULT_ALIGN(AlignedHeight, VAlign[i]);
+
+ ExpectedPitch = AlignedWidth * GetBppValue(bpp);
+ ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, GMM_BYTES(32));
+ ExpectedPitch = GMM_ULT_ALIGN(ExpectedPitch, TileSize[i][0] * 4); //Only for displayables - 16K pitch align
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+
+ VerifyResourcePitchInTiles<true>(ResourceInfo, static_cast<uint32_t>(ExpectedPitch / TileSize[i][0]));
+ VerifyResourceSize<true>(ResourceInfo, GMM_ULT_ALIGN(ExpectedPitch * AlignedHeight * gmmParams.ArraySize, PAGE_SIZE));
+ VerifyResourceQPitch<false>(ResourceInfo, AlignedHeight);
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ //Aux-size enough to cover all
+ if(const_cast<SKU_FEATURE_TABLE &>(pGfxAdapterInfo->SkuTable).FtrLinearCCS)
+ {
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ }
+
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for Linear Buffer Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_TestLinearCompressedResource)
+{
+ // Horizontal pixel alignment
+ const uint32_t MinPitch = 32;
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_BUFFER;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.Linear = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+
+ // Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 1;
+ gmmParams.Flags.Info.AllowVirtualPadding = (bpp != 8); //OCL uses 8bpp buffers. Specification doesn't comment if Linear buffer compr allowed or not on bpp!=8.
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, MinPitch);
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<false>(ResourceInfo, 0);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for buffer
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for buffer
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ //test main surface base alignment is 16KB
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+
+ // Allocate more than 1 page
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1001;
+ gmmParams.BaseHeight = 1;
+ gmmParams.Flags.Info.AllowVirtualPadding = (bpp != 8); //OCL uses 8bpp buffers. Specification doesn't comment if Linear buffer compr allowed or not on bpp!=8.
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ uint32_t AlignedWidth = GMM_ULT_ALIGN(gmmParams.BaseWidth64, MinPitch);
+ uint32_t PitchInBytes = AlignedWidth * GetBppValue(bpp);
+ uint32_t AlignedSize = GMM_ULT_ALIGN(PitchInBytes, PAGE_SIZE);
+
+ VerifyResourceHAlign<false>(ResourceInfo, MinPitch);
+ VerifyResourceVAlign<false>(ResourceInfo, 0); // N/A for buffer
+ VerifyResourcePitch<false>(ResourceInfo, 0); // N/A for buffer
+ VerifyResourcePitchInTiles<false>(ResourceInfo, 0); // N/A for linear
+ VerifyResourceSize<true>(ResourceInfo, AlignedSize);
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // N/A for non-arrayed
+
+ //test main surface base alignment is 16KB
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ ASSERT_LE(GMM_ULT_ALIGN(ResourceInfo->GetSizeMainSurface() / (GMM_KBYTE(16) / GMM_BYTES(64)), GMM_KBYTE(4)),
+ ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+///TODO Add MSAA/Depth Compressed Resource tests
+TEST_F(CTestGen12dGPUResource, DISABLED_TestLosslessMSAACompressedResource)
+{
+}
+
+///TODO Add MSAA/Depth Compressed Resource tests
+TEST_F(CTestGen12dGPUResource, DISABLED_TestDepthCompressedResource)
+{
+ const uint32_t HAlign = 8;
+ uint32_t VAlign = 4;
+
+ //const uint32_t DepthTileSize[1][2] = { 64, 64 };
+ const uint32_t AllocTileSize[1][2] = {128, 32}; //HiZ is TileY
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1; //Not supported for Depth buffer, but HiZ output is TileY
+ gmmParams.Flags.Gpu.Depth = 1; //GPU Flags= Depth/SeparateStencil + HiZ
+ gmmParams.Flags.Gpu.HiZ = 1;
+ gmmParams.Flags.Gpu.IndirectClearColor = 1;
+ gmmParams.Flags.Gpu.CCS = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
+
+ // Allocate 1x1 surface so that it occupies 1 Tile in X dimension
+ for(uint32_t j = TEST_BPP_8; j <= TEST_BPP_128; j++) //Depth bpp doesn't matter, Depth px dimensions decide HiZ size in HW
+ {
+ {
+ VAlign = (j == TEST_BPP_16) ? 8 : 4;
+ }
+ gmmParams.Format = SetResourceFormat(static_cast<TEST_BPP>(j)); //Only 16,24,32 supported; But driver creates the resource even for other bpps without failing
+ for(uint32_t i = RESOURCE_2D; i <= RESOURCE_CUBE; i++) //3D doesn't support HiZ - test driver returns proper?
+ {
+ gmmParams.Type = static_cast<GMM_RESOURCE_TYPE>(i);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1; //0x24; //not 1 tile
+ //gmmParams.MaxLod = 6; --add expectedheight calc- mip0+max{mip1, sum{mip2,...n}}
+ gmmParams.Depth = 0x1;
+ if(i == RESOURCE_1D || i == RESOURCE_3D)
+ {
+ gmmParams.Flags.Gpu.HiZ = 0;
+ }
+
+ GMM_RESOURCE_INFO *ResourceInfo = NULL;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ //EXPECT_NE(NULL, ResourceInfo);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ uint32_t ExpectedPitch = AllocTileSize[0][0] * 4;
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 1 tileY wide
+ uint32_t ExpectedHeight = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign);
+
+ if(gmmParams.ArraySize > 1 || gmmParams.Type == RESOURCE_CUBE)
+ {
+ uint32_t ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign); //Apply formula on Specification
+ ExpectedQPitch = GMM_ULT_ALIGN(ExpectedQPitch / 2, VAlign);
+ ExpectedHeight *= (gmmParams.Type == RESOURCE_CUBE) ? 6 : 1;
+
+ VerifyResourceQPitch<false>(ResourceInfo, ExpectedQPitch); // Each face should be VAlign rows apart within a tile, Turn on verification after clarity
+ }
+
+ VerifyResourceSize<true>(ResourceInfo,
+ GFX_ALIGN(ExpectedPitch * ExpectedHeight, 4 * PAGE_SIZE)); //1 Tile should be enough
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X dimension. (muti-tiles Tiles in Y dimension for cube/array)
+ for(uint32_t i = RESOURCE_2D; i <= RESOURCE_CUBE; i++)
+ {
+ gmmParams.Type = static_cast<GMM_RESOURCE_TYPE>(i);
+ gmmParams.BaseWidth64 = AllocTileSize[0][0] + 0x1;
+ gmmParams.BaseHeight = (gmmParams.Type == RESOURCE_1D) ? 0x1 :
+ (gmmParams.Type == RESOURCE_CUBE) ? gmmParams.BaseWidth64 :
+ VAlign / 2;
+ gmmParams.ArraySize = (gmmParams.Type != RESOURCE_3D) ? VAlign : 1; // Gen8 doesn't support 3D-arrays (so HiZ not supported) [test 3d arrays once -- HiZ would fail but ResCreate doesn't?]
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ uint32_t ExpectedPitch = GFX_ALIGN(gmmParams.BaseWidth * (int)pow(2, j), AllocTileSize[0][0] * 4);
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tileY wide
+
+ uint32_t ExpectedQPitch;
+ if(gmmParams.ArraySize > 1 || gmmParams.Type == RESOURCE_CUBE)
+ {
+ ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign);
+ //ExpectedQPitch = GMM_ULT_ALIGN(ExpectedQPitch / 2, VAlign);
+
+ VerifyResourceQPitch<false>(ResourceInfo, ExpectedQPitch); // Each face should be VAlign rows apart within a tile. Turn on verification after clarity
+ }
+
+ VerifyResourceSize<true>(ResourceInfo, // PitchInBytes * Rows where Rows = (__GMM_MAX_CUBE_FACE x QPitch) /2 (Stencil height = halved due to interleaving), then aligned to tile boundary
+ ((gmmParams.Type == RESOURCE_CUBE) ?
+ ExpectedPitch * GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.ArraySize * __GMM_MAX_CUBE_FACE, AllocTileSize[0][1]) : //cube
+ ((gmmParams.ArraySize > 1) ?
+ ExpectedPitch * GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.ArraySize, AllocTileSize[0][1]) : //array
+ 4 * GMM_KBYTE(4))));
+
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate 2 tiles in X/Y dimension (non-arrayed) Multi-tiles for 3D
+ for(uint32_t i = RESOURCE_2D; i <= RESOURCE_3D; i++)
+ {
+ gmmParams.Type = static_cast<GMM_RESOURCE_TYPE>(i);
+ gmmParams.BaseWidth64 = AllocTileSize[0][0] + 0x1;
+ gmmParams.BaseHeight = 2 * AllocTileSize[0][1] + 0x1; //Half-Depth Height or QPitch (lod!=0), aligned to 8 required by HW
+ gmmParams.Depth = (gmmParams.Type == RESOURCE_2D) ? 0x1 :
+ VAlign + 1;
+ gmmParams.ArraySize = 1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ uint32_t ExpectedPitch = AllocTileSize[0][0] * 4;
+ VerifyResourcePitch<true>(ResourceInfo, ExpectedPitch);
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide
+
+ uint32_t TwoDQPitch, ExpectedQPitch;
+ if(gmmParams.Type == RESOURCE_3D)
+ {
+ TwoDQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign);
+ ExpectedQPitch = gmmParams.Depth * GMM_ULT_ALIGN(TwoDQPitch / 2, VAlign); //Depth slices arranged as 2D-arrayed slices.
+ }
+ else
+ {
+ //HiZ for 3D not supported. Driver still allocates like IVB/HSW. (should Qpitch or only overall buffer height be Valigned ?)
+ VerifyResourceSize<true>(ResourceInfo,
+ ((gmmParams.Type == RESOURCE_3D) ?
+ ExpectedPitch * GMM_ULT_ALIGN(ExpectedQPitch, AllocTileSize[0][1]) :
+ 2 * 2 * GMM_KBYTE(4)));
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+ }
+}
+
+TEST_F(CTestGen12dGPUResource, DISABLED_TestStencilCompressedResource)
+{
+ const uint32_t HAlign = {16};
+ const uint32_t VAlign = {8};
+
+ const uint32_t TileSize[2] = {128, 32};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ //gmmParams.ArraySize = 4;
+
+ gmmParams.Flags.Gpu.SeparateStencil = 1;
+ gmmParams.Flags.Info.RenderCompressed = 1;
+ // Turn on .MC or .RC flag - mandatory to tell compression-type, for Yf its also used to pad surf
+ // to 4x1 tile
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-adapter shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+
+ //Allocate 1x1 surface
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.IndirectClearColor = 1;
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(TEST_BPP_8);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, 4 * TileSize[0]); // As wide as 4 Tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 4 Tile wide
+ VerifyResourceSize<true>(ResourceInfo, 4 * GMM_KBYTE(4)); // 4 Tile Big
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not Tested
+
+ //test main surface base alignment is 16KB
+ //For Yf test main surface pitch is 4-tileYF aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4); // Check on YF only
+
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X dimension
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(TEST_BPP_8);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4); // 2 tile big, but 4-tile pitch alignment
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+
+ //test main surface base alignment is 16KB
+ //For Y test main surface pitch is 4-tileY aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X/Y dimension
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.IndirectClearColor = 1;
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(TEST_BPP_8);
+ GMM_TILE_MODE TileMode = LEGACY_TILE_Y;
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[0] * 4); // As wide as 2 tile, but 4-tile pitch alignment
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 4); // 2 tile wide, but 4-tile pitch alignment
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 4 * 2); // 4 tile wide; and 2-tile high
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not tested
+ //test main surface base alignment is 16KB
+ //For Y test main surface pitch is 4-tileY aligned
+ EXPECT_EQ(GMM_KBYTE(64), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetRenderPitchTiles() % 4);
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+
+/// @brief ULT for 2D TileYf Compressed Resource
+TEST_F(CTestGen12dGPUResource, DISABLED_Test2DTileYfAMFSResource)
+{
+ const uint32_t HAlign[TEST_BPP_MAX] = {64, 64, 32, 32, 16};
+ const uint32_t VAlign[TEST_BPP_MAX] = {64, 32, 32, 16, 16};
+
+ const uint32_t TileSize[TEST_BPP_MAX][2] = {{64, 64},
+ {128, 32},
+ {128, 32},
+ {256, 16},
+ {256, 16}};
+
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Type = RESOURCE_2D;
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Flags.Info.TiledY = 1;
+ gmmParams.Flags.Info.TiledYf = 1;
+ gmmParams.Flags.Gpu.Texture = 1;
+ gmmParams.Flags.Gpu.ProceduralTexture = 1;
+ // If unifiedAuxSurf reqd (mandatory for displayable or cross-adapter shared), turn on .CCS/.MMC and .UnifiedAuxSurface too
+
+ //Allocate 1x1 surface
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+ //gmmParams.Flags.Gpu.MMC = 0; //Turn on to check unifiedaux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = 0x1;
+ gmmParams.BaseHeight = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0]); // As wide as 1 Tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 1); // 1 Tile wide
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4)); // 1 Tile Big
+ VerifyResourceQPitch<false>(ResourceInfo, 0); // Not Tested
+
+ //test main surface base alignment is 4KB, since AMFS PT isn't compressed
+ //but uses same linear CCS as compression
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ EXPECT_EQ(0, AuxResourceInfo->GmmGetTileMode());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = 0x1;
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 2); // As wide as 2 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2); // 2 tile wide
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 2); // 2 tile big
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+
+ //test main surface base alignment is 4KB
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ EXPECT_EQ(0, AuxResourceInfo->GmmGetTileMode());
+
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+
+ // Allocate surface that requires multi tiles in two dimension
+ // Allocate 2 tiles in X/Y dimension
+ for(uint32_t i = 0; i < TEST_BPP_MAX; i++)
+ {
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 1; //Turn off for separate aux creation
+ gmmParams.Flags.Gpu.CCS = 1; //Turn off for separate aux creation
+
+ TEST_BPP bpp = static_cast<TEST_BPP>(i);
+ GMM_TILE_MODE TileMode = DEFINE_TILE(YF_2D, bpp);
+ gmmParams.Format = SetResourceFormat(bpp);
+ gmmParams.BaseWidth64 = (TileSize[i][0] / GetBppValue(bpp)) + 1; // 1 pixel larger than 1 tile width
+ gmmParams.BaseHeight = TileSize[i][1] + 1; // 1 row larger than 1 tile height
+ gmmParams.Depth = 0x1;
+
+ GMM_RESOURCE_INFO *ResourceInfo;
+ ResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ VerifyResourceHAlign<true>(ResourceInfo, HAlign[i]);
+ VerifyResourceVAlign<true>(ResourceInfo, VAlign[i]);
+ VerifyResourcePitch<true>(ResourceInfo, TileSize[i][0] * 2); // As wide as 2 tile
+ VerifyResourcePitchInTiles<true>(ResourceInfo, 2); // 2 tile wide
+ VerifyResourceSize<true>(ResourceInfo, GMM_KBYTE(4) * 2 * 2); // 2 tile wide; and 2-tile high
+
+ VerifyResourceQPitch<false>(ResourceInfo, 0);
+ //test main surface base alignment is 4KB
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetBaseAlignment());
+ EXPECT_EQ(0, ResourceInfo->GetUnifiedAuxSurfaceOffset(GMM_AUX_CCS) % PAGE_SIZE);
+ EXPECT_EQ(GMM_KBYTE(4), ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS));
+
+ { //separate Aux
+ gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
+
+ GMM_RESOURCE_INFO *AuxResourceInfo;
+ AuxResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+ EXPECT_EQ(ResourceInfo->GetAuxHAlign(), AuxResourceInfo->GetHAlign());
+ EXPECT_EQ(ResourceInfo->GetAuxVAlign(), AuxResourceInfo->GetVAlign());
+ EXPECT_EQ(ResourceInfo->GetUnifiedAuxPitch(), AuxResourceInfo->GetRenderPitch());
+ EXPECT_EQ(ResourceInfo->GetSizeAuxSurface(GMM_AUX_CCS), AuxResourceInfo->GetSizeSurface());
+ EXPECT_EQ(0, AuxResourceInfo->GmmGetTileMode());
+ pGmmULTClientContext->DestroyResInfoObject(AuxResourceInfo);
+ }
+ pGmmULTClientContext->DestroyResInfoObject(ResourceInfo);
+ }
+}
+
+/// @brief ULT for MSAA Resource - adddepth MSAA, MCS surf param verificaton, compression case
+TEST_F(CTestGen12dGPUResource, DISABLED_TestColorMSAA)
+{
+ //Tile dimensions in Bytes
+ const uint32_t MCSTileSize[1][2] = {128, 32}; //MCS is TileY
+
+ const uint32_t TestDimensions[4][2] = {
+ //Input dimensions in #Tiles
+ {15, 20}, //16 Tiles x 20 <Max Width: Depth MSS crosses Pitch limit beyond this>
+ {0, 0}, //1x1x1
+ {1, 0}, //2 Tilesx1
+ {1, 1}, //2 Tiles x 2
+ };
+
+ uint32_t TestArraySize[2] = {1, 5};
+ uint32_t MinPitch = 32;
+
+ uint32_t HAlign, VAlign, TileDimX, TileDimY, MCSHAlign, MCSVAlign, TileSize;
+ uint32_t ExpectedMCSBpp;
+ std::vector<tuple<int, int, int, bool, int, int>> List; //TEST_TILE_TYPE, TEST_BPP, TEST_RESOURCE_TYPE, Depth or RT, TestDimension index, ArraySize
+ auto Size = BuildInputIterator(List, 4, 2); // Size of arrays TestDimensions, TestArraySize
+
+ for(auto element : List)
+ {
+ GMM_RESCREATE_PARAMS gmmParams = {};
+ gmmParams.Flags.Info = {0};
+
+ TEST_TILE_TYPE Tiling = (TEST_TILE_TYPE)std::get<0>(element);
+ TEST_BPP Bpp = (TEST_BPP)std::get<1>(element);
+ TEST_RESOURCE_TYPE ResType = (TEST_RESOURCE_TYPE)std::get<2>(element);
+ bool IsRT = std::get<3>(element); // True for RT, False for Depth
+ int TestDimIdx = std::get<4>(element); //index into TestDimensions array
+ int ArrayIdx = std::get<5>(element); //index into TestArraySize
+ TileSize = (Tiling == TEST_TILEYS) ? GMM_KBYTE(64) : GMM_KBYTE(4);
+
+ //Discard un-supported Tiling/Res_type/bpp for this test
+ if(ResType != TEST_RESOURCE_2D || //No 1D/3D/Cube. Supported 2D mip-maps/array
+ (!IsRT && (Tiling == TEST_TILEX || //Specifications doesn't support TileX for Depth
+ !(Bpp == TEST_BPP_16 || Bpp == TEST_BPP_32)))) //depth supported on 16bit, 32bit formats only
+ continue;
+
+ if(!IsRT)
+ continue; //comment depth msaa for now (requires change in h/v align)
+
+ SetTileFlag(gmmParams, Tiling);
+ SetResType(gmmParams, ResType);
+ SetResGpuFlags(gmmParams, IsRT);
+ SetResArraySize(gmmParams, TestArraySize[ArrayIdx]);
+
+ gmmParams.NoGfxMemory = 1;
+ gmmParams.Format = SetResourceFormat(Bpp);
+ for(uint32_t k = MSAA_2x; k <= MSAA_16x; k++)
+ {
+ GetAlignmentAndTileDimensionsForMSAA(Bpp, IsRT, Tiling, (TEST_MSAA)k,
+ TileDimX, TileDimY, HAlign, VAlign,
+ ExpectedMCSBpp, MCSHAlign, MCSVAlign);
+
+ //gmmParams.BaseWidth64 = TestDimensions[TestDimIdx][0] * TileDimX + 0x1;
+ //gmmParams.BaseHeight = TestDimensions[TestDimIdx][1] * TileDimY + 0x1;
+ gmmParams.BaseWidth64 = 4;
+ gmmParams.BaseHeight = 4;
+ gmmParams.Depth = 0x1;
+ gmmParams.MSAA.NumSamples = static_cast<uint32_t>(pow((double)2, k));
+ gmmParams.Flags.Gpu.MCS = 0;
+
+ //MSS surface
+ GMM_RESOURCE_INFO *MSSResourceInfo;
+ MSSResourceInfo = pGmmULTClientContext->CreateResInfoObject(&gmmParams);
+
+ if(MSSResourceInfo)
+ {
+ VerifyResourceHAlign<true>(MSSResourceInfo, HAlign);
+ VerifyResourceVAlign<true>(MSSResourceInfo, VAlign);
+ if(IsRT) //Arrayed MSS
+ {
+ uint32_t ExpectedPitch = 0, ExpectedQPitch = 0;
+ ExpectedPitch = GMM_ULT_ALIGN(GMM_ULT_ALIGN(gmmParams.BaseWidth64, HAlign) * (int)pow(2.0, Bpp), TileDimX); // Aligned width * bpp, aligned to TileWidth
+ ExpectedPitch = GFX_MAX(ExpectedPitch, MinPitch);
+ VerifyResourcePitch<true>(MSSResourceInfo, ExpectedPitch);
+ if(Tiling != TEST_LINEAR)
+ VerifyResourcePitchInTiles<true>(MSSResourceInfo, ExpectedPitch / TileDimX);
+
+ ExpectedQPitch = GMM_ULT_ALIGN(gmmParams.BaseHeight, VAlign);
+ if(gmmParams.ArraySize > 1) //Gen9: Qpitch is distance between array slices (not sample slices)
+ {
+ VerifyResourceQPitch<true>(MSSResourceInfo, ExpectedQPitch);
+ }
+
+ uint32_t ExpectedHeight = GMM_ULT_ALIGN(ExpectedQPitch * gmmParams.MSAA.NumSamples * gmmParams.ArraySize, TileDimY); //Align Height =ExpectedPitch * NumSamples * ExpectedQPitch, to Tile-Height
+ VerifyResourceSize<true>(MSSResourceInfo, GMM_ULT_ALIGN(ExpectedPitch * ExpectedHeight, TileSize));
+ }
+ }
+
+ pGmmULTClientContext->DestroyResInfoObject(MSSResourceInfo);
+ } //NumSamples = k
+ } //Iterate through all Input types
+
+ //Mip-mapped, MSAA case:
+}
diff --git a/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.h b/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.h
new file mode 100644
index 0000000..71ea4e1
--- /dev/null
+++ b/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.h
@@ -0,0 +1,39 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+#pragma once
+
+#include "GmmGen10ResourceULT.h"
+#include "../GmmLib/inc/Internal/Common/Platform/GmmGen12Platform.h"
+
+class CTestGen12dGPUResource : public CTestGen10Resource
+{
+public:
+ static void SetUpTestCase();
+ static void TearDownTestCase();
+};
+
+#define DEFINE_TILE(xxx, bpp) \
+ (bpp == TEST_BPP_8) ? TILE_##xxx##_8bpe : \
+ (bpp == TEST_BPP_16) ? TILE_##xxx##_16bpe : \
+ (bpp == TEST_BPP_32) ? TILE_##xxx##_32bpe : \
+ (bpp == TEST_BPP_64) ? TILE_##xxx##_64bpe : \
+ TILE_##xxx##_128bpe
diff --git a/Source/GmmLib/Utility/GmmLibObject.cpp b/Source/GmmLib/Utility/GmmLibObject.cpp
index af3c287..64a0416 100644
--- a/Source/GmmLib/Utility/GmmLibObject.cpp
+++ b/Source/GmmLib/Utility/GmmLibObject.cpp
@@ -28,6 +28,7 @@
#include "External/Common/CachePolicy/GmmCachePolicyGen10.h"
#include "External/Common/CachePolicy/GmmCachePolicyGen11.h"
#include "External/Common/CachePolicy/GmmCachePolicyGen12.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h"
#include "Internal/Common/Texture/GmmTextureCalc.h"
#include "Internal/Common/Texture/GmmGen10TextureCalc.h"
#include "Internal/Common/Texture/GmmGen11TextureCalc.h"
@@ -104,7 +105,14 @@
if (GFX_GET_CURRENT_RENDERCORE(pGmmGlobalContext->GetPlatformInfo().Platform) >= IGFX_GEN12_CORE)
{
- pGmmCachePolicy = new GmmLib::GmmGen12CachePolicy(CachePolicy);
+ if(pGmmGlobalContext->GetSkuTable().FtrLocalMemory)
+ {
+ pGmmCachePolicy = new GmmLib::GmmGen12dGPUCachePolicy(CachePolicy);
+ }
+ else
+ {
+ pGmmCachePolicy = new GmmLib::GmmGen12CachePolicy(CachePolicy);
+ }
}
else if(GFX_GET_CURRENT_RENDERCORE(pGmmGlobalContext->GetPlatformInfo().Platform) >= IGFX_GEN11_CORE)
{
@@ -174,4 +182,4 @@
return new GmmGen12TextureCalc();
break;
}
-}
\ No newline at end of file
+}
diff --git a/Source/GmmLib/inc/External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h b/Source/GmmLib/inc/External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h
new file mode 100644
index 0000000..71ecfbc
--- /dev/null
+++ b/Source/GmmLib/inc/External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h
@@ -0,0 +1,49 @@
+/*==============================================================================
+Copyright(c) 2020 Intel Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files(the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and / or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+============================================================================*/
+#pragma once
+
+#ifdef __cplusplus
+#include "../GmmCachePolicyCommon.h"
+
+namespace GmmLib
+{
+ class NON_PAGED_SECTION GmmGen12dGPUCachePolicy :
+ public GmmGen12CachePolicy
+ {
+ public:
+
+ /* Constructors */
+ GmmGen12dGPUCachePolicy(GMM_CACHE_POLICY_ELEMENT *pCachePolicy):GmmGen12CachePolicy(pCachePolicy)
+ {
+ }
+ virtual ~GmmGen12dGPUCachePolicy()
+ {
+ }
+
+ /* Function prototypes */
+ GMM_STATUS InitCachePolicy();
+ void SetUpMOCSTable();
+ int32_t IsSpecialMOCSUsage(GMM_RESOURCE_USAGE_TYPE Usage, bool& UpdateMOCS);
+
+ };
+}
+#endif // #ifdef __cplusplus
diff --git a/Source/GmmLib/inc/Internal/Common/GmmLibInc.h b/Source/GmmLib/inc/Internal/Common/GmmLibInc.h
index 9f7d9e5..c0f1085 100644
--- a/Source/GmmLib/inc/Internal/Common/GmmLibInc.h
+++ b/Source/GmmLib/inc/Internal/Common/GmmLibInc.h
@@ -39,6 +39,7 @@
#include "External/Common/CachePolicy/GmmCachePolicyGen10.h"
#include "External/Common/CachePolicy/GmmCachePolicyGen11.h"
#include "External/Common/CachePolicy/GmmCachePolicyGen12.h"
+#include "External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h"
#include "External/Common/GmmResourceInfoExt.h"
#include "../Platform/GmmPlatforms.h"
#include "Platform/GmmGen8Platform.h"
@@ -68,4 +69,4 @@
#define D3DKMT_CROSS_ADAPTER_RESOURCE_PITCH_ALIGNMENT 128
#define D3DKMT_CROSS_ADAPTER_RESOURCE_HEIGHT_ALIGNMENT 4
-#endif
\ No newline at end of file
+#endif
diff --git a/Source/inc/common/igfxfmid.h b/Source/inc/common/igfxfmid.h
index c0d4c29..1bab786 100644
--- a/Source/inc/common/igfxfmid.h
+++ b/Source/inc/common/igfxfmid.h
@@ -66,6 +66,7 @@
IGFX_JASPERLAKE,
IGFX_ELKHARTLAKE =IGFX_JASPERLAKE,
IGFX_TIGERLAKE_LP,
+ IGFX_DG1 = 1210,
IGFX_MAX_PRODUCT,
@@ -270,6 +271,10 @@
#define GFX_GET_CURRENT_PRODUCT(p) ( (p).eProductFamily )
#define GFX_GET_CURRENT_DISPLAYCORE(p) ( (p).eDisplayCoreFamily )
#define GFX_GET_CURRENT_RENDERCORE(p) ( (p).eRenderCoreFamily )
+
+// This macro returns true if the product family is discrete
+#define GFX_IS_DISCRETE_FAMILY(p) ( ( GFX_GET_CURRENT_PRODUCT(p) == IGFX_DG1 ) )
+
// These macros return true/false depending on the current render family.
#define GFX_IS_NAPA_RENDER_FAMILY(p) ( ( GFX_GET_CURRENT_RENDERCORE(p) == IGFX_GEN3_CORE ) || \
( GFX_GET_CURRENT_RENDERCORE(p) == IGFX_GEN3_5_CORE ) )
@@ -1175,6 +1180,8 @@
#define ITGL_LP_1x2x16_DESK_WS_65W_DEVICE_F0_ID 0x9A78 // Desktop WS- S81 - 35W/65W/95W
#define ITGL_LP_GT0_ULT_DEVICE_F0_ID 0x9A7F // GT0 - No GFX, Display Only
+#define DEV_ID_4905 0x4905
+
//LKF
#define ILKF_1x8x8_DESK_DEVICE_F0_ID 0x9840
#define ILKF_GT0_DESK_DEVICE_A0_ID 0x9850
diff --git a/Source/inc/common/sku_wa.h b/Source/inc/common/sku_wa.h
index 0e78b97..160de6c 100644
--- a/Source/inc/common/sku_wa.h
+++ b/Source/inc/common/sku_wa.h
@@ -98,6 +98,7 @@
unsigned int FtrDriverFLR : 1; // Enable Function Level Reset (Gen11+)
unsigned int FtrLocalMemory : 1;
unsigned int FtrCameraCaptureCaching : 1;
+ unsigned int FtrLocalMemoryAllows4KB : 1;
};
