Skip to content

GMM Global Context Removal #91

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 14 commits into from
Closed

GMM Global Context Removal #91

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
14 commits
Select commit Hold shift + click to select a range
e6be1b1
Phase 1: As part of global and static code removal- GMM policy, plafo…
johnmach Aug 19, 2021
0b89ef1
Updating the GMM #define to make sure it uses parameterized GMMlib Co…
johnmach Aug 27, 2021
13a5749
Replace pGmmGlobalContext with member variable with pGmmLibContext in…
johnmach Aug 30, 2021
bebc475
Replace pGmmGlobalContext with pGmmLibContext in all Platform Class r…
johnmach Aug 31, 2021
305802c
Remove any remaining use of pGmmGlobalContext
johnmach Aug 31, 2021
fca3040
Phase 2: Update Macros to use pGmmLibContext (local) instead of globa…
johnmach Sep 1, 2021
58737f2
Replace pGmmGlobalContext with pGmmUMDLibContext/pGmmKMDLibContext in…
johnmach Sep 1, 2021
1feaacc
All KMD level pGmmGlobalContext global variable is removed and replac…
johnmach Sep 2, 2021
1aefbb2
Phase 3: Add support for Multi-Adapter in GMM UMD Library and replace…
johnmach Sep 15, 2021
a91ddbf
Make GMM UMD DLL Initialize and Destroy APIs backward compatible for …
johnmach Sep 16, 2021
979048d
Phase 4: Enable and add support for Multi-Adapter ULT for GMM UMD DLL…
johnmach Sep 16, 2021
21ad984
Update the Entry-Level Init and destroy APIs
johnmach Oct 14, 2021
00399f3
Phase 5: Remove the pGmmGlobalContext Global and its dependencies
johnmach Oct 14, 2021
6061622
Initial cleanup of KMD code
johnmach Nov 24, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion Source/GmmLib/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -269,7 +269,6 @@ set(SOURCES_
${BS_DIR_GMMLIB}/Texture/GmmTextureOffset.cpp
${BS_DIR_GMMLIB}/GlobalInfo/GmmInfo.cpp
${BS_DIR_GMMLIB}/Utility/CpuSwizzleBlt/CpuSwizzleBlt.c
${BS_DIR_GMMLIB}/Utility/GmmLibObject.cpp
${BS_DIR_GMMLIB}/Utility/GmmLog/GmmLog.cpp
${BS_DIR_GMMLIB}/Utility/GmmUtility.cpp
)
Expand Down
62 changes: 34 additions & 28 deletions Source/GmmLib/CachePolicy/GmmCachePolicy.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,30 +26,32 @@ OTHER DEALINGS IN THE SOFTWARE.
/////////////////////////////////////////////////////////////////////////////////////
/// C Wrapper function for GmmLib::GmmCachePolicyGetPteType
/// @see GmmLib::GmmCachePolicyCommon::CachePolicyGetPteType()
///
//
/// @param[in] pLibContext: pGmmLibContext
/// @param[in] Usage: type of usage
///
/// @return GMM_PTE_CACHE_CONTROL_BITS:Populated PTE
///
/////////////////////////////////////////////////////////////////////////////////////
GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmCachePolicyGetPteType(GMM_RESOURCE_USAGE_TYPE Usage)
GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmCachePolicyGetPteType(void *pLibContext, GMM_RESOURCE_USAGE_TYPE Usage)
{
return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetPteType(Usage);
GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetPteType(Usage);
}

/////////////////////////////////////////////////////////////////////////////////////
/// C Wrapper function for GmmLib::GmmCachePolicyIsUsagePTECached
/// @see GmmLib::GmmCachePolicyCommon::CachePolicyIsUsagePTECached()
///
/// @param[in] pLibContext: pGmmLibContext
/// @param[in] Usage: type of usage
///
/// @return 1 if the usage PTE entry is set for cached, 0 otherwise.
/////////////////////////////////////////////////////////////////////////////////////
uint8_t GMM_STDCALL GmmCachePolicyIsUsagePTECached(GMM_RESOURCE_USAGE_TYPE Usage)
uint8_t GMM_STDCALL GmmCachePolicyIsUsagePTECached(void *pLibContext, GMM_RESOURCE_USAGE_TYPE Usage)
{
return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyIsUsagePTECached(Usage);
GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
return pGmmLibContext->GetCachePolicyObj()->CachePolicyIsUsagePTECached(Usage);
}

/////////////////////////////////////////////////////////////////////////////////////
/// C wrapper for GmmLib::GmmResourceInfoCommon::GetCachePolicyUsage.
/// @see GmmLib::GmmResourceInfoCommon::GetCachePolicyUsage()
Expand Down Expand Up @@ -85,9 +87,10 @@ void GMM_STDCALL GmmCachePolicyOverrideResourceUsage(GMM_RESOURCE_INFO *pResInfo
/// @return MEMORY_OBJECT_CONTROL_STATE: Gen adjusted MOCS structure (cache
/// policy) for the given buffer use.
/////////////////////////////////////////////////////////////////////////////////////
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(void *pLibContext, GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
{
return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetMemoryObject(pResInfo, Usage);
GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetMemoryObject(pResInfo, Usage);
}

/////////////////////////////////////////////////////////////////////////////////////
Expand All @@ -100,58 +103,61 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetMemoryObject(GMM_RESOUR
/// @return MEMORY_OBJECT_CONTROL_STATE: Populated memory object
///
/////////////////////////////////////////////////////////////////////////////////////
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetOriginalMemoryObject(GMM_RESOURCE_INFO *pResInfo)
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmCachePolicyGetOriginalMemoryObject(void *pLibContext, GMM_RESOURCE_INFO *pResInfo)
{
return pGmmGlobalContext->GetCachePolicyObj()->CachePolicyGetOriginalMemoryObject(pResInfo);
GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
return pGmmLibContext->GetCachePolicyObj()->CachePolicyGetOriginalMemoryObject(pResInfo);
}

/////////////////////////////////////////////////////////////////////////////////////
/// C Wrapper function for GmmCachePolicy::GmmGetWantedMemoryType.
/// @see GmmLib::GmmCachePolicy::GetWantedMemoryType()
///
/// @param[in] CachePolicy:cache policy for a usage
/// @param[in] pLibContext: pGmmLibContext
///
/// @return wanted memory type
/////////////////////////////////////////////////////////////////////////////////////
GMM_GFX_MEMORY_TYPE GmmGetWantedMemoryType(GMM_CACHE_POLICY_ELEMENT CachePolicy)
GMM_GFX_MEMORY_TYPE GmmGetWantedMemoryType(void *pLibContext, GMM_CACHE_POLICY_ELEMENT CachePolicy)
{
return pGmmGlobalContext->GetCachePolicyObj()->GetWantedMemoryType(CachePolicy);
GMM_LIB_CONTEXT *pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
return pGmmLibContext->GetCachePolicyObj()->GetWantedMemoryType(CachePolicy);
}

/////////////////////////////////////////////////////////////////////////////////////
/// Returns count of current MOCS values for MOCS Table programming at GMM boot
///
/// @param[in] none:
/// @param[in] pLibContext: pGmmLibContext
/// @return uint32_t no of mocs register required to program
/////////////////////////////////////////////////////////////////////////////////////
uint32_t GMM_STDCALL GmmCachePolicyGetMaxMocsIndex(void)
uint32_t GMM_STDCALL GmmCachePolicyGetMaxMocsIndex(void *pLibContext)
{
GMM_CACHE_POLICY * pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
GmmLib::GmmGen9CachePolicy *ptr = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
GMM_LIB_CONTEXT * pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
GMM_CACHE_POLICY * pCachePolicy = pGmmLibContext->GetCachePolicyObj();
GmmLib::GmmGen9CachePolicy *ptr = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
return ptr->CurrentMaxMocsIndex;
}

/////////////////////////////////////////////////////////////////////////////////////
/// Returns count of current L1 HDC MOCS values for MOCS Table programming at GMM boot
///
/// @param[in] none:
/// @param[in] pLibContext: pGmmLibContext
/// @return uint32_t max L1 hdc mocs index needed to program
/////////////////////////////////////////////////////////////////////////////////////
uint32_t GMM_STDCALL GmmCachePolicyGetMaxL1HdcMocsIndex(void)
uint32_t GMM_STDCALL GmmCachePolicyGetMaxL1HdcMocsIndex(void *pLibContext)
{
GMM_CACHE_POLICY * pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
GmmLib::GmmGen9CachePolicy *ptr = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
GMM_LIB_CONTEXT * pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
GMM_CACHE_POLICY * pCachePolicy = pGmmLibContext->GetCachePolicyObj();
GmmLib::GmmGen9CachePolicy *ptr = static_cast<GmmLib::GmmGen9CachePolicy *>(pCachePolicy);
return ptr->CurrentMaxL1HdcMocsIndex;
}

/////////////////////////////////////////////////////////////////////////////////////
/// Returns count of current Special MOCS values for MOCS Table programming at GMM boot
///
/// @param[in] none:
/// @param[in] pLibContext: pGmmLibContext
/// @return uint32_t max special mocs index needed to program
/////////////////////////////////////////////////////////////////////////////////////
uint32_t GMM_STDCALL GmmCachePolicyGetMaxSpecialMocsIndex(void)
uint32_t GMM_STDCALL GmmCachePolicyGetMaxSpecialMocsIndex(void *pLibContext)
{
GMM_CACHE_POLICY *pCachePolicy = pGmmGlobalContext->GetCachePolicyObj();
GMM_LIB_CONTEXT * pGmmLibContext = (GMM_LIB_CONTEXT *)pLibContext;
GMM_CACHE_POLICY *pCachePolicy = pGmmLibContext->GetCachePolicyObj();
return pCachePolicy->GetMaxSpecialMocsIndex();
}
}
18 changes: 8 additions & 10 deletions Source/GmmLib/CachePolicy/GmmCachePolicyCommon.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,15 +23,14 @@ OTHER DEALINGS IN THE SOFTWARE.
#include "Internal/Common/GmmLibInc.h"
#include "External/Common/GmmCachePolicy.h"

int32_t GmmLib::GmmCachePolicyCommon::RefCount = 0;

/////////////////////////////////////////////////////////////////////////////////////
/// Constructor for the GmmCachePolicyCommon Class, initializes the CachePolicy
/// @param[in] pCachePolicy
/////////////////////////////////////////////////////////////////////////////////////
GmmLib::GmmCachePolicyCommon::GmmCachePolicyCommon(GMM_CACHE_POLICY_ELEMENT *pCachePolicy)
GmmLib::GmmCachePolicyCommon::GmmCachePolicyCommon(GMM_CACHE_POLICY_ELEMENT *pCachePolicy, Context *pGmmLibContext)
{
this->pCachePolicy = pCachePolicy;
this->pCachePolicy = pCachePolicy;
this->pGmmLibContext = pGmmLibContext;
}

/////////////////////////////////////////////////////////////////////////////////////
Expand Down Expand Up @@ -70,7 +69,7 @@ GMM_GFX_MEMORY_TYPE GmmLib::GmmCachePolicyCommon::GetWantedMemoryType(GMM_CACHE_
/////////////////////////////////////////////////////////////////////////////////////
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetOriginalMemoryObject(GMM_RESOURCE_INFO *pResInfo)
{
MEMORY_OBJECT_CONTROL_STATE MOCS = pGmmGlobalContext->GetCachePolicyElement(GMM_RESOURCE_USAGE_UNKNOWN).MemoryObjectOverride;
MEMORY_OBJECT_CONTROL_STATE MOCS = pGmmLibContext->GetCachePolicyElement(GMM_RESOURCE_USAGE_UNKNOWN).MemoryObjectOverride;

if(pResInfo)
{
Expand All @@ -94,9 +93,8 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolic
MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetMemoryObject(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage)
{
const GMM_CACHE_POLICY_ELEMENT *CachePolicy = NULL;
__GMM_ASSERT(pGmmGlobalContext->GetCachePolicyElement(Usage).Initialized);
CachePolicy = pGmmGlobalContext->GetCachePolicyUsage();

__GMM_ASSERT(pGmmLibContext->GetCachePolicyElement(Usage).Initialized);
CachePolicy = pGmmLibContext->GetCachePolicyUsage();
// Prevent wrong Usage for XAdapter resources. UMD does not call GetMemoryObject on shader resources but,
// when they add it someone could call it without knowing the restriction.
if(pResInfo &&
Expand Down Expand Up @@ -129,6 +127,6 @@ MEMORY_OBJECT_CONTROL_STATE GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolic
/////////////////////////////////////////////////////////////////////////////////////
GMM_PTE_CACHE_CONTROL_BITS GMM_STDCALL GmmLib::GmmCachePolicyCommon::CachePolicyGetPteType(GMM_RESOURCE_USAGE_TYPE Usage)
{
__GMM_ASSERT(pGmmGlobalContext->GetCachePolicyElement(Usage).Initialized);
return pGmmGlobalContext->GetCachePolicyElement(Usage).PTE;
__GMM_ASSERT(pGmmLibContext->GetCachePolicyElement(Usage).Initialized);
return pGmmLibContext->GetCachePolicyElement(Usage).PTE;
}
14 changes: 7 additions & 7 deletions Source/GmmLib/CachePolicy/GmmCachePolicyConditionals.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,18 +20,18 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
============================================================================*/

#define PRODUCT(X) (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) == IGFX_##X)
#define ISPRODUCT(X) (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_##X)

#define FROMPRODUCT(X) (GFX_GET_CURRENT_PRODUCT(pGmmGlobalContext->GetPlatformInfo().Platform) >= IGFX_##X)
#define FROMPRODUCT(X) (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) >= IGFX_##X)

#define SKU(FtrXxx) (pGmmGlobalContext->GetSkuTable().FtrXxx != 0)
#define SKU(FtrXxx) (pGmmLibContext->GetSkuTable().FtrXxx != 0)

#define WA(WaXxx) (pGmmGlobalContext->GetWaTable().WaXxx != 0)
#define WA(WaXxx) (pGmmLibContext->GetWaTable().WaXxx != 0)

// Underscored to prevent name collision with the GMM_CACHE_POLICY_ELEMENT fields named L3 and LLC
#define _L3 (pGmmGlobalContext->GetGtSysInfo()->L3CacheSizeInKb)
#define _LLC (pGmmGlobalContext->GetGtSysInfo()->LLCCacheSizeInKb)
#define _ELLC (pGmmGlobalContext->GetGtSysInfo()->EdramSizeInKb)
#define _L3 (pGmmLibContext->GetGtSysInfo()->L3CacheSizeInKb)
#define _LLC (pGmmLibContext->GetGtSysInfo()->LLCCacheSizeInKb)
#define _ELLC (pGmmLibContext->GetGtSysInfo()->EdramSizeInKb)
#define CAM$ (SKU(FtrCameraCaptureCaching))

// Units are already in KB in the system information, so these helper macros need to account for that
Expand Down
32 changes: 17 additions & 15 deletions Source/GmmLib/CachePolicy/GmmGen10CachePolicy.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -67,7 +67,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::InitCachePolicy()

uint32_t CurrentMaxIndex = 0;
uint32_t CurrentMaxHDCL1Index = GMM_GEN10_HDCL1_MOCS_INDEX_START - 1; // define constant
GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = pGmmGlobalContext->GetCachePolicyTlbElement();
GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = pGmmLibContext->GetCachePolicyTlbElement();

// index 0 is uncached.
{
Expand Down Expand Up @@ -254,7 +254,10 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetPATInitWA()
GMM_STATUS Status = GMM_SUCCESS;

#if(defined(__GMM_KMD__))

if(pGmmLibContext->GetGtSysInfoPtr()->EdramSizeInKb)
{
const_cast<WA_TABLE &>(pGmmLibContext->GetWaTable()).WaNoMocsEllcOnly = 1;
}
#else
Status = GMM_ERROR;
#endif
Expand Down Expand Up @@ -346,10 +349,9 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
uint8_t Age = 1;
uint8_t ServiceClass = 0;
int32_t * pPrivatePATTableMemoryType = NULL;
pPrivatePATTableMemoryType = pGmmGlobalContext->GetPrivatePATTableMemoryType();

__GMM_ASSERT(pGmmGlobalContext->GetSkuTable().FtrIA32eGfxPTEs);
pPrivatePATTableMemoryType = pGmmLibContext->GetPrivatePATTableMemoryType();

__GMM_ASSERT(pGmmLibContext->GetSkuTable().FtrIA32eGfxPTEs);
for(i = 0; i < GMM_NUM_GFX_PAT_TYPES; i++)
{
pPrivatePATTableMemoryType[i] = -1;
Expand All @@ -360,7 +362,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
{
GMM_PRIVATE_PAT PAT = {0};

if(pGmmGlobalContext->GetWaTable().FtrMemTypeMocsDeferPAT)
if(pGmmLibContext->GetWaTable().WaNoMocsEllcOnly)
{
GfxTargetCache = GMM_GFX_TC_ELLC_ONLY;
}
Expand All @@ -372,12 +374,12 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
switch(i)
{
case PAT0:
if(pGmmGlobalContext->GetWaTable().WaGttPat0)
{
if(pGmmGlobalContext->GetWaTable().WaGttPat0WB)
{
if(pGmmLibContext->GetWaTable().WaGttPat0)
{
if(pGmmLibContext->GetWaTable().WaGttPat0WB)
{
GfxMemType = GMM_GFX_WB;
if(GFX_IS_ATOM_PLATFORM)
if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
{
PAT.PreGen10.Snoop = 1;
}
Expand All @@ -392,7 +394,7 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
else // if GTT is not tied to PAT0 then WaGttPat0WB is NA
{
GfxMemType = GMM_GFX_WB;
if(GFX_IS_ATOM_PLATFORM)
if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
{
PAT.PreGen10.Snoop = 1;
}
Expand All @@ -401,10 +403,10 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
break;

case PAT1:
if(pGmmGlobalContext->GetWaTable().WaGttPat0 && !pGmmGlobalContext->GetWaTable().WaGttPat0WB)
if(pGmmLibContext->GetWaTable().WaGttPat0 && !pGmmLibContext->GetWaTable().WaGttPat0WB)
{
GfxMemType = GMM_GFX_WB;
if(GFX_IS_ATOM_PLATFORM)
if(GFX_IS_ATOM_PLATFORM(pGmmLibContext))
{
PAT.PreGen10.Snoop = 1;
}
Expand Down Expand Up @@ -460,4 +462,4 @@ GMM_STATUS GmmLib::GmmGen10CachePolicy::SetupPAT()
Status = GMM_ERROR;
#endif
return Status;
}
}
2 changes: 1 addition & 1 deletion Source/GmmLib/CachePolicy/GmmGen10CachePolicy.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
#define FBLLC (SKU(FtrFrameBufferLLC))

//eDRAM-Only caching, for a usage that might be encrypted, must use ENCRYPTED_PARTIALS_EDRAM
#define ENCRYPTED_PARTIALS_EDRAM (EDRAM && !(pGmmGlobalContext->GetWaTable().WaEncryptedEdramOnlyPartials))
#define ENCRYPTED_PARTIALS_EDRAM (EDRAM && !(pGmmLibContext->GetWaTable().WaEncryptedEdramOnlyPartials))

// Cache Policy Definition
// AOM = Do not allocate on miss (0 = allocate on miss [normal cache behavior], 1 = don't allocate on miss)
Expand Down
Loading