Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package gmmlib for openSUSE:Factory checked
in at 2023-11-14 21:43:47
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/gmmlib (Old)
and /work/SRC/openSUSE:Factory/.gmmlib.new.17445 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "gmmlib"
Tue Nov 14 21:43:47 2023 rev:28 rq:1125894 version:22.3.13
Changes:
--------
--- /work/SRC/openSUSE:Factory/gmmlib/gmmlib.changes 2023-09-13
20:48:16.694022395 +0200
+++ /work/SRC/openSUSE:Factory/.gmmlib.new.17445/gmmlib.changes 2023-11-14
21:43:57.250666837 +0100
@@ -1,0 +2,7 @@
+Tue Nov 14 12:26:45 UTC 2023 - Dirk Müller <dmuel...@suse.com>
+
+- update to 22.3.13:
+ * Fix Multiadapter ULT issue reproducibilty
+ * Add new PVC Device ID
+
+-------------------------------------------------------------------
Old:
----
intel-gmmlib-22.3.11.tar.gz
New:
----
intel-gmmlib-22.3.13.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ gmmlib.spec ++++++
--- /var/tmp/diff_new_pack.TUnZAA/_old 2023-11-14 21:43:57.786686679 +0100
+++ /var/tmp/diff_new_pack.TUnZAA/_new 2023-11-14 21:43:57.786686679 +0100
@@ -19,7 +19,7 @@
%global somajor 12
%global libname libigdgmm%{somajor}
Name: gmmlib
-Version: 22.3.11
+Version: 22.3.13
Release: 0
Summary: Intel Graphics Memory Management Library Package
License: MIT
++++++ intel-gmmlib-22.3.11.tar.gz -> intel-gmmlib-22.3.13.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/gmmlib-intel-gmmlib-22.3.11/README.rst
new/gmmlib-intel-gmmlib-22.3.13/README.rst
--- old/gmmlib-intel-gmmlib-22.3.11/README.rst 2023-08-30 12:31:58.000000000
+0200
+++ new/gmmlib-intel-gmmlib-22.3.13/README.rst 2023-11-08 06:39:22.000000000
+0100
@@ -33,7 +33,7 @@
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 -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/gmmlib-intel-gmmlib-22.3.11/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp
new/gmmlib-intel-gmmlib-22.3.13/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp
--- old/gmmlib-intel-gmmlib-22.3.11/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp
2023-08-30 12:31:58.000000000 +0200
+++ new/gmmlib-intel-gmmlib-22.3.13/Source/GmmLib/ULT/GmmMultiAdapterULT.cpp
2023-11-08 06:39:22.000000000 +0100
@@ -25,71 +25,51 @@
#endif
#include <stdlib.h>
-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()
-{
-}
-
-void MACommonULT::SetUpTestCase()
-{
-}
+ // 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.
+
+ //reset all test info
+ memset(GmmTestInfo, 0, sizeof(GmmTestInfo));
+ memset(AdapterSaved, 0, sizeof(AdapterSaved));
+
+ hGmmLib = NULL;
+ pfnGmmDestroy = NULL;
+ pfnGmmInit = NULL;
-void MACommonULT::TearDownTestCase()
-{
-}
+ //set a seed value so the test is always reproducible
+ srand(0);
-CTestMA::CTestMA()
-{
- uint32_t i = 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 @@
}
}
+MACommonULT::~MACommonULT()
+{
+}
+
+CTestMA::CTestMA()
+{
+}
+
CTestMA::~CTestMA()
{
}
@@ -110,101 +98,251 @@
{
}
-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]);
-
- *(void **)(&pfnGmmInit[AdapterIdx][CountIdx]) =
dlsym(hGmmLib[AdapterIdx][CountIdx], "InitializeGmm");
- *(void **)(&pfnGmmDestroy[AdapterIdx][CountIdx]) =
dlsym(hGmmLib[AdapterIdx][CountIdx], "GmmAdapterDestroy");
-
- ASSERT_TRUE(pfnGmmInit[AdapterIdx][CountIdx]);
- ASSERT_TRUE(pfnGmmDestroy[AdapterIdx][CountIdx]);
+ LoadGmmDll();
}
-void MACommonULT::UnLoadGmmDll(uint32_t AdapterIdx, uint32_t CountIdx)
+void CTestMA::TearDown()
{
- if(hGmmLib[AdapterIdx][CountIdx])
- {
- dlclose(hGmmLib[AdapterIdx][CountIdx]);
- hGmmLib[AdapterIdx][CountIdx] = NULL;
+ UnLoadGmmDll();
+}
+
+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;
+}
+
+// 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)
+{
+ 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
+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 @@
// 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 @@
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 @@
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 @@
{
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 @@
{
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 @@
// 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 @@
{
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 @@
// 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 @@
// 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 -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/gmmlib-intel-gmmlib-22.3.11/Source/GmmLib/ULT/GmmMultiAdapterULT.h
new/gmmlib-intel-gmmlib-22.3.13/Source/GmmLib/ULT/GmmMultiAdapterULT.h
--- old/gmmlib-intel-gmmlib-22.3.11/Source/GmmLib/ULT/GmmMultiAdapterULT.h
2023-08-30 12:31:58.000000000 +0200
+++ new/gmmlib-intel-gmmlib-22.3.13/Source/GmmLib/ULT/GmmMultiAdapterULT.h
2023-11-08 06:39:22.000000000 +0100
@@ -24,8 +24,9 @@
#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 @@
#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 -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/gmmlib-intel-gmmlib-22.3.11/Source/inc/common/igfxfmid.h
new/gmmlib-intel-gmmlib-22.3.13/Source/inc/common/igfxfmid.h
--- old/gmmlib-intel-gmmlib-22.3.11/Source/inc/common/igfxfmid.h
2023-08-30 12:31:58.000000000 +0200
+++ new/gmmlib-intel-gmmlib-22.3.13/Source/inc/common/igfxfmid.h
2023-11-08 06:39:22.000000000 +0100
@@ -294,9 +294,16 @@
#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 ) || \
@@ -1878,6 +1885,7 @@
#define DEV_ID_0BDA 0x0BDA
#define DEV_ID_0BDB 0x0BDB
#define DEV_ID_0B69 0x0B69
+#define DEV_ID_0B6E 0x0B6E
// Macro to identify PVC device ID
#define GFX_IS_XT_CONFIG(d) ((d == DEV_ID_0BD5) || \
@@ -1887,7 +1895,8 @@
(d == DEV_ID_0BD9) || \
(d == DEV_ID_0BDA) || \
(d == DEV_ID_0BDB) || \
- (d == DEV_ID_0B69))
+ (d == DEV_ID_0B69) || \
+ (d == DEV_ID_0B6E))
//DG2 Device IDs
#define DEV_ID_4F80 0x4F80
