From 9b4d7b1d0fa6ea0c75eb5b030e28ff3ea55184c9 Mon Sep 17 00:00:00 2001 From: zhangyichix Date: Fri, 1 Dec 2023 10:36:19 +0800 Subject: [PATCH] Upgrade to release tag: intel-gmmlib-22.3.12 * Release tag: https://github.com/intel/gmmlib/releases/tag/intel-gmmlib-22.3.12 Tracked-On: OAM-113713 Signed-off-by: zhangyichix --- README.rst | 2 +- Security.md | 6 + Source/GmmLib/GlobalInfo/GmmInfo.cpp | 2 +- Source/GmmLib/GlobalInfo/GmmLibDllMain.cpp | 19 - Source/GmmLib/ULT/GmmMultiAdapterULT.cpp | 494 ++++++++++-------- Source/GmmLib/ULT/GmmMultiAdapterULT.h | 184 ++----- Source/GmmLib/inc/External/Common/GmmLibDll.h | 1 - .../inc/External/Common/GmmLibDllName.h | 6 - Source/inc/common/igfxfmid.h | 69 ++- 9 files changed, 392 insertions(+), 391 deletions(-) create mode 100644 Security.md diff --git a/README.rst b/README.rst index 516cf82..9b464e8 100644 --- a/README.rst +++ b/README.rst @@ -33,7 +33,7 @@ Building 4) Run the cmake command to prepare build files - ``$ cmake [-DCMAKE_BUILD_TYPE= Release | Debug | ReleaseInternal] [-DARCH= 64 | 32] ..`` + ``$ cmake [-DCMAKE_BUILD_TYPE= Release | Debug | ReleaseInternal] ..`` 5) Build the project diff --git a/Security.md b/Security.md new file mode 100644 index 0000000..5c2ff35 --- /dev/null +++ b/Security.md @@ -0,0 +1,6 @@ +# Security Policy + +Intel is committed to rapidly addressing security vulnerabilities affecting our customers and providing clear guidance on the solution, impact, severity and mitigation. + +## Reporting a Vulnerability +Please report any security vulnerabilities in this project utilizing the guidelines [here](https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html). diff --git a/Source/GmmLib/GlobalInfo/GmmInfo.cpp b/Source/GmmLib/GlobalInfo/GmmInfo.cpp index ec2be20..db81fd6 100644 --- a/Source/GmmLib/GlobalInfo/GmmInfo.cpp +++ b/Source/GmmLib/GlobalInfo/GmmInfo.cpp @@ -1075,7 +1075,7 @@ GMM_CACHE_POLICY *GMM_STDCALL GmmLib::Context::CreateCachePolicyCommon() return GetCachePolicyObj(); } - if((GFX_GET_CURRENT_PRODUCT(GetPlatformInfo().Platform) == IGFX_METEORLAKE)) + if((GFX_GET_CURRENT_PRODUCT(GetPlatformInfo().Platform) == IGFX_METEORLAKE) || (GFX_GET_CURRENT_PRODUCT(GetPlatformInfo().Platform) == IGFX_ARROWLAKE)) { pGmmCachePolicy = new GmmLib::GmmXe_LPGCachePolicy(CachePolicy, this); } diff --git a/Source/GmmLib/GlobalInfo/GmmLibDllMain.cpp b/Source/GmmLib/GlobalInfo/GmmLibDllMain.cpp index 0fa6a7a..117a5d8 100755 --- a/Source/GmmLib/GlobalInfo/GmmLibDllMain.cpp +++ b/Source/GmmLib/GlobalInfo/GmmLibDllMain.cpp @@ -34,25 +34,6 @@ OTHER DEALINGS IN THE SOFTWARE. #include "External/Common/GmmClientContext.h" #include "External/Common/GmmLibDll.h" -///////////////////////////////////////////////////////////////////////////////////// -/// First Call to GMM Lib DLL/so to get the DLL/so exported fucntion pointers -/// -///////////////////////////////////////////////////////////////////////////////////// -extern "C" GMM_LIB_API GMM_STATUS GMM_STDCALL OpenGmm(GmmExportEntries *pm_GmmFuncs) -{ - GMM_STATUS Status = GMM_SUCCESS; - if(pm_GmmFuncs) - { - //TODO - } - else - { - Status = GMM_INVALIDPARAM; - } - - return Status; -} - ///////////////////////////////////////////////////////////////////////////////////// // First Call to GMM Lib DLL/so to initialize singleton global context // and create client context diff --git a/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp b/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp index 39d2b4c..aa6ac6c 100644 --- a/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp +++ b/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp @@ -25,71 +25,51 @@ OTHER DEALINGS IN THE SOFTWARE. #endif #include -ADAPTER_INFO * MACommonULT::pGfxAdapterInfo[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -PLATFORM MACommonULT::GfxPlatform[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -GMM_LIB_CONTEXT * MACommonULT::pLibContext[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -GMM_CLIENT_CONTEXT *MACommonULT::pGmmULTClientContext[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -PFNGMMINIT MACommonULT::pfnGmmInit[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -PFNGMMDESTROY MACommonULT::pfnGmmDestroy[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -GMM_INIT_IN_ARGS MACommonULT::InArgs[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -GMM_INIT_OUT_ARGS MACommonULT::OutArgs[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; -GMM_DLL_HANDLE MACommonULT::hGmmLib[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - -// Comman array for all thread related ULTs to supply Adapter-Client Context input. -ThreadInParams MACommonULT::InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; - -// Array to store the adapter BDFs from simulated UMD, Save the adapter bdf in an array. -ADAPTER_BDF MACommonULT::AdpaterSaved[MAX_NUM_ADAPTERS]; - MACommonULT::MACommonULT() { -} - -MACommonULT::~MACommonULT() -{ -} + // Ideally this should be in the SetUp function for each test case, but since there are + // wrapper classes around this for the test suites and SetUp does not get called on this + // class, it needs to go in the constructor which gets created for each test case. -void MACommonULT::SetUpTestCase() -{ -} + //reset all test info + memset(GmmTestInfo, 0, sizeof(GmmTestInfo)); + memset(AdapterSaved, 0, sizeof(AdapterSaved)); -void MACommonULT::TearDownTestCase() -{ -} + hGmmLib = NULL; + pfnGmmDestroy = NULL; + pfnGmmInit = NULL; -CTestMA::CTestMA() -{ - uint32_t i = 0; + //set a seed value so the test is always reproducible + srand(0); - memset(AdpaterSaved, 0, sizeof(AdpaterSaved)); // Save the random Generated bdf value in an array during intantiation itself // These value remain live for each of the ULT lifetime. - for(i = 0; i < MAX_NUM_ADAPTERS; i++) + for (int i = 0; i < MAX_NUM_ADAPTERS; i++) { - AdpaterSaved[i].Bus = rand() / 100; - AdpaterSaved[i].Device = rand() / 100; - AdpaterSaved[i].Function = rand() / 100; - AdpaterSaved[i].Reserved = 0; + AdapterSaved[i].Bus = rand() / 100; + AdapterSaved[i].Device = rand() / 100; + AdapterSaved[i].Function = rand() / 100; + AdapterSaved[i].Reserved = 0; } // Validate the generated BDfs are unique // No two Adapter's BDF should be equal on a PCI bus. - for(i = 0; i < MAX_NUM_ADAPTERS; i++) + for (int i = 0; i < MAX_NUM_ADAPTERS; i++) { - for(uint32_t j = 0; j < MAX_NUM_ADAPTERS; j++) + for (int j = 0; j < MAX_NUM_ADAPTERS; j++) { - if(i != j) + if (i != j) { - if(AdpaterSaved[i].Bus == AdpaterSaved[j].Bus) + if (AdapterSaved[i].Bus == AdapterSaved[j].Bus) { - if(AdpaterSaved[i].Device == AdpaterSaved[j].Device) + if (AdapterSaved[i].Device == AdapterSaved[j].Device) { - if(AdpaterSaved[i].Function == AdpaterSaved[j].Function) + if (AdapterSaved[i].Function == AdapterSaved[j].Function) { // OOps! Generated BDFs are equal. // Lets change any one field to make it unique // Lets increment Bus. - AdpaterSaved[j].Bus++; + AdapterSaved[j].Bus++; } } } @@ -98,6 +78,14 @@ CTestMA::CTestMA() } } +MACommonULT::~MACommonULT() +{ +} + +CTestMA::CTestMA() +{ +} + CTestMA::~CTestMA() { } @@ -110,101 +98,251 @@ void CTestMA::TearDownTestCase() { } -void MACommonULT::LoadGmmDll(uint32_t AdapterIdx, uint32_t CountIdx) +void CTestMA::SetUp() { - hGmmLib[AdapterIdx][CountIdx] = dlopen(GMM_UMD_DLL, RTLD_LAZY); - ASSERT_TRUE(hGmmLib[AdapterIdx][CountIdx]); + LoadGmmDll(); +} - *(void **)(&pfnGmmInit[AdapterIdx][CountIdx]) = dlsym(hGmmLib[AdapterIdx][CountIdx], "InitializeGmm"); - *(void **)(&pfnGmmDestroy[AdapterIdx][CountIdx]) = dlsym(hGmmLib[AdapterIdx][CountIdx], "GmmAdapterDestroy"); +void CTestMA::TearDown() +{ + UnLoadGmmDll(); +} - ASSERT_TRUE(pfnGmmInit[AdapterIdx][CountIdx]); - ASSERT_TRUE(pfnGmmDestroy[AdapterIdx][CountIdx]); +void MACommonULT::LoadGmmDll() +{ + hGmmLib = dlopen(GMM_UMD_DLL, RTLD_LAZY); + ASSERT_TRUE(hGmmLib); + + *(void **)(&pfnGmmInit) = dlsym(hGmmLib, "InitializeGmm"); + *(void **)(&pfnGmmDestroy) = dlsym(hGmmLib, "GmmAdapterDestroy"); + + ASSERT_TRUE(pfnGmmInit); + ASSERT_TRUE(pfnGmmDestroy); +} + +void MACommonULT::UnLoadGmmDll() +{ + if (hGmmLib) + { + dlclose(hGmmLib); + + hGmmLib = NULL; + pfnGmmInit = NULL; + pfnGmmDestroy = NULL; + } +} + +// Lets test with the recent GPUs till 32nd adapters and take IGFX_COFFEELAKE for 32+ adapters +// Only for our ULT to supply dummy ProductFamily +PRODUCT_FAMILY MACommonULT::GetProductFamily(uint32_t AdapterIdx) +{ + switch (AdapterIdx) + { + case 0: + return IGFX_DG1; + case 1: + return IGFX_ICELAKE; + case 2: + return IGFX_TIGERLAKE_LP; + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return IGFX_DG2; + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + return IGFX_XE_HP_SDV; + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + return IGFX_PVC; + case 30: + case 31: + default: + break; + } + return IGFX_COFFEELAKE; } -void MACommonULT::UnLoadGmmDll(uint32_t AdapterIdx, uint32_t CountIdx) +// Lets test with the recent GPUs till 32nd adpater and take IGFX_GEN9_CORE for 32+ adapters +// Only for our ULT to supply dummy GFXCORE_FAMILY +GFXCORE_FAMILY MACommonULT::GetRenderCoreFamily(uint32_t AdapterIdx) { - if(hGmmLib[AdapterIdx][CountIdx]) + switch (AdapterIdx) { - dlclose(hGmmLib[AdapterIdx][CountIdx]); - hGmmLib[AdapterIdx][CountIdx] = NULL; + case 0: + return IGFX_XE_HP_CORE; + case 1: + return IGFX_GEN11LP_CORE; + case 2: + return IGFX_GEN12LP_CORE; + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return IGFX_XE_HPG_CORE; + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + return IGFX_XE_HP_CORE; + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 29: + return IGFX_XE_HPC_CORE; + case 30: + case 31: + default: + break; } + return IGFX_GEN9_CORE; +} + +// To simulate the UMDs/ClinentContexts per adapter i.e MAX_COUNT_PER_ADAPTER +// Increase MAX_COUNT_PER_ADAPTER value if there are more UMDs involved +GMM_CLIENT MACommonULT::GetClientType(uint32_t CountIdx) +{ + switch (CountIdx) + { + case 0: + return GMM_D3D9_VISTA; + case 1: + return GMM_D3D10_VISTA; + case 2: + return GMM_D3D12_VISTA; + case 3: + return GMM_EXCITE_VISTA; + case 4: + return GMM_OCL_VISTA; + default: + break; + } + return GMM_D3D9_VISTA; +} + +// Returns the AdapterSaved array value, Adapter BDFs based on input AdapterIdx +ADAPTER_BDF MACommonULT::GetAdapterBDF(uint32_t AdapterIdx) +{ + ADAPTER_BDF AdapterBDF = {0, 2, 0, 0}; + + if (AdapterIdx < MAX_NUM_ADAPTERS) + { + AdapterBDF.Bus = AdapterSaved[AdapterIdx].Bus; + AdapterBDF.Device = AdapterSaved[AdapterIdx].Device; + AdapterBDF.Function = AdapterSaved[AdapterIdx].Function; + } + return AdapterBDF; } void MACommonULT::GmmInitModule(uint32_t AdapterIdx, uint32_t CountIdx) { ASSERT_TRUE(AdapterIdx < MAX_NUM_ADAPTERS); - GMM_STATUS Status = GMM_SUCCESS; - ADAPTER_BDF AdapterBDF = GetAdapterBDF(AdapterIdx); - GfxPlatform[AdapterIdx][CountIdx].eProductFamily = GetProductFamily(AdapterIdx); - GfxPlatform[AdapterIdx][CountIdx].eRenderCoreFamily = GetRenderCoreFamily(AdapterIdx); + GMM_STATUS Status = GMM_SUCCESS; + ADAPTER_BDF AdapterBDF = GetAdapterBDF(AdapterIdx); + GmmTestInfo[AdapterIdx][CountIdx].GfxPlatform.eProductFamily = GetProductFamily(AdapterIdx); + GmmTestInfo[AdapterIdx][CountIdx].GfxPlatform.eRenderCoreFamily = GetRenderCoreFamily(AdapterIdx); - if(!pGfxAdapterInfo[AdapterIdx][CountIdx]) + if (!GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo) { - pGfxAdapterInfo[AdapterIdx][CountIdx] = (ADAPTER_INFO *)malloc(sizeof(ADAPTER_INFO)); - if(!pGfxAdapterInfo[AdapterIdx][CountIdx]) + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo = (ADAPTER_INFO *)malloc(sizeof(ADAPTER_INFO)); + if (!GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo) { ASSERT_TRUE(false); return; } - memset(pGfxAdapterInfo[AdapterIdx][CountIdx], 0, sizeof(ADAPTER_INFO)); - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrTileY = 1; // Legacy TileY - - if(GfxPlatform[AdapterIdx][CountIdx].eRenderCoreFamily >= IGFX_GEN12_CORE) + memset(GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo, 0, sizeof(ADAPTER_INFO)); + + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrTileY = 1; // Legacy TileY + + if (GmmTestInfo[AdapterIdx][CountIdx].GfxPlatform.eRenderCoreFamily >= IGFX_GEN12_CORE) { - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrWddm2GpuMmu = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrUserModeTranslationTable = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrE2ECompression = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrLinearCCS = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrTileY = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrLLCBypass = 0; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrWddm2Svm = 0; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrWddm2GpuMmu = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrUserModeTranslationTable = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrE2ECompression = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrLinearCCS = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrTileY = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrLLCBypass = 0; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrWddm2Svm = 0; // keep this disabled for pagetablemgr testing + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrSVM = 1; // keep this enabled for pagetablemgr testing + //GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.WaUntypedBufferCompression = 1; } - if(IGFX_DG1 == GfxPlatform[AdapterIdx][CountIdx].eProductFamily) + if (IGFX_DG1 == GmmTestInfo[AdapterIdx][CountIdx].GfxPlatform.eProductFamily) { - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrLinearCCS = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrStandardMipTailFormat = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrTileY = 0; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrLocalMemory = 1; - pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable.FtrWddm2_1_64kbPages = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrLinearCCS = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrStandardMipTailFormat = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrTileY = 0; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrLocalMemory = 1; + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable.FtrWddm2_1_64kbPages = 1; } - } - InArgs[AdapterIdx][CountIdx].ClientType = GetClientType(CountIdx); - InArgs[AdapterIdx][CountIdx].pGtSysInfo = &pGfxAdapterInfo[AdapterIdx][CountIdx]->SystemInfo; - InArgs[AdapterIdx][CountIdx].pSkuTable = &pGfxAdapterInfo[AdapterIdx][CountIdx]->SkuTable; - InArgs[AdapterIdx][CountIdx].pWaTable = &pGfxAdapterInfo[AdapterIdx][CountIdx]->WaTable; - InArgs[AdapterIdx][CountIdx].Platform = GfxPlatform[AdapterIdx][CountIdx]; + + GmmTestInfo[AdapterIdx][CountIdx].InArgs.ClientType = GetClientType(CountIdx); + GmmTestInfo[AdapterIdx][CountIdx].InArgs.pGtSysInfo = &GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SystemInfo; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.pSkuTable = &GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->SkuTable; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.pWaTable = &GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo->WaTable; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.Platform = GmmTestInfo[AdapterIdx][CountIdx].GfxPlatform; #if LHDM - InArgs[AdapterIdx][CountIdx].stAdapterBDF = AdapterBDF; - InArgs[AdapterIdx][CountIdx].DeviceRegistryPath = NULL; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.stAdapterBDF = AdapterBDF; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.DeviceRegistryPath = NULL; #else - InArgs[AdapterIdx][CountIdx].FileDescriptor = AdapterBDF.Data; + GmmTestInfo[AdapterIdx][CountIdx].InArgs.FileDescriptor = AdapterBDF.Data; #endif - Status = pfnGmmInit[AdapterIdx][CountIdx](&InArgs[AdapterIdx][CountIdx], &OutArgs[AdapterIdx][CountIdx]); + Status = pfnGmmInit(&GmmTestInfo[AdapterIdx][CountIdx].InArgs, &GmmTestInfo[AdapterIdx][CountIdx].OutArgs); EXPECT_EQ(Status, GMM_SUCCESS); - pGmmULTClientContext[AdapterIdx][CountIdx] = OutArgs[AdapterIdx][CountIdx].pGmmClientContext; - ASSERT_TRUE(pGmmULTClientContext[AdapterIdx][CountIdx]); + GmmTestInfo[AdapterIdx][CountIdx].pGmmULTClientContext = GmmTestInfo[AdapterIdx][CountIdx].OutArgs.pGmmClientContext; + ASSERT_TRUE(GmmTestInfo[AdapterIdx][CountIdx].pGmmULTClientContext); - pLibContext[AdapterIdx][CountIdx] = pGmmULTClientContext[AdapterIdx][CountIdx]->GetLibContext(); - ASSERT_TRUE(pLibContext[AdapterIdx][CountIdx]); + GmmTestInfo[AdapterIdx][CountIdx].pLibContext = GmmTestInfo[AdapterIdx][CountIdx].pGmmULTClientContext->GetLibContext(); + ASSERT_TRUE(GmmTestInfo[AdapterIdx][CountIdx].pLibContext); } void MACommonULT::GmmDestroyModule(uint32_t AdapterIdx, uint32_t CountIdx) { - OutArgs[AdapterIdx][CountIdx].pGmmClientContext = pGmmULTClientContext[AdapterIdx][CountIdx]; - pfnGmmDestroy[AdapterIdx][CountIdx](&OutArgs[AdapterIdx][CountIdx]); - pGmmULTClientContext[AdapterIdx][CountIdx] = NULL; - pLibContext[AdapterIdx][CountIdx] = NULL; - if(pGfxAdapterInfo[AdapterIdx][CountIdx]) + GmmTestInfo[AdapterIdx][CountIdx].OutArgs.pGmmClientContext = GmmTestInfo[AdapterIdx][CountIdx].pGmmULTClientContext; + pfnGmmDestroy(&GmmTestInfo[AdapterIdx][CountIdx].OutArgs); + GmmTestInfo[AdapterIdx][CountIdx].pGmmULTClientContext = NULL; + GmmTestInfo[AdapterIdx][CountIdx].pLibContext = NULL; + if (GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo) { - free(pGfxAdapterInfo[AdapterIdx][CountIdx]); - pGfxAdapterInfo[AdapterIdx][CountIdx] = NULL; + free(GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo); + GmmTestInfo[AdapterIdx][CountIdx].pGfxAdapterInfo = NULL; } } @@ -213,7 +351,7 @@ void MACommonULT::GmmDestroyModule(uint32_t AdapterIdx, uint32_t CountIdx) // MaxClientsThreads = MAX_NUM_ADAPTERS for ULT TestMTLoadMultipleAdapters // MaxClientsThreads = MAX_COUNT_PER_ADAPTER for ULT TestMTLoadAdaptersMultipleTimes // MaxClientsThreads = MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER, for ULT TestMTLoadMultipleAdaptersMultipleTimes -void MACommonULT::CreateMAThread(uint32_t MaxClientThreads) +static void CreateMAThread(uint32_t MaxClientThreads, ThreadInParams *InParams) { // Spawn all threads upto MaxClientThreads and wait for them all at once uint32_t i = 0; @@ -221,28 +359,26 @@ void MACommonULT::CreateMAThread(uint32_t MaxClientThreads) pthread_t thread_id[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; /* thread's ID (just an integer) */ /* MaxClientsThreads to represent MAX_NUM_ADAPTERS *MAX_COUNT_PER_ADAPTER Clients */ - for(i = 0; i < (MaxClientThreads); i++) + for (i = 0; i < (MaxClientThreads); i++) { - Status = pthread_create(&thread_id[i], NULL, Thread1, (void *)&InParams[i]); + Status = pthread_create(&thread_id[i], NULL, MAULTThreadEntryFunc, (void *)&InParams[i]); ASSERT_TRUE((!Status)); } /* wait for threads to terminate */ - for(i = 0; i < (MaxClientThreads); i++) + for (i = 0; i < (MaxClientThreads); i++) { Status = pthread_join(thread_id[i], NULL); ASSERT_TRUE((!Status)); } } -void *Thread1(void *lpParam) +void *MAULTThreadEntryFunc(void *lpParam) { ThreadInParams *pInParams = (ThreadInParams *)(lpParam); - MACommonULT::LoadGmmDll(pInParams->AdapterIdx, pInParams->CountIdx); - MACommonULT::GmmInitModule(pInParams->AdapterIdx, pInParams->CountIdx); - MACommonULT::GmmDestroyModule(pInParams->AdapterIdx, pInParams->CountIdx); - MACommonULT::UnLoadGmmDll(pInParams->AdapterIdx, pInParams->CountIdx); + pInParams->MATestObj->GmmInitModule(pInParams->AdapterIdx, pInParams->CountIdx); + pInParams->MATestObj->GmmDestroyModule(pInParams->AdapterIdx, pInParams->CountIdx); pthread_exit(NULL); } @@ -267,41 +403,29 @@ TEST_F(CTestMA, TestLoadMultipleAdapters) uint32_t AdapterCount = 0; uint32_t i = 0; - // Load the dll for all available adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - LoadGmmDll(AdapterCount, 0); - } - // Initilize the dll for all available adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { GmmInitModule(AdapterCount, 0); } // Check the Libcontext for each of the adapter is different or not - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { - for(i = 0; i < MAX_NUM_ADAPTERS; i++) + for (i = 0; i < MAX_NUM_ADAPTERS; i++) { - if(AdapterCount != i) + if (AdapterCount != i) { - EXPECT_NE(pLibContext[AdapterCount][0], pLibContext[i][0]); + EXPECT_NE(GmmTestInfo[AdapterCount][0].pLibContext, GmmTestInfo[i][0].pLibContext); } } } // Un-Initilize the dll for all loaded adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { GmmDestroyModule(AdapterCount, 0); } - - // Unload the dll for all loaded adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - UnLoadGmmDll(AdapterCount, 0); - } } /// Load all adapters(MAX_NUM_ADAPTERS) multiple times up to MAX_COUNT_PER_ADAPTER in same process @@ -309,51 +433,33 @@ TEST_F(CTestMA, TestLoadAdapterMultipleTimes) { uint32_t AdapterCount = 0, RefCount = 0; - // Load the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - LoadGmmDll(AdapterCount, RefCount); - } - } - // Initilize the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { GmmInitModule(AdapterCount, RefCount); } } // For each adapter upto MAX_NUM_ADAPTERS Check the LibContext for all instances upto // MAX_COUNT_PER_ADAPTER to be equal - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER - 1; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER - 1; RefCount++) { - EXPECT_EQ(pLibContext[AdapterCount][RefCount], pLibContext[AdapterCount][RefCount + 1]); + EXPECT_EQ(GmmTestInfo[AdapterCount][RefCount].pLibContext, GmmTestInfo[AdapterCount][RefCount + 1].pLibContext); } } // Un-Initilize the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters // The destroy/unload can be out of order - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { GmmDestroyModule(AdapterCount, RefCount); } } - - // Unload the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - UnLoadGmmDll(AdapterCount, RefCount); - } - } } /// Test Init-Destroy multiple times Upto MAX_COUNT_PER_ADAPTER before Unloading DLL, on Same Adapter upto MAX_NUM_ADAPTERS @@ -361,23 +467,14 @@ TEST_F(CTestMA, TestInitDestroyMultipleTimesOnSameAdapter) { uint32_t AdapterCount = 0, RefCount = 0; - // Load the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - LoadGmmDll(AdapterCount, RefCount); - } - } - // Initilize and destroy module upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters // For each adapter(AdapterCount < MAX_NUM_ADAPTERS) Check the LibContext for all instances to be equal - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { // Initilize the dll upto MAX_COUNT_PER_ADAPTER times for each adapter // In reality the init and destroy can occurs any number of time on a particular adapter, so for simplcity treating that UMD // will load already loaded lib again for MAX_COUNT_PER_ADAPTER times. - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { GmmInitModule(AdapterCount, RefCount); } @@ -388,26 +485,17 @@ TEST_F(CTestMA, TestInitDestroyMultipleTimesOnSameAdapter) // Also our ULT is a Light-Weight process due to which the freed memory not assigned to other processes may get assigned again. // But mind that this is possible only when the previous libcontext intialized is compulsorily inactive and destroyed. // otherwise the same secnario as in TestLoadMultipleAdapters occurs .i.e different pointer value is returned on new adpater bdf. - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER - 1; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER - 1; RefCount++) { - EXPECT_EQ(pLibContext[AdapterCount][RefCount], pLibContext[AdapterCount][RefCount + 1]); + EXPECT_EQ(GmmTestInfo[AdapterCount][RefCount].pLibContext, GmmTestInfo[AdapterCount][RefCount + 1].pLibContext); } // Un-Initilize the dll upto MAX_COUNT_PER_ADAPTER times for each adapter - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { GmmDestroyModule(AdapterCount, RefCount); } } - - // Unload the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - UnLoadGmmDll(AdapterCount, RefCount); - } - } } /// Test Init-Destroy multiple times before Unloading DLL, on Multiple Adapters @@ -415,46 +503,28 @@ TEST_F(CTestMA, TestInitDestroyMultipleTimesOnMultiAdapter) { uint32_t AdapterCount = 0, RefCount = 0; - // Load the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - LoadGmmDll(AdapterCount, RefCount); - } - } - // Initilize and destroy the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters // For each adapter(AdapterCount < MAX_NUM_ADAPTERS) Check the LibContext for all instances to is unique // This is similar to TestInitDestroyMultipleTimesOnSameAdapter ULT apart from the order of adapter initialization. - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { // Initilize the dll upto MAX_COUNT_PER_ADAPTER times for each adapter - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { GmmInitModule(AdapterCount, RefCount); } // Check the LibContext for each of the adpater(upto MAX_NUM_ADAPTERS) to be unique // whereas LibContext for all instances on a same adapter is to be equal - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS - 1; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS - 1; AdapterCount++) { - EXPECT_NE(pLibContext[AdapterCount][RefCount], pLibContext[AdapterCount + 1][RefCount]); + EXPECT_NE(GmmTestInfo[AdapterCount][RefCount].pLibContext, GmmTestInfo[AdapterCount + 1][RefCount].pLibContext); } - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { GmmDestroyModule(AdapterCount, RefCount); } } - - // Unload the dll upto MAX_COUNT_PER_ADAPTER times for each of MAX_NUM_ADAPTERS adapters - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) - { - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) - { - UnLoadGmmDll(AdapterCount, RefCount); - } - } } /* @@ -466,56 +536,62 @@ in parallel and in random order. // Here the number of client per adapter is 1 .i.e 0th count Index TEST_F(CTestMA, TestMTLoadMultipleAdapters) { - uint32_t AdapterCount = 0; + uint32_t AdapterCount = 0; + ThreadInParams InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; memset(InParams, 0, sizeof(InParams)); //Populate the Inparams array with the MAX_NUM_ADAPTERS indices - for(AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) + for (AdapterCount = 0; AdapterCount < MAX_NUM_ADAPTERS; AdapterCount++) { InParams[AdapterCount].AdapterIdx = AdapterCount; InParams[AdapterCount].CountIdx = 0; + InParams[AdapterCount].MATestObj = this; } // Create threads to load all Adapters upto MAX_NUM_ADAPTERS for a single client each - CreateMAThread(MAX_NUM_ADAPTERS); + CreateMAThread(MAX_NUM_ADAPTERS, InParams); } // Load a Single Adapter multiple times upto MAX_COUNT_PER_ADAPTER on multiple threads in same process TEST_F(CTestMA, TestMTLoadAdaptersMultipleTimes) { - uint32_t RefCount = 0; + uint32_t RefCount = 0; + ThreadInParams InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; memset(InParams, 0, sizeof(InParams)); //Populate the Inparams array with MAX_COUNT_PER_ADAPTER indices - for(RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) + for (RefCount = 0; RefCount < MAX_COUNT_PER_ADAPTER; RefCount++) { InParams[RefCount].AdapterIdx = 0; InParams[RefCount].CountIdx = RefCount; + InParams[RefCount].MATestObj = this; } // Create threads to load all clients i.e MAX_COUNT_PER_ADAPTER on single adpater - CreateMAThread(MAX_COUNT_PER_ADAPTER); + CreateMAThread(MAX_COUNT_PER_ADAPTER, InParams); } // Load Multiple Adapters upto MAX_NUM_ADAPTERS, multiple times upto MAX_COUNT_PER_ADAPTER on multiple threads in same process TEST_F(CTestMA, TestMTLoadMultipleAdaptersMultipleTimes) { - uint32_t i = 0, j = 0, k = 0; - uint32_t AdapterCount = 0, RefCount = 0; + uint32_t i = 0, j = 0, k = 0; + uint32_t AdapterCount = 0, RefCount = 0; + ThreadInParams InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; memset(InParams, 0, sizeof(InParams)); //Populate the Inparams array with the MAX_NUM_ADAPTERS*MAX_COUNT_PER_ADAPTER indices //Such that Each Adapter corresponds to its max mumber of clients in a sequential order - for(i = 0; i < (MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER); i++) + for (i = 0; i < (MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER); i++) { - for(j = 0; j < MAX_NUM_ADAPTERS; j++) + for (j = 0; j < MAX_NUM_ADAPTERS; j++) { - for(k = 0; k < MAX_COUNT_PER_ADAPTER; k++) + for (k = 0; k < MAX_COUNT_PER_ADAPTER; k++) { InParams[i].AdapterIdx = AdapterCount; InParams[i].CountIdx = RefCount++; + InParams[i].MATestObj = this; i++; } RefCount = 0; @@ -525,7 +601,7 @@ TEST_F(CTestMA, TestMTLoadMultipleAdaptersMultipleTimes) // Create threads to load MAX_NUM_ADAPTERS, MAX_COUNT_PER_ADAPTER times // Thread Count = MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER - CreateMAThread(MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER); + CreateMAThread(MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER, InParams); } #endif // GMM_LIB_DLL_MA diff --git a/Source/GmmLib/ULT/GmmMultiAdapterULT.h b/Source/GmmLib/ULT/GmmMultiAdapterULT.h index c7f2ca8..6ec4292 100644 --- a/Source/GmmLib/ULT/GmmMultiAdapterULT.h +++ b/Source/GmmLib/ULT/GmmMultiAdapterULT.h @@ -24,8 +24,9 @@ OTHER DEALINGS IN THE SOFTWARE. #include "stdafx.h" #include "GmmCommonULT.h" +#include "../inc/External/Common/GmmClientContext.h" -#define MAX_COUNT_PER_ADAPTER 3 +#define MAX_COUNT_PER_ADAPTER 5 #ifdef _WIN32 #define GMM_DLL_HANDLE HINSTANCE @@ -33,171 +34,68 @@ OTHER DEALINGS IN THE SOFTWARE. #define GMM_DLL_HANDLE void* #endif -typedef struct ThreadInParams_Rec +typedef struct GmmULTInfo_Rec { - uint32_t AdapterIdx; - uint32_t CountIdx; -} ThreadInParams; + ADAPTER_INFO *pGfxAdapterInfo; + PLATFORM GfxPlatform; + GMM_LIB_CONTEXT *pLibContext; + GMM_CLIENT_CONTEXT *pGmmULTClientContext; + GMM_INIT_IN_ARGS InArgs; + GMM_INIT_OUT_ARGS OutArgs; +} GmmULTInfo; class MACommonULT : public testing::Test { public: MACommonULT(); ~MACommonULT(); - static void SetUpTestCase(); - static void TearDownTestCase(); - static void LoadGmmDll(uint32_t AdapterIdx, uint32_t CountIdx); - static void UnLoadGmmDll(uint32_t AdapterIdx, uint32_t CountIdx); - static void GmmInitModule(uint32_t AdapterIdx, uint32_t CountIdx); - static void GmmDestroyModule(uint32_t AdapterIdx, uint32_t CountIdx); - static void CreateMAThread(uint32_t MaxClientThreads); - - static ADAPTER_INFO * pGfxAdapterInfo[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static PLATFORM GfxPlatform[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static GMM_LIB_CONTEXT * pLibContext[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static GMM_CLIENT_CONTEXT * pGmmULTClientContext[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static PFNGMMINIT pfnGmmInit[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static PFNGMMDESTROY pfnGmmDestroy[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static GMM_INIT_IN_ARGS InArgs[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static GMM_INIT_OUT_ARGS OutArgs[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - static GMM_DLL_HANDLE hGmmLib[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; - - // Comman Input paramter array for all thread related ULTs to supply Adapter-Client Context input. - - static ThreadInParams InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER]; + + void LoadGmmDll(); + void UnLoadGmmDll(); + void GmmInitModule(uint32_t AdapterIdx, uint32_t CountIdx); + void GmmDestroyModule(uint32_t AdapterIdx, uint32_t CountIdx); + + PRODUCT_FAMILY GetProductFamily(uint32_t AdapterIdx); + GFXCORE_FAMILY GetRenderCoreFamily(uint32_t AdapterIdx); + GMM_CLIENT GetClientType(uint32_t CountIdx); + ADAPTER_BDF GetAdapterBDF(uint32_t AdapterIdx); + +protected: + GmmULTInfo GmmTestInfo[MAX_NUM_ADAPTERS][MAX_COUNT_PER_ADAPTER]; + + GMM_DLL_HANDLE hGmmLib; + PFNGMMINIT pfnGmmInit; + PFNGMMDESTROY pfnGmmDestroy; // Array to store the adapter BDFs from simulated UMD, Save the adapter bdf in an array - static ADAPTER_BDF AdpaterSaved[MAX_NUM_ADAPTERS]; - - // Only for our ULT to supply dummy ProductFamily - static PRODUCT_FAMILY GetProductFamily(uint32_t AdapterIdx) - { - switch (AdapterIdx) - { - case 0: return IGFX_DG1; - case 1: return IGFX_ICELAKE; - case 2: return IGFX_TIGERLAKE_LP; - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: return IGFX_DG2; - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: return IGFX_XE_HP_SDV; - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: return IGFX_PVC; - case 30: - case 31: - default: break; - } - return IGFX_COFFEELAKE; - } - - // Only for our ULT to supply dummy GFXCORE_FAMILY - static GFXCORE_FAMILY GetRenderCoreFamily(uint32_t AdapterIdx) - { - switch (AdapterIdx) - { - case 0: return IGFX_XE_HP_CORE; - case 1: return IGFX_GEN11LP_CORE; - case 2: return IGFX_GEN12LP_CORE; - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: return IGFX_XE_HPG_CORE; - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: return IGFX_XE_HP_CORE; - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: return IGFX_XE_HPC_CORE; - case 30: - case 31: - default: break; - } - return IGFX_GEN9_CORE; - } - - // To simulate the UMDs/ClinentContexts per adapter i.e MAX_COUNT_PER_ADAPTER - // Increase MAX_COUNT_PER_ADAPTER value if there are more UMDs involved. - static GMM_CLIENT GetClientType(uint32_t CountIdx) - { - switch (CountIdx) - { - case 0: return GMM_D3D9_VISTA; - case 1: return GMM_D3D10_VISTA; - case 2: return GMM_D3D12_VISTA; - case 3: return GMM_EXCITE_VISTA; - case 4: return GMM_OCL_VISTA; - default: break; - } - return GMM_D3D9_VISTA; - } - - // Returns the AdpaterSaved array value, Adapter BDFs based on input AdapterIdx. - - static ADAPTER_BDF GetAdapterBDF(uint32_t AdapterIdx) - { - ADAPTER_BDF AdapterBDF={0,2,0,0}; - - if(AdapterIdx < MAX_NUM_ADAPTERS) - { - AdapterBDF.Bus = AdpaterSaved[AdapterIdx].Bus; - AdapterBDF.Device = AdpaterSaved[AdapterIdx].Device; - AdapterBDF.Function = AdpaterSaved[AdapterIdx].Function; - } - return AdapterBDF; - } + ADAPTER_BDF AdapterSaved[MAX_NUM_ADAPTERS]; }; typedef MACommonULT GMM_MA_ULT_CONTEXT; +typedef struct ThreadInParams_Rec +{ + uint32_t AdapterIdx; + uint32_t CountIdx; + + GMM_MA_ULT_CONTEXT *MATestObj; +} ThreadInParams; + class CTestMA : public MACommonULT { public: CTestMA(); ~CTestMA(); + void SetUp() override; + void TearDown() override; + static void SetUpTestCase(); static void TearDownTestCase(); - }; #ifdef _WIN32 - DWORD WINAPI Thread1(LPVOID lpParam); +DWORD WINAPI MAULTThreadEntryFunc(LPVOID lpParam); #else - void *Thread1(void *lpParam); +void *MAULTThreadEntryFunc(void *lpParam); #endif diff --git a/Source/GmmLib/inc/External/Common/GmmLibDll.h b/Source/GmmLib/inc/External/Common/GmmLibDll.h index eca2805..6bdb31d 100755 --- a/Source/GmmLib/inc/External/Common/GmmLibDll.h +++ b/Source/GmmLib/inc/External/Common/GmmLibDll.h @@ -68,7 +68,6 @@ extern "C" { ///////////////////////////////////////////////////////////////////////////////////// /// Only function exported from GMM lib DLL. ///////////////////////////////////////////////////////////////////////////////////// - GMM_LIB_API GMM_STATUS GMM_STDCALL OpenGmm(GmmExportEntries *pm_GmmFuncs); GMM_LIB_API GMM_STATUS GMM_STDCALL InitializeGmm(GMM_INIT_IN_ARGS *pInArgs, GMM_INIT_OUT_ARGS *pOutArgs); GMM_LIB_API void GMM_STDCALL GmmAdapterDestroy(GMM_INIT_OUT_ARGS *pInArgs); diff --git a/Source/GmmLib/inc/External/Common/GmmLibDllName.h b/Source/GmmLib/inc/External/Common/GmmLibDllName.h index 854716e..9fc05ed 100755 --- a/Source/GmmLib/inc/External/Common/GmmLibDllName.h +++ b/Source/GmmLib/inc/External/Common/GmmLibDllName.h @@ -22,10 +22,7 @@ OTHER DEALINGS IN THE SOFTWARE. #pragma once #if defined(_WIN64 ) || defined(__x86_64__) || defined(__LP64__) - #define GMM_ENTRY_NAME "OpenGmm" - #define GMM_INIT_NAME "GmmInit" #define GMM_ADAPTER_INIT_NAME "InitializeGmm" - #define GMM_DESTROY_NAME "GmmDestroy" #define GMM_ADAPTER_DESTROY_NAME "GmmAdapterDestroy" #if defined(_WIN64) @@ -36,10 +33,7 @@ OTHER DEALINGS IN THE SOFTWARE. #define GMM_UMD_DLL "libigdgmm.so.12" #endif #else - #define GMM_ENTRY_NAME "_OpenGmm@4" - #define GMM_INIT_NAME "_GmmInit@48" #define GMM_ADAPTER_INIT_NAME "_InitializeGmm@8" - #define GMM_DESTROY_NAME "_GmmDestroy@4" #define GMM_ADAPTER_DESTROY_NAME "_GmmAdapterDestroy@4" #if defined(_WIN32) diff --git a/Source/inc/common/igfxfmid.h b/Source/inc/common/igfxfmid.h index f8484a1..8a8438c 100644 --- a/Source/inc/common/igfxfmid.h +++ b/Source/inc/common/igfxfmid.h @@ -76,6 +76,7 @@ typedef enum { IGFX_DG2 = 1270, IGFX_PVC = 1271, IGFX_METEORLAKE = 1272, + IGFX_ARROWLAKE = 1273, IGFX_MAX_PRODUCT, IGFX_GENNEXT = 0x7ffffffe, @@ -108,6 +109,8 @@ typedef enum { PCH_TGL_H, // TGL H PCH PCH_ADL_N, // ADL_N PCHDL PCH_MTL, // MTL PCH + PCH_ARL, // ARL PCH + PCH_PRODUCT_FAMILY_FORCE_ULONG = 0x7fffffff } PCH_PRODUCT_FAMILY; @@ -291,9 +294,16 @@ typedef enum __NATIVEGTTYPE #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 ) || \ - ( GFX_GET_CURRENT_PRODUCT(p) == IGFX_XE_HP_SDV ) || \ - ( GFX_GET_CURRENT_PRODUCT(p) == IGFX_DG2 ) ) +#define GFX_IS_DISCRETE_PRODUCT(pf) ( ( pf == IGFX_DG1 ) || \ + ( pf == IGFX_DG2 ) || \ + ( pf == IGFX_XE_HP_SDV ) ) + +#define GFX_IS_DISCRETE_FAMILY(p) GFX_IS_DISCRETE_PRODUCT(GFX_GET_CURRENT_PRODUCT(p)) + +#define GFX_IS_INTEGRATED_PRODUCT(pf) (!GFX_IS_DISCRETE_PRODUCT(pf)) + +#define GFX_IS_INTEGRATED_FAMILY(p) (!GFX_IS_DISCRETE_FAMILY(p)) + // 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 ) || \ @@ -640,12 +650,6 @@ typedef enum __NATIVEGTTYPE #define ICHV_PLUS_DESK_DEVICE_F0_ID 0x22B3 // Reserved //BDW device ids -#define IBDW_GT0_DESK_DEVICE_F0_ID 0x0BD0 -#define IBDW_GT1_DESK_DEVICE_F0_ID 0x0BD1 -#define IBDW_GT2_DESK_DEVICE_F0_ID 0x0BD2 -#define IBDW_GT3_DESK_DEVICE_F0_ID 0x0BD3 -#define IBDW_GT4_DESK_DEVICE_F0_ID 0x0BD4 - #define IBDW_GT1_HALO_MOBL_DEVICE_F0_ID 0x1602 #define IBDW_GT1_ULT_MOBL_DEVICE_F0_ID 0x1606 #define IBDW_GT1_RSVD_DEVICE_F0_ID 0x160B @@ -1837,6 +1841,40 @@ typedef enum __NATIVEGTTYPE #define PCH_DEV_ID_AE1E 0xAE1E #define PCH_DEV_ID_AE1F 0xAE1F +// ARL PCH Dev IDs +#define PCH_DEV_ID_7700 0x7700 +#define PCH_DEV_ID_7701 0x7701 +#define PCH_DEV_ID_7702 0x7702 +#define PCH_DEV_ID_7703 0x7703 +#define PCH_DEV_ID_7704 0x7704 +#define PCH_DEV_ID_7705 0x7705 +#define PCH_DEV_ID_7706 0x7706 +#define PCH_DEV_ID_7707 0x7707 +#define PCH_DEV_ID_7708 0x7708 +#define PCH_DEV_ID_7709 0x7709 +#define PCH_DEV_ID_770A 0x770A +#define PCH_DEV_ID_770B 0x770B +#define PCH_DEV_ID_770C 0x770C +#define PCH_DEV_ID_770D 0x770D +#define PCH_DEV_ID_770E 0x770E +#define PCH_DEV_ID_770F 0x770F +#define PCH_DEV_ID_7710 0x7710 +#define PCH_DEV_ID_7711 0x7711 +#define PCH_DEV_ID_7712 0x7712 +#define PCH_DEV_ID_7713 0x7713 +#define PCH_DEV_ID_7714 0x7714 +#define PCH_DEV_ID_7715 0x7715 +#define PCH_DEV_ID_7716 0x7716 +#define PCH_DEV_ID_7717 0x7717 +#define PCH_DEV_ID_7718 0x7718 +#define PCH_DEV_ID_7719 0x7719 +#define PCH_DEV_ID_771A 0x771A +#define PCH_DEV_ID_771B 0x771B +#define PCH_DEV_ID_771C 0x771C +#define PCH_DEV_ID_771D 0x771D +#define PCH_DEV_ID_771E 0x771E +#define PCH_DEV_ID_771F 0x771F + //PVC Device ID #define DEV_ID_0BD0 0x0BD0 #define DEV_ID_0BD5 0x0BD5 @@ -1891,14 +1929,17 @@ typedef enum __NATIVEGTTYPE #define DEV_ID_56C0 0x56C0 #define DEV_ID_56C1 0x56C1 - -// RPL-P +// RPL-P/U #define DEV_ID_A7A0 0xA7A0 #define DEV_ID_A7A1 0xA7A1 #define DEV_ID_A7A8 0xA7A8 #define DEV_ID_A7A9 0xA7A9 #define DEV_ID_A720 0xA720 #define DEV_ID_A721 0xA721 +#define DEV_ID_A7AA 0xA7AA +#define DEV_ID_A7AB 0xA7AB +#define DEV_ID_A7AC 0xA7AC +#define DEV_ID_A7AD 0xA7AD // ADL-N #define DEV_ID_46D0 0x46D0 @@ -1914,6 +1955,9 @@ typedef enum __NATIVEGTTYPE #define DEV_ID_7DD5 0x7DD5 #define DEV_ID_7DD7 0x7DD7 +// ARL-S +#define DEV_ID_7D67 0x7D67 + #define MGM_HAS 0 //#define SDG_HAS 1 //Reserve place for Springdale-G HAS @@ -1953,6 +1997,9 @@ typedef enum __NATIVEGTTYPE ( d == DEV_ID_56B2 ) || \ ( d == DEV_ID_56B3 )) +// Macro to identify ARL-S Device ID +#define GFX_IS_ARL_S(d) ( ( d == DEV_ID_7D67 ) ) + //we define the highest cap and lower cap of stepping IDs #define SI_REV_ID(lo,hi) (lo | hi<<16)