You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
538 lines
10 KiB
538 lines
10 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#include "pch_tier0.h" |
|
#include "tier0/tslist.h" |
|
#include <list> |
|
#include <stdlib.h> |
|
#if defined( _X360 ) |
|
#include "xbox/xbox_win32stubs.h" |
|
#endif |
|
|
|
namespace TSListTests |
|
{ |
|
int NUM_TEST = 10000; |
|
int NUM_THREADS; |
|
int MAX_THREADS = 8; |
|
int NUM_PROCESSORS = 1; |
|
|
|
CInterlockedInt g_nTested; |
|
CInterlockedInt g_nThreads; |
|
CInterlockedInt g_nPushThreads; |
|
CInterlockedInt g_nPopThreads; |
|
CInterlockedInt g_nPushes; |
|
CInterlockedInt g_nPops; |
|
CTSQueue<int, true> g_TestQueue; |
|
CTSList<int> g_TestList; |
|
volatile bool g_bStart; |
|
std::list<ThreadHandle_t> g_ThreadHandles; |
|
|
|
int *g_pTestBuckets; |
|
|
|
CTSListBase g_Test; |
|
TSLNodeBase_t **g_nodes; |
|
int idx = 0; |
|
|
|
const char *g_pListType; |
|
|
|
class CTestOps |
|
{ |
|
public: |
|
virtual void Push( int item ) = 0; |
|
virtual bool Pop( int *pResult ) = 0; |
|
virtual bool Validate() { return true; } |
|
virtual bool IsEmpty() = 0; |
|
}; |
|
|
|
class CQueueOps : public CTestOps |
|
{ |
|
void Push( int item ) |
|
{ |
|
g_TestQueue.PushItem( item ); |
|
g_nPushes++; |
|
} |
|
bool Pop( int *pResult ) |
|
{ |
|
if ( g_TestQueue.PopItem( pResult ) ) |
|
{ |
|
g_nPops++; |
|
return true; |
|
} |
|
return false; |
|
} |
|
bool Validate() |
|
{ |
|
return g_TestQueue.ValidateQueue(); |
|
} |
|
bool IsEmpty() |
|
{ |
|
return ( g_TestQueue.Count() == 0 ); |
|
} |
|
} g_QueueOps; |
|
|
|
class CListOps : public CTestOps |
|
{ |
|
void Push( int item ) |
|
{ |
|
g_TestList.PushItem( item ); |
|
g_nPushes++; |
|
} |
|
bool Pop( int *pResult ) |
|
{ |
|
if ( g_TestList.PopItem( pResult ) ) |
|
{ |
|
g_nPops++; |
|
return true; |
|
} |
|
return false; |
|
} |
|
bool Validate() |
|
{ |
|
return true; |
|
} |
|
bool IsEmpty() |
|
{ |
|
return ( g_TestList.Count() == 0 ); |
|
} |
|
} g_ListOps; |
|
|
|
CTestOps *g_pTestOps; |
|
|
|
void ClearBuckets() |
|
{ |
|
memset( g_pTestBuckets, 0, sizeof(int) * NUM_TEST ); |
|
} |
|
|
|
void IncBucket( int i ) |
|
{ |
|
if ( i < NUM_TEST ) // tests can slop over a bit |
|
{ |
|
ThreadInterlockedIncrement( &g_pTestBuckets[i] ); |
|
} |
|
} |
|
|
|
void DecBucket( int i ) |
|
{ |
|
if ( i < NUM_TEST ) // tests can slop over a bit |
|
{ |
|
ThreadInterlockedDecrement( &g_pTestBuckets[i] ); |
|
} |
|
} |
|
|
|
void ValidateBuckets() |
|
{ |
|
for ( int i = 0; i < NUM_TEST; i++ ) |
|
{ |
|
if ( g_pTestBuckets[i] != 0 ) |
|
{ |
|
Msg( "Test bucket %d has an invalid value %d\n", i, g_pTestBuckets[i] ); |
|
DebuggerBreakIfDebugging(); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
unsigned PopThreadFunc( void *) |
|
{ |
|
ThreadSetDebugName( "PopThread" ); |
|
g_nPopThreads++; |
|
g_nThreads++; |
|
while ( !g_bStart ) |
|
{ |
|
ThreadSleep( 0 ); |
|
} |
|
int ignored; |
|
for (;;) |
|
{ |
|
if ( !g_pTestOps->Pop( &ignored ) ) |
|
{ |
|
if ( g_nPushThreads == 0 ) |
|
{ |
|
// Pop the rest |
|
while ( g_pTestOps->Pop( &ignored ) ) |
|
{ |
|
ThreadSleep( 0 ); |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
g_nThreads--; |
|
g_nPopThreads--; |
|
return 0; |
|
} |
|
|
|
unsigned PushThreadFunc( void * ) |
|
{ |
|
ThreadSetDebugName( "PushThread" ); |
|
g_nPushThreads++; |
|
g_nThreads++; |
|
while ( !g_bStart ) |
|
{ |
|
ThreadSleep( 0 ); |
|
} |
|
|
|
while ( g_nTested < NUM_TEST ) |
|
{ |
|
g_pTestOps->Push( g_nTested ); |
|
g_nTested++; |
|
} |
|
g_nThreads--; |
|
g_nPushThreads--; |
|
return 0; |
|
} |
|
|
|
void TestStart() |
|
{ |
|
g_nTested = 0; |
|
g_nThreads = 0; |
|
g_nPushThreads = 0; |
|
g_nPopThreads = 0; |
|
g_bStart = false; |
|
g_nPops = g_nPushes = 0; |
|
ClearBuckets(); |
|
} |
|
|
|
void TestWait() |
|
{ |
|
while ( g_nThreads < NUM_THREADS ) |
|
{ |
|
ThreadSleep( 0 ); |
|
} |
|
g_bStart = true; |
|
while ( g_nThreads > 0 ) |
|
{ |
|
ThreadSleep( 50 ); |
|
} |
|
} |
|
|
|
void TestEnd( bool bExpectEmpty = true ) |
|
{ |
|
ValidateBuckets(); |
|
|
|
if ( g_nPops != g_nPushes ) |
|
{ |
|
Msg( "FAIL: Not all items popped\n" ); |
|
return; |
|
} |
|
|
|
if ( g_pTestOps->Validate() ) |
|
{ |
|
if ( !bExpectEmpty || g_pTestOps->IsEmpty() ) |
|
{ |
|
Msg("pass\n"); |
|
} |
|
else |
|
{ |
|
Msg("FAIL: !IsEmpty()\n"); |
|
} |
|
} |
|
else |
|
{ |
|
Msg("FAIL: !Validate()\n"); |
|
} |
|
while ( g_ThreadHandles.size() ) |
|
{ |
|
ThreadJoin( g_ThreadHandles.front(), 0 ); |
|
|
|
ReleaseThreadHandle( g_ThreadHandles.front() ); |
|
g_ThreadHandles.pop_front(); |
|
} |
|
} |
|
|
|
|
|
//-------------------------------------------------- |
|
// |
|
// Shared Tests for CTSQueue and CTSList |
|
// |
|
//-------------------------------------------------- |
|
void PushPopTest() |
|
{ |
|
Msg( "%s test: single thread push/pop, in order... ", g_pListType ); |
|
ClearBuckets(); |
|
g_nTested = 0; |
|
int value; |
|
while ( g_nTested < NUM_TEST ) |
|
{ |
|
value = g_nTested++; |
|
g_pTestOps->Push( value ); |
|
IncBucket( value ); |
|
} |
|
|
|
g_pTestOps->Validate(); |
|
|
|
while ( g_pTestOps->Pop( &value ) ) |
|
{ |
|
DecBucket( value ); |
|
} |
|
TestEnd(); |
|
} |
|
|
|
void PushPopInterleavedTestGuts() |
|
{ |
|
int value; |
|
for (;;) |
|
{ |
|
bool bPush = ( rand() % 2 == 0 ); |
|
if ( bPush && ( value = g_nTested++ ) < NUM_TEST ) |
|
{ |
|
g_pTestOps->Push( value ); |
|
IncBucket( value ); |
|
} |
|
else if ( g_pTestOps->Pop( &value ) ) |
|
{ |
|
DecBucket( value ); |
|
} |
|
else |
|
{ |
|
if ( g_nTested >= NUM_TEST ) |
|
{ |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
void PushPopInterleavedTest() |
|
{ |
|
Msg( "%s test: single thread push/pop, interleaved... ", g_pListType ); |
|
srand( Plat_MSTime() ); |
|
g_nTested = 0; |
|
ClearBuckets(); |
|
PushPopInterleavedTestGuts(); |
|
TestEnd(); |
|
} |
|
|
|
unsigned PushPopInterleavedTestThreadFunc( void * ) |
|
{ |
|
ThreadSetDebugName( "PushPopThread" ); |
|
g_nThreads++; |
|
while ( !g_bStart ) |
|
{ |
|
ThreadSleep( 0 ); |
|
} |
|
PushPopInterleavedTestGuts(); |
|
g_nThreads--; |
|
return 0; |
|
} |
|
|
|
void STPushMTPop( bool bDistribute ) |
|
{ |
|
Msg( "%s test: single thread push, multithread pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
TestStart(); |
|
g_ThreadHandles.push_back( CreateSimpleThread( &PushThreadFunc, NULL ) ); |
|
for ( int i = 0; i < NUM_THREADS - 1; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PopThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (i % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
|
|
TestWait(); |
|
TestEnd(); |
|
} |
|
|
|
void MTPushSTPop( bool bDistribute ) |
|
{ |
|
Msg( "%s test: multithread push, single thread pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
TestStart(); |
|
g_ThreadHandles.push_back( CreateSimpleThread( &PopThreadFunc, NULL ) ); |
|
for ( int i = 0; i < NUM_THREADS - 1; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PushThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (i % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
|
|
TestWait(); |
|
TestEnd(); |
|
} |
|
|
|
void MTPushMTPop( bool bDistribute ) |
|
{ |
|
Msg( "%s test: multithread push, multithread pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
TestStart(); |
|
int ct = 0; |
|
for ( int i = 0; i < NUM_THREADS / 2 ; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PopThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (ct++ % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
for ( int i = 0; i < NUM_THREADS / 2 ; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PushThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (ct++ % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
|
|
TestWait(); |
|
TestEnd(); |
|
} |
|
|
|
void MTPushPopPopInterleaved( bool bDistribute ) |
|
{ |
|
Msg( "%s test: multithread interleaved push/pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
srand( Plat_MSTime() ); |
|
TestStart(); |
|
for ( int i = 0; i < NUM_THREADS; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PushPopInterleavedTestThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (i % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
TestWait(); |
|
TestEnd(); |
|
} |
|
|
|
void MTPushSeqPop( bool bDistribute ) |
|
{ |
|
Msg( "%s test: multithread push, sequential pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
TestStart(); |
|
for ( int i = 0; i < NUM_THREADS; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PushThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (i % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
|
|
TestWait(); |
|
int ignored; |
|
g_pTestOps->Validate(); |
|
while ( g_pTestOps->Pop( &ignored ) ) |
|
{ |
|
} |
|
TestEnd(); |
|
} |
|
|
|
void SeqPushMTPop( bool bDistribute ) |
|
{ |
|
Msg( "%s test: sequential push, multithread pop, %s", g_pListType, bDistribute ? "distributed..." : "no affinity..." ); |
|
TestStart(); |
|
while ( g_nTested++ < NUM_TEST ) |
|
{ |
|
g_pTestOps->Push( g_nTested ); |
|
} |
|
for ( int i = 0; i < NUM_THREADS; i++ ) |
|
{ |
|
ThreadHandle_t hThread = CreateSimpleThread( &PopThreadFunc, NULL ); |
|
g_ThreadHandles.push_back( hThread ); |
|
if ( bDistribute ) |
|
{ |
|
int32 mask = 1 << (i % NUM_PROCESSORS); |
|
ThreadSetAffinity( hThread, mask ); |
|
} |
|
} |
|
|
|
TestWait(); |
|
TestEnd(); |
|
} |
|
|
|
} |
|
void RunSharedTests( int nTests ) |
|
{ |
|
using namespace TSListTests; |
|
|
|
const CPUInformation &pi = *GetCPUInformation(); |
|
NUM_PROCESSORS = pi.m_nLogicalProcessors; |
|
MAX_THREADS = NUM_PROCESSORS * 2; |
|
g_pTestBuckets = new int[NUM_TEST]; |
|
while ( nTests-- ) |
|
{ |
|
for ( NUM_THREADS = 2; NUM_THREADS <= MAX_THREADS; NUM_THREADS *= 2) |
|
{ |
|
Msg( "\nTesting %d threads:\n", NUM_THREADS ); |
|
PushPopTest(); |
|
PushPopInterleavedTest(); |
|
SeqPushMTPop( false ); |
|
STPushMTPop( false ); |
|
MTPushSeqPop( false ); |
|
MTPushSTPop( false ); |
|
MTPushMTPop( false ); |
|
MTPushPopPopInterleaved( false ); |
|
if ( NUM_PROCESSORS > 1 ) |
|
{ |
|
SeqPushMTPop( true ); |
|
STPushMTPop( true ); |
|
MTPushSeqPop( true ); |
|
MTPushSTPop( true ); |
|
MTPushMTPop( true ); |
|
MTPushPopPopInterleaved( true ); |
|
} |
|
} |
|
} |
|
delete[] g_pTestBuckets; |
|
} |
|
|
|
bool RunTSListTests( int nListSize, int nTests ) |
|
{ |
|
using namespace TSListTests; |
|
NUM_TEST = nListSize; |
|
|
|
TSLHead_t foo; |
|
(void)foo; // Avoid warning about unused variable. |
|
#ifdef USE_NATIVE_SLIST |
|
int maxSize = ( 1 << (sizeof( foo.Depth ) * 8) ) - 1; |
|
#else |
|
int maxSize = ( 1 << (sizeof( foo.value.Depth ) * 8) ) - 1; |
|
#endif |
|
if ( NUM_TEST > maxSize ) |
|
{ |
|
Msg( "TSList cannot hold more that %d nodes\n", maxSize ); |
|
return false; |
|
} |
|
|
|
|
|
g_pTestOps = &g_ListOps; |
|
g_pListType = "CTSList"; |
|
|
|
RunSharedTests( nTests ); |
|
|
|
Msg("Tests done, purging test memory..." ); |
|
g_TestList.Purge(); |
|
Msg( "done\n"); |
|
return true; |
|
} |
|
|
|
bool RunTSQueueTests( int nListSize, int nTests ) |
|
{ |
|
using namespace TSListTests; |
|
NUM_TEST = nListSize; |
|
|
|
g_pTestOps = &g_QueueOps; |
|
g_pListType = "CTSQueue"; |
|
|
|
RunSharedTests( nTests ); |
|
|
|
Msg("Tests done, purging test memory..." ); |
|
g_TestQueue.Purge(); |
|
Msg( "done\n"); |
|
return true; |
|
}
|
|
|