Fix Multiadapter ULT issue reproducibilty
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 @@
#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()
{
-}
+ // 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.
-MACommonULT::~MACommonULT()
-{
-}
+ //reset all test info
+ memset(GmmTestInfo, 0, sizeof(GmmTestInfo));
+ memset(AdapterSaved, 0, sizeof(AdapterSaved));
-void MACommonULT::SetUpTestCase()
-{
-}
+ 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 --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 @@
#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];
+ void LoadGmmDll();
+ void UnLoadGmmDll();
+ void GmmInitModule(uint32_t AdapterIdx, uint32_t CountIdx);
+ void GmmDestroyModule(uint32_t AdapterIdx, uint32_t CountIdx);
- // Comman Input paramter array for all thread related ULTs to supply Adapter-Client Context input.
+ PRODUCT_FAMILY GetProductFamily(uint32_t AdapterIdx);
+ GFXCORE_FAMILY GetRenderCoreFamily(uint32_t AdapterIdx);
+ GMM_CLIENT GetClientType(uint32_t CountIdx);
+ ADAPTER_BDF GetAdapterBDF(uint32_t AdapterIdx);
- static ThreadInParams InParams[MAX_NUM_ADAPTERS * MAX_COUNT_PER_ADAPTER];
+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
