Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
 
 
 
 
 
 

3264 lines
76 KiB

//========== Copyright 2005, Valve Corporation, All rights reserved. ========
//
// Purpose:
//
//=============================================================================
#include "tier0/platform.h"
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x0403
#include <windows.h>
#endif
#ifdef _WIN32
#include <process.h>
#include <Mmsystem.h>
#pragma comment(lib, "winmm.lib")
#include "tier0/vcrmode.h"
#elif POSIX
#include <sched.h>
#include <exception>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <sys/time.h>
#define GetLastError() errno
typedef void *LPVOID;
#if !defined(OSX)
#if defined(ANDROID)
#include <fcntl.h>
#include <unistd.h>
#else
#include <sys/fcntl.h>
#include <sys/unistd.h>
#endif
#define sem_unlink( arg )
#define OS_TO_PTHREAD(x) (x)
#else
#define pthread_yield pthread_yield_np
#include <mach/thread_act.h>
#include <mach/mach.h>
#define OS_TO_PTHREAD(x) pthread_from_mach_thread_np( x )
#endif // !OSX
#endif
#ifndef _PS3
#include <memory.h>
#endif
#include "tier0/minidump.h"
#include "tier0/threadtools.h"
#include "tier0/dynfunction.h"
#ifdef _X360
#include "xbox/xbox_win32stubs.h"
#endif
#include <map>
// Must be last header...
#include "tier0/memdbgon.h"
#ifdef _PS3
#include "ps3/ps3_win32stubs.h"
#define NEW_WAIT_FOR_MULTIPLE_OBJECTS
bool gbCheckNotMultithreaded = true;
extern "C" void(*g_pfnPushMarker)( const char * pName );
extern "C" void(*g_pfnPopMarker)();
#endif
#define THREADS_DEBUG 1
#define DEBUG_ERROR(XX) Assert(0)
// Need to ensure initialized before other clients call in for main thread ID
#ifdef _WIN32
#pragma warning(disable:4073)
#pragma init_seg(lib)
#endif
#ifdef _WIN32
ASSERT_INVARIANT(TT_SIZEOF_CRITICALSECTION == sizeof(CRITICAL_SECTION));
ASSERT_INVARIANT(TT_INFINITE == INFINITE);
#endif
// thread creation counter.
// this is used to provide a unique threadid for each running thread in g_nThreadID ( a thread local variable ).
const int MAX_THREAD_IDS = 128;
static volatile bool s_bThreadIDAllocated[MAX_THREAD_IDS];
#if defined(_PS3)
#include "tls_ps3.h"
#else
DLL_CLASS_EXPORT CTHREADLOCALINT g_nThreadID;
#endif
static CThreadFastMutex s_ThreadIDMutex;
PLATFORM_INTERFACE void AllocateThreadID( void )
{
AUTO_LOCK( s_ThreadIDMutex );
for( int i = 1; i < MAX_THREAD_IDS; i++ )
{
if ( ! s_bThreadIDAllocated[i] )
{
g_nThreadID = i;
s_bThreadIDAllocated[i] = true;
return;
}
}
Error( "Out of thread ids. Decrease the number of threads or increase MAX_THREAD_IDS\n" );
}
PLATFORM_INTERFACE void FreeThreadID( void )
{
AUTO_LOCK( s_ThreadIDMutex );
int nThread = g_nThreadID;
if ( nThread )
s_bThreadIDAllocated[nThread] = false;
}
//-----------------------------------------------------------------------------
// Simple thread functions.
// Because _beginthreadex uses stdcall, we need to convert to cdecl
//-----------------------------------------------------------------------------
struct ThreadProcInfo_t
{
ThreadProcInfo_t( ThreadFunc_t pfnThread, void *pParam )
: pfnThread( pfnThread),
pParam( pParam )
{
}
ThreadFunc_t pfnThread;
void * pParam;
};
//---------------------------------------------------------
#ifdef _WIN32
static DWORD WINAPI ThreadProcConvert( void *pParam )
{
ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam);
AllocateThreadID();
delete ((ThreadProcInfo_t *)pParam);
unsigned nRet = (*info.pfnThread)(info.pParam);
FreeThreadID();
return nRet;
}
#elif defined( PS3 )
union ThreadProcInfoUnion_t
{
struct Val_t
{
ThreadFunc_t pfnThread;
void * pParam;
}
val;
uint64_t val64;
};
static void ThreadProcConvertUnion( uint64_t param )
{
COMPILE_TIME_ASSERT( sizeof( ThreadProcInfoUnion_t ) == 8 );
ThreadProcInfoUnion_t info;
info.val64 = param;
AllocateThreadID();
unsigned nRet = (*info.val.pfnThread)(info.val.pParam);
FreeThreadID();
sys_ppu_thread_exit( nRet );
}
static void* ThreadProcConvert( void *pParam )
{
ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam);
AllocateThreadID();
delete ((ThreadProcInfo_t *)pParam);
unsigned nRet = (*info.pfnThread)(info.pParam);
FreeThreadID();
return ( void * ) nRet;
}
#else
static void* ThreadProcConvert( void *pParam )
{
ThreadProcInfo_t info = *((ThreadProcInfo_t *)pParam);
AllocateThreadID();
delete ((ThreadProcInfo_t *)pParam);
unsigned nRet = (*info.pfnThread)(info.pParam);
FreeThreadID();
return ( void * ) (uintp) nRet;
}
#endif
#if defined( _PS3 )
/*******************************************************************************
* Thread Local Storage globals and functions
*******************************************************************************/
#ifndef _PS3
__thread void *gTLSValues[ MAX_TLS_VALUES ] = { NULL };
__thread bool gTLSFlags[ MAX_TLS_VALUES ] = { false };
__thread bool gbWaitObjectsCreated = false;
__thread sys_semaphore_t gWaitObjectsSemaphore;
#endif // !_PS3
static char gThreadName[28] = "";
// Simple TLS allocator. Linearly searches for a free slot.
uint32 TlsAlloc()
{
for ( int i = 0; i < MAX_TLS_VALUES; ++i )
{
if ( !gTLSFlags[i] )
{
gTLSFlags[i] = true;
return i;
}
}
#ifdef _PS3
DEBUG_ERROR("TlsAlloc(): Out of TLS\n");
#endif
return 0xFFFFFFFF;
}
void TlsFree( uint32 index )
{
gTLSValues[ index ] = NULL;
gTLSFlags[ index ] = false;
}
void *TlsGetValue( uint32 index )
{
return gTLSValues[ index ];
}
void TlsSetValue( uint32 index, void *pValue )
{
gTLSValues[ index ] = pValue;
}
#endif //_PS3
#ifdef _WIN32
class CThreadHandleToIDMap
{
public:
HANDLE m_hThread;
uint m_ThreadID;
CThreadHandleToIDMap *m_pNext;
};
static CThreadHandleToIDMap *g_pThreadHandleToIDMaps = NULL;
static CThreadMutex g_ThreadHandleToIDMapMutex;
static volatile int g_nThreadHandleToIDMaps = 0;
static void AddThreadHandleToIDMap( HANDLE hThread, uint threadID )
{
if ( !hThread )
return;
// Remember this handle/id combo.
CThreadHandleToIDMap *pMap = new CThreadHandleToIDMap;
pMap->m_hThread = hThread;
pMap->m_ThreadID = threadID;
// Add it to the global list.
g_ThreadHandleToIDMapMutex.Lock();
pMap->m_pNext = g_pThreadHandleToIDMaps;
g_pThreadHandleToIDMaps = pMap;
++g_nThreadHandleToIDMaps;
g_ThreadHandleToIDMapMutex.Unlock();
if ( g_nThreadHandleToIDMaps > 500 )
Error( "ThreadHandleToIDMap overflow." );
}
// This assumes you've got g_ThreadHandleToIDMapMutex locked!!
static bool InternalLookupHandleToThreadIDMap( HANDLE hThread, CThreadHandleToIDMap* &pMap, CThreadHandleToIDMap** &ppPrev )
{
ppPrev = &g_pThreadHandleToIDMaps;
for ( pMap=g_pThreadHandleToIDMaps; pMap; pMap=pMap->m_pNext )
{
if ( pMap->m_hThread == hThread )
return true;
ppPrev = &pMap->m_pNext;
}
return false;
}
static void RemoveThreadHandleToIDMap( HANDLE hThread )
{
if ( !hThread )
return;
CThreadHandleToIDMap *pMap, **ppPrev;
g_ThreadHandleToIDMapMutex.Lock();
if ( g_nThreadHandleToIDMaps <= 0 )
Error( "ThreadHandleToIDMap underflow." );
if ( InternalLookupHandleToThreadIDMap( hThread, pMap, ppPrev ) )
{
*ppPrev = pMap->m_pNext;
delete pMap;
--g_nThreadHandleToIDMaps;
}
g_ThreadHandleToIDMapMutex.Unlock();
}
static uint LookupThreadIDFromHandle( HANDLE hThread )
{
if ( hThread == NULL || hThread == GetCurrentThread() )
return GetCurrentThreadId();
float flStartTime = Plat_FloatTime();
while ( Plat_FloatTime() - flStartTime < 2 )
{
CThreadHandleToIDMap *pMap, **ppPrev;
g_ThreadHandleToIDMapMutex.Lock();
bool bRet = InternalLookupHandleToThreadIDMap( hThread, pMap, ppPrev );
g_ThreadHandleToIDMapMutex.Unlock();
if ( bRet )
return pMap->m_ThreadID;
// We should only get here if a thread that is just starting up is currently in AddThreadHandleToIDMap.
// Give up the timeslice and try again.
ThreadSleep( 1 );
}
Assert( !"LookupThreadIDFromHandle failed!" );
Warning( "LookupThreadIDFromHandle couldn't find thread ID for handle." );
return 0;
}
#endif
//---------------------------------------------------------
ThreadHandle_t * CreateTestThreads( ThreadFunc_t fnThread, int numThreads, int nProcessorsToDistribute )
{
ThreadHandle_t *pHandles = (new ThreadHandle_t[numThreads+1]) + 1;
pHandles[-1] = (ThreadHandle_t)INT_TO_POINTER( numThreads );
for( int i = 0; i < numThreads; ++i )
{
//TestThreads();
ThreadHandle_t hThread;
const unsigned int nDefaultStackSize = 64 * 1024; // this stack size is used in case stackSize == 0
hThread = CreateSimpleThread( fnThread, INT_TO_POINTER( i ), nDefaultStackSize );
if ( nProcessorsToDistribute )
{
int32 mask = 1 << (i % nProcessorsToDistribute);
ThreadSetAffinity( hThread, mask );
}
/*
ThreadProcInfoUnion_t info;
info.val.pfnThread = fnThread;
info.val.pParam = (void*)(i);
if ( int nError = sys_ppu_thread_create( &hThread, ThreadProcConvertUnion, info.val64, 1001, nDefaultStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, "SimpleThread" ) != CELL_OK )
{
printf( "PROBLEM!\n" );
Error( "Cannot create thread, error %d\n", nError );
return 0;
}
*/
//ThreadHandle_t hThread = CreateSimpleThread( fnThread, (void*)i );
pHandles[i] = hThread;
}
// printf("Finishinged CreateTestThreads(%p,%d)\n", (void*)fnThread, numThreads );
return pHandles;
}
void JoinTestThreads( ThreadHandle_t *pHandles )
{
int nCount = POINTER_TO_INT( (uintp)pHandles[-1] );
// printf("Joining test threads @%p[%d]:\n", pHandles, nCount );
// for( int i = 0; i < nCount; ++i )
// {
// printf(" %p,\n", (void*)pHandles[i] );
// }
for( int i = 0; i < nCount; ++i )
{
// printf( "Joining %p", (void*) pHandles[i] );
// if( !i ) sys_timer_usleep(100000);
ThreadJoin( pHandles[i] );
ReleaseThreadHandle( pHandles[i] );
}
delete[]( pHandles - 1 );
}
ThreadHandle_t CreateSimpleThread( ThreadFunc_t pfnThread, void *pParam, unsigned stackSize )
{
#ifdef _WIN32
DWORD threadID;
HANDLE hThread = (HANDLE)CreateThread( NULL, stackSize, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ), stackSize ? STACK_SIZE_PARAM_IS_A_RESERVATION : 0, &threadID );
AddThreadHandleToIDMap( hThread, threadID );
return (ThreadHandle_t)hThread;
#elif PS3
//TestThreads();
ThreadHandle_t th;
ThreadProcInfoUnion_t info;
info.val.pfnThread = pfnThread;
info.val.pParam = pParam;
const unsigned int nDefaultStackSize = 64 * 1024; // this stack size is used in case stackSize == 0
if ( sys_ppu_thread_create( &th, ThreadProcConvertUnion, info.val64, 1001, stackSize ? stackSize : nDefaultStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, "SimpleThread" ) != CELL_OK )
{
AssertMsg1( 0, "Failed to create thread (error 0x%x)", errno );
return 0;
}
return th;
#elif POSIX
pthread_t tid;
pthread_create( &tid, NULL, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ) );
return ( ThreadHandle_t ) tid;
#else
Assert( 0 );
DebuggerBreak();
return 0;
#endif
}
ThreadHandle_t CreateSimpleThread( ThreadFunc_t pfnThread, void *pParam, ThreadId_t *pID, unsigned stackSize )
{
#ifdef _WIN32
DWORD threadID;
HANDLE hThread = (HANDLE)CreateThread( NULL, stackSize, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ), stackSize ? STACK_SIZE_PARAM_IS_A_RESERVATION : 0, &threadID );
if( pID )
*pID = (ThreadId_t)threadID;
AddThreadHandleToIDMap( hThread, threadID );
return (ThreadHandle_t)hThread;
#elif POSIX
pthread_t tid;
pthread_create( &tid, NULL, ThreadProcConvert, new ThreadProcInfo_t( pfnThread, pParam ) );
if( pID )
*pID = (ThreadId_t)tid;
return ( ThreadHandle_t ) tid;
#else
Assert( 0 );
DebuggerBreak();
return 0;
#endif
}
bool ReleaseThreadHandle( ThreadHandle_t hThread )
{
#ifdef _WIN32
bool bRetVal = ( CloseHandle( hThread ) != 0 );
RemoveThreadHandleToIDMap( (HANDLE)hThread );
return bRetVal;
#else
return true;
#endif
}
//-----------------------------------------------------------------------------
//
// Wrappers for other simple threading operations
//
//-----------------------------------------------------------------------------
void ThreadSleep(unsigned nMilliseconds)
{
#ifdef _WIN32
#ifdef _WIN32_PC
static bool bInitialized = false;
if ( !bInitialized )
{
bInitialized = true;
// Set the timer resolution to 1 ms (default is 10.0, 15.6, 2.5, 1.0 or
// some other value depending on hardware and software) so that we can
// use Sleep( 1 ) to avoid wasting CPU time without missing our frame
// rate.
timeBeginPeriod( 1 );
}
#endif
Sleep( nMilliseconds );
#elif PS3
if( nMilliseconds == 0 )
{
// sys_ppu_thread_yield doesn't seem to function properly, so sleep instead.
// sys_timer_usleep( 60 );
sys_ppu_thread_yield();
}
else
{
sys_timer_usleep( nMilliseconds * 1000 );
}
#elif defined(POSIX)
usleep( nMilliseconds * 1000 );
#endif
}
//-----------------------------------------------------------------------------
void ThreadNanoSleep(unsigned ns)
{
#ifdef _WIN32
// ceil
Sleep( ( ns + 999 ) / 1000 );
#elif PS3
sys_timer_usleep( ns );
#elif defined(POSIX)
struct timespec tm;
tm.tv_sec = 0;
tm.tv_nsec = ns;
nanosleep( &tm, NULL );
#endif
}
//-----------------------------------------------------------------------------
#ifndef ThreadGetCurrentId
ThreadId_t ThreadGetCurrentId()
{
#ifdef _WIN32
return GetCurrentThreadId();
#elif defined( _PS3 )
sys_ppu_thread_t th = 0;
sys_ppu_thread_get_id( &th );
return th;
#elif defined(POSIX)
return (ThreadId_t)pthread_self();
#else
Assert(0);
DebuggerBreak();
return 0;
#endif
}
#endif
//-----------------------------------------------------------------------------
ThreadHandle_t ThreadGetCurrentHandle()
{
#ifdef _WIN32
return (ThreadHandle_t)GetCurrentThread();
#elif defined( _PS3 )
sys_ppu_thread_t th = 0;
sys_ppu_thread_get_id( &th );
return th;
#elif defined(POSIX)
return (ThreadHandle_t)pthread_self();
#else
Assert(0);
DebuggerBreak();
return 0;
#endif
}
// On PS3, this will return true for zombie threads
bool ThreadIsThreadIdRunning( ThreadId_t uThreadId )
{
#ifdef _WIN32
bool bRunning = true;
HANDLE hThread = ::OpenThread( THREAD_QUERY_INFORMATION , false, uThreadId );
if ( hThread )
{
DWORD dwExitCode;
if( !::GetExitCodeThread( hThread, &dwExitCode ) || dwExitCode != STILL_ACTIVE )
bRunning = false;
CloseHandle( hThread );
}
else
{
bRunning = false;
}
return bRunning;
#elif defined( _PS3 )
// will return CELL_OK for zombie threads
int priority;
return (sys_ppu_thread_get_priority( uThreadId, &priority ) == CELL_OK );
#elif defined(POSIX)
int iResult = pthread_kill( OS_TO_PTHREAD(uThreadId), 0 );
if ( iResult == 0 )
return true;
return false;
#endif
}
//-----------------------------------------------------------------------------
int ThreadGetPriority( ThreadHandle_t hThread )
{
if ( !hThread )
{
hThread = ThreadGetCurrentHandle();
}
#ifdef _WIN32
return ::GetThreadPriority( (HANDLE)hThread );
#elif defined( _PS3 )
int iPri = 0;
sys_ppu_thread_get_priority( hThread, &iPri );
return iPri;
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
bool ThreadSetPriority( ThreadHandle_t hThread, int priority )
{
if ( !hThread )
{
hThread = ThreadGetCurrentHandle();
}
#ifdef _WIN32
return ( SetThreadPriority(hThread, priority) != 0 );
#elif defined( _PS3 )
int retval = sys_ppu_thread_set_priority( hThread, priority );
return retval >= CELL_OK;
#elif defined(POSIX)
struct sched_param thread_param;
thread_param.sched_priority = priority;
//pthread_setschedparam( (pthread_t ) hThread, SCHED_RR, &thread_param );
return true;
#endif
}
//-----------------------------------------------------------------------------
void ThreadSetAffinity( ThreadHandle_t hThread, int nAffinityMask )
{
if ( !hThread )
{
hThread = ThreadGetCurrentHandle();
}
#ifdef _WIN32
SetThreadAffinityMask( hThread, nAffinityMask );
#elif defined(POSIX)
// cpu_set_t cpuSet;
// CPU_ZERO( cpuSet );
// for( int i = 0 ; i < 32; i++ )
// if ( nAffinityMask & ( 1 << i ) )
// CPU_SET( cpuSet, i );
// sched_setaffinity( hThread, sizeof( cpuSet ), &cpuSet );
#endif
}
//-----------------------------------------------------------------------------
#ifndef _X360
ThreadId_t InitMainThread()
{
ThreadSetDebugName( "MainThrd" );
return ThreadGetCurrentId();
}
ThreadId_t g_ThreadMainThreadID = InitMainThread();
bool ThreadInMainThread()
{
return ( ThreadGetCurrentId() == g_ThreadMainThreadID );
}
void DeclareCurrentThreadIsMainThread()
{
g_ThreadMainThreadID = ThreadGetCurrentId();
}
#else
byte *InitMainThread()
{
byte b;
return AlignValue( &b, 64*1024 );
}
#define STACK_SIZE_360 327680
byte *g_pBaseMainStack = InitMainThread();
byte *g_pLimitMainStack = InitMainThread() - STACK_SIZE_360;
#endif
//-----------------------------------------------------------------------------
bool ThreadJoin( ThreadHandle_t hThread, unsigned timeout )
{
if ( !hThread )
{
return false;
}
#ifdef _WIN32
DWORD dwWait = WaitForSingleObject( (HANDLE)hThread, timeout );
if ( dwWait == WAIT_TIMEOUT)
return false;
if ( dwWait != WAIT_OBJECT_0 && ( dwWait != WAIT_FAILED && GetLastError() != 0 ) )
{
Assert( 0 );
return false;
}
#elif defined( _PS3 )
uint64 uiExitCode = 0;
int retval = sys_ppu_thread_join( hThread, &uiExitCode );
return ( retval >= CELL_OK );
#elif defined(POSIX)
if ( pthread_join( (pthread_t)hThread, NULL ) != 0 )
return false;
#else
Assert(0);
DebuggerBreak();
#endif
return true;
}
//-----------------------------------------------------------------------------
void ThreadSetDebugName( ThreadHandle_t hThread, const char *pszName )
{
#ifdef WIN32
if ( Plat_IsInDebugSession() )
{
#define MS_VC_EXCEPTION 0x406d1388
typedef struct tagTHREADNAME_INFO
{
DWORD dwType; // must be 0x1000
LPCSTR szName; // pointer to name (in same addr space)
DWORD dwThreadID; // thread ID (-1 caller thread)
DWORD dwFlags; // reserved for future use, most be zero
} THREADNAME_INFO;
THREADNAME_INFO info;
info.dwType = 0x1000;
info.szName = pszName;
info.dwThreadID = LookupThreadIDFromHandle( hThread );
if ( info.dwThreadID != 0 )
{
info.dwFlags = 0;
__try
{
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(DWORD), (ULONG_PTR *)&info);
}
__except (EXCEPTION_CONTINUE_EXECUTION)
{
}
}
}
#endif
}
//-----------------------------------------------------------------------------
#ifdef _WIN32
ASSERT_INVARIANT( TW_FAILED == WAIT_FAILED );
ASSERT_INVARIANT( TW_TIMEOUT == WAIT_TIMEOUT );
ASSERT_INVARIANT( WAIT_OBJECT_0 == 0 );
int ThreadWaitForObjects( int nEvents, const HANDLE *pHandles, bool bWaitAll, unsigned timeout )
{
return VCRHook_WaitForMultipleObjects( nEvents, pHandles, bWaitAll, timeout );
}
#endif
//-----------------------------------------------------------------------------
// Used to thread LoadLibrary on the 360
//-----------------------------------------------------------------------------
static ThreadedLoadLibraryFunc_t s_ThreadedLoadLibraryFunc = 0;
PLATFORM_INTERFACE void SetThreadedLoadLibraryFunc( ThreadedLoadLibraryFunc_t func )
{
s_ThreadedLoadLibraryFunc = func;
}
PLATFORM_INTERFACE ThreadedLoadLibraryFunc_t GetThreadedLoadLibraryFunc()
{
return s_ThreadedLoadLibraryFunc;
}
//-----------------------------------------------------------------------------
//
// CThreadSyncObject (note nothing uses this directly (I think) )
//
//-----------------------------------------------------------------------------
#ifdef _PS3
uint32_t CThreadSyncObject::m_bstaticMutexInitialized = false;
uint32_t CThreadSyncObject::m_bstaticMutexInitializing = false;
sys_lwmutex_t CThreadSyncObject::m_staticMutex;
#endif
CThreadSyncObject::CThreadSyncObject()
#ifdef _WIN32
: m_hSyncObject( NULL ), m_bCreatedHandle(false)
#elif defined(POSIX) && !defined(PS3)
: m_bInitalized( false )
#endif
{
#ifdef _PS3
//Do we nee to initialise the staticMutex?
if (m_bstaticMutexInitialized) return;
//If we are the first thread then create the mutex
if ( cellAtomicCompareAndSwap32(&m_bstaticMutexInitializing, false, true) == false )
{
sys_lwmutex_attribute_t mutexAttr;
sys_lwmutex_attribute_initialize( mutexAttr );
mutexAttr.attr_recursive = SYS_SYNC_RECURSIVE;
int err = sys_lwmutex_create( &m_staticMutex, &mutexAttr );
Assert(err == CELL_OK);
m_bstaticMutexInitialized = true;
}
else
{
//Another thread is already in the process of initialising the mutex, wait for it
while ( !m_bstaticMutexInitialized )
{
// sys_ppu_thread_yield doesn't seem to function properly, so sleep instead.
// sys_timer_usleep( 60 );
sys_ppu_thread_yield();
}
}
#endif
}
//---------------------------------------------------------
CThreadSyncObject::~CThreadSyncObject()
{
#ifdef _WIN32
if ( m_hSyncObject && m_bCreatedHandle )
{
if ( !CloseHandle(m_hSyncObject) )
{
Assert( 0 );
}
}
#elif defined(POSIX) && !defined( PS3 )
if ( m_bInitalized )
{
pthread_cond_destroy( &m_Condition );
pthread_mutex_destroy( &m_Mutex );
m_bInitalized = false;
}
#endif
}
//---------------------------------------------------------
bool CThreadSyncObject::operator!() const
{
#if PS3
return m_bstaticMutexInitialized;
#elif defined( _WIN32 )
return !m_hSyncObject;
#elif defined(POSIX)
return !m_bInitalized;
#endif
}
//---------------------------------------------------------
void CThreadSyncObject::AssertUseable()
{
#ifdef THREADS_DEBUG
#if PS3
AssertMsg( m_bstaticMutexInitialized, "Thread synchronization object is unuseable" );
#elif defined( _WIN32 )
AssertMsg( m_hSyncObject, "Thread synchronization object is unuseable" );
#elif defined(POSIX)
AssertMsg( m_bInitalized, "Thread synchronization object is unuseable" );
#endif
#endif
}
//---------------------------------------------------------
#if defined(_WIN32) || ( defined(POSIX) && !defined( _PS3 ) )
bool CThreadSyncObject::Wait( uint32 dwTimeout )
{
#ifdef THREADS_DEBUG
AssertUseable();
#endif
#ifdef _WIN32
return ( WaitForSingleObject( m_hSyncObject, dwTimeout ) == WAIT_OBJECT_0 );
#elif defined( POSIX ) && !defined( PS3 )
pthread_mutex_lock( &m_Mutex );
bool bRet = false;
if ( m_cSet > 0 )
{
bRet = true;
m_bWakeForEvent = false;
}
else
{
volatile int ret = 0;
while ( !m_bWakeForEvent && ret != ETIMEDOUT )
{
struct timeval tv;
gettimeofday( &tv, NULL );
volatile struct timespec tm;
uint64 actualTimeout = dwTimeout;
if ( dwTimeout == TT_INFINITE && m_bManualReset )
actualTimeout = 10; // just wait 10 msec at most for manual reset events and loop instead
volatile uint64 nNanoSec = (uint64)tv.tv_usec*1000 + (uint64)actualTimeout*1000000;
tm.tv_sec = tv.tv_sec + nNanoSec /1000000000;
tm.tv_nsec = nNanoSec % 1000000000;
do
{
ret = pthread_cond_timedwait( &m_Condition, &m_Mutex, (const timespec *)&tm );
}
while( ret == EINTR );
bRet = ( ret == 0 );
if ( m_bManualReset )
{
if ( m_cSet )
break;
if ( dwTimeout == TT_INFINITE && ret == ETIMEDOUT )
ret = 0; // force the loop to spin back around
}
}
if ( bRet )
m_bWakeForEvent = false;
}
if ( !m_bManualReset && bRet )
m_cSet = 0;
pthread_mutex_unlock( &m_Mutex );
return bRet;
#endif
}
#endif
uint32 CThreadSyncObject::WaitForMultiple( int nObjects, CThreadSyncObject **ppObjects, bool bWaitAll, uint32 dwTimeout )
{
#if defined( _WIN32 )
CThreadSyncObject *pHandles = (CThreadSyncObject*)stackalloc( sizeof(CThreadSyncObject) * nObjects );
for ( int i=0; i < nObjects; i++ )
{
pHandles[i].m_hSyncObject = ppObjects[i]->m_hSyncObject;
}
return WaitForMultiple( nObjects, pHandles, bWaitAll, dwTimeout );
#else
// TODO: Need a more efficient implementation of this.
uint32 dwStartTime = 0;
if ( dwTimeout != TT_INFINITE )
dwStartTime = Plat_MSTime();
// If bWaitAll = true, then we need to track which ones were triggered.
char *pWasTriggered = NULL;
int nTriggered = 0;
if ( bWaitAll )
{
pWasTriggered = (char*)stackalloc( nObjects );
memset( pWasTriggered, 0, nObjects );
}
while ( 1 )
{
for ( int i=0; i < nObjects; i++ )
{
if ( bWaitAll && pWasTriggered[i] )
continue;
#ifdef _PS3
Assert( !"Not implemented!" );
if ( false )
#else
if ( ppObjects[i]->Wait( 0 ) )
#endif
{
++nTriggered;
if ( bWaitAll )
{
if ( nTriggered == nObjects )
return 0;
else
pWasTriggered[i] = 1;
}
else
{
return i;
}
}
}
// Timeout?
if ( dwTimeout != TT_INFINITE )
{
if ( Plat_MSTime() - dwStartTime >= dwTimeout )
return TW_TIMEOUT;
}
ThreadSleep( 0 );
}
#endif
}
uint32 CThreadSyncObject::WaitForMultiple( int nObjects, CThreadSyncObject *pObjects, bool bWaitAll, uint32 dwTimeout )
{
#if defined(_WIN32 )
HANDLE *pHandles = (HANDLE*)stackalloc( sizeof(HANDLE) * nObjects );
for ( int i=0; i < nObjects; i++ )
{
pHandles[i] = pObjects[i].m_hSyncObject;
}
DWORD ret = WaitForMultipleObjects( nObjects, pHandles, bWaitAll, dwTimeout );
if ( ret == WAIT_TIMEOUT )
return TW_TIMEOUT;
else if ( ret >= WAIT_OBJECT_0 && (ret-WAIT_OBJECT_0) < (uint32)nObjects )
return (int)(ret - WAIT_OBJECT_0);
else if ( ret >= WAIT_ABANDONED_0 && (ret - WAIT_ABANDONED_0) < (uint32)nObjects )
Error( "Unhandled WAIT_ABANDONED in WaitForMultipleObjects" );
else if ( ret == WAIT_FAILED )
return TW_FAILED;
else
Error( "Unknown return value (%lu) from WaitForMultipleObjects", ret );
// We'll never get here..
return 0;
#else
CThreadSyncObject **ppObjects = (CThreadSyncObject**)stackalloc( sizeof( CThreadSyncObject* ) * nObjects );
for ( int i=0; i < nObjects; i++ )
{
ppObjects[i] = &pObjects[i];
}
return WaitForMultiple( nObjects, ppObjects, bWaitAll, dwTimeout );
#endif
}
// To implement these, I need to check that casts are safe
uint32 CThreadEvent::WaitForMultiple( int nObjects, CThreadEvent *pObjects, bool bWaitAll, uint32 dwTimeout )
{
// If data ever gets added to CThreadEvent, then we need a different implementation.
#ifdef _PS3
CThreadEvent **ppObjects = (CThreadEvent**)stackalloc( sizeof( CThreadEvent* ) * nObjects );
for ( int i=0; i < nObjects; i++ )
{
ppObjects[i] = &pObjects[i];
}
return WaitForMultipleObjects( nObjects, ppObjects, bWaitAll, dwTimeout );
#else
COMPILE_TIME_ASSERT( sizeof( CThreadSyncObject ) == 0 || sizeof( CThreadEvent ) == sizeof( CThreadSyncObject ) );
return CThreadSyncObject::WaitForMultiple( nObjects, (CThreadSyncObject*)pObjects, bWaitAll, dwTimeout );
#endif
}
uint32 CThreadEvent::WaitForMultiple( int nObjects, CThreadEvent **ppObjects, bool bWaitAll, uint32 dwTimeout )
{
#ifdef _PS3
return WaitForMultipleObjects( nObjects, ppObjects, bWaitAll, dwTimeout );
#else
// If data ever gets added to CThreadEvent, then we need a different implementation.
COMPILE_TIME_ASSERT( sizeof( CThreadSyncObject )== 0 || sizeof( CThreadEvent ) == sizeof( CThreadSyncObject ) );
return CThreadSyncObject::WaitForMultiple( nObjects, (CThreadSyncObject**)ppObjects, bWaitAll, dwTimeout );
#endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CThreadEvent::CThreadEvent( bool bManualReset )
{
#ifdef _WIN32
m_hSyncObject = CreateEvent( NULL, bManualReset, FALSE, NULL );
m_bCreatedHandle = true;
AssertMsg1(m_hSyncObject, "Failed to create event (error 0x%x)", GetLastError() );
#elif defined( _PS3 )
m_bManualReset = bManualReset;
m_bSet = 0;
m_bInitalized = false;
m_numWaitingThread = 0;
// set up linked list of wait objects
memset(&m_waitObjects[0], 0, sizeof(m_waitObjects));
m_pWaitObjectsList = &m_waitObjects[0];
m_pWaitObjectsPool = &m_waitObjects[1];
for (int i = 2; i < CTHREADEVENT_MAX_WAITING_THREADS + 2; i++)
{
LLLinkNode(m_pWaitObjectsPool, &m_waitObjects[i]);
}
#elif defined( POSIX )
pthread_mutexattr_t Attr;
pthread_mutexattr_init( &Attr );
pthread_mutex_init( &m_Mutex, &Attr );
pthread_mutexattr_destroy( &Attr );
pthread_cond_init( &m_Condition, NULL );
m_bInitalized = true;
m_cSet = 0;
m_bWakeForEvent = false;
m_bManualReset = bManualReset;
#else
#error "Implement me"
#endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#ifdef _PS3
//
// linked list functionality
//
//-----------------------------------------------------------------------------
// Purpose: Linked list implementation
//-----------------------------------------------------------------------------
CThreadEventWaitObject* CThreadEvent::LLUnlinkNode(CThreadEventWaitObject *node)
{
// <sergiy> Note: if you have a null-access crash here, it may mean that CTHREADEVENT_MAX_WAITING_THREADS is not high enough
// and the linked list pool is simply exhausted
node->m_pPrev->m_pNext = node->m_pNext;
if (node->m_pNext) node->m_pNext->m_pPrev = node->m_pPrev;
node->m_pNext = node->m_pPrev = NULL;
return node;
}
CThreadEventWaitObject* CThreadEvent::LLLinkNode(CThreadEventWaitObject* list, CThreadEventWaitObject *node)
{
node->m_pNext = list->m_pNext;
if (node->m_pNext)
{
node->m_pNext->m_pPrev = node;
}
list->m_pNext = node;
node->m_pPrev = list;
return node;
}
//-----------------------------------------------------------------------------
// Helper function to atomically write index into destination and set semaphore
// This is used by WaitForMultipleObjects(WAIT_ANY) because once the semaphore
// is set, the waiting thread also needs to know which event triggered it
// We do NOT need this to be atomic because if a number of events fire it doesn't
// matter which one of these we pick
//-----------------------------------------------------------------------------
void CThreadEventWaitObject::Set()
{
*m_pFlag = m_index;
sys_semaphore_post(*m_pSemaphore, 1);
}
//
// CThreadEvent::RegisterWaitingThread
//
void CThreadEvent::RegisterWaitingThread(sys_semaphore_t *pSemaphore, int index, int *flag)
{
sys_lwmutex_lock(&m_staticMutex, 0);
// if we are already set, then signal this semaphore
if (m_bSet)
{
CThreadEventWaitObject waitObject;
waitObject.Init(pSemaphore, index, flag);
waitObject.Set();
if (!m_bManualReset)
{
m_bSet = false;
}
}
else
{
if (!m_pWaitObjectsPool->m_pNext)
{
DEBUG_ERROR("CThreadEvent: Ran out of events; cannot register waiting thread\n");
}
// add this semaphore to linked list - can be added more than once it doesn't matter
CThreadEventWaitObject *pWaitObject = LLUnlinkNode(m_pWaitObjectsPool->m_pNext);
pWaitObject->Init(pSemaphore, index, flag);
LLLinkNode(m_pWaitObjectsList, pWaitObject);
}
sys_lwmutex_unlock(&m_staticMutex);
}
//
// CThreadEvent::UnregisterWaitingThread
//
void CThreadEvent::UnregisterWaitingThread(sys_semaphore_t *pSemaphore)
{
// remove all instances of this semaphore from linked list
sys_lwmutex_lock(&m_staticMutex, 0);
CThreadEventWaitObject *pWaitObject = m_pWaitObjectsList->m_pNext;
while (pWaitObject)
{
CThreadEventWaitObject *pNext = pWaitObject->m_pNext;
if (pWaitObject->m_pSemaphore == pSemaphore)
{
LLUnlinkNode(pWaitObject);
LLLinkNode(m_pWaitObjectsPool, pWaitObject);
}
pWaitObject = pNext;
}
sys_lwmutex_unlock(&m_staticMutex);
}
#endif // _PS3
#ifdef _WIN32
CThreadEvent::CThreadEvent( const char *name, bool initialState, bool bManualReset )
{
m_hSyncObject = CreateEvent( NULL, bManualReset, (BOOL) initialState, name );
AssertMsg1( m_hSyncObject, "Failed to create event (error 0x%x)", GetLastError() );
}
NamedEventResult_t CThreadEvent::CheckNamedEvent( const char *name, uint32 dwTimeout )
{
HANDLE eHandle = OpenEvent( SYNCHRONIZE, FALSE, name );
if ( eHandle == NULL ) return TT_EventDoesntExist;
DWORD result = WaitForSingleObject( eHandle, dwTimeout );
return ( result == WAIT_OBJECT_0 ) ? TT_EventSignaled : TT_EventNotSignaled;
}
#endif
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
//---------------------------------------------------------
bool CThreadEvent::Set()
{
//////////////////////////////////////////////////////////////
#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
AssertUseable();
#ifdef _WIN32
return ( SetEvent( m_hSyncObject ) != 0 );
#elif defined( _PS3 )
sys_lwmutex_lock(&m_staticMutex, 0);
if (m_bManualReset)
{
//Mark event as set
m_bSet = true;
//If any threads are already waiting then signal them to run
if (m_bInitalized)
{
int err = sys_semaphore_post( m_Semaphore, m_numWaitingThread);
Assert(err == CELL_OK);
}
}
else
{
//If any threads are already waiting then signal ONE to run, else signal next to run
if (m_numWaitingThread>0)
{
int err = sys_semaphore_post( m_Semaphore, 1);
Assert(err == CELL_OK);
}
else
{
m_bSet=true;
}
}
sys_lwmutex_unlock(&m_staticMutex);
return true;
#elif defined(POSIX)
pthread_mutex_lock( &m_Mutex );
m_cSet = 1;
m_bWakeForEvent = true;
int ret = pthread_cond_signal( &m_Condition );
pthread_mutex_unlock( &m_Mutex );
return ret == 0;
#endif
//////////////////////////////////////////////////////////////
#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
sys_lwmutex_lock(&m_staticMutex, 0);
//Mark event as set
m_bSet = true;
// signal registered semaphores
while (m_pWaitObjectsList->m_pNext)
{
CThreadEventWaitObject *pWaitObject = LLUnlinkNode(m_pWaitObjectsList->m_pNext);
pWaitObject->Set();
LLLinkNode(m_pWaitObjectsPool, pWaitObject);
g_pfnPopMarker();
if (!m_bManualReset)
{
m_bSet = false;
break;
}
}
sys_lwmutex_unlock(&m_staticMutex);
return true;
//////////////////////////////////////////////////////////////
#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
}
//---------------------------------------------------------
bool CThreadEvent::Reset()
{
#ifdef THREADS_DEBUG
AssertUseable();
#endif
#ifdef _WIN32
return ( ResetEvent( m_hSyncObject ) != 0 );
#elif defined( _PS3 )
//Just mark us as no longer signaled
m_bSet = 0;
return true;
#elif defined(POSIX)
pthread_mutex_lock( &m_Mutex );
m_cSet = 0;
m_bWakeForEvent = false;
pthread_mutex_unlock( &m_Mutex );
return true;
#endif
}
//---------------------------------------------------------
bool CThreadEvent::Check()
{
#ifdef _PS3
return m_bSet; // Please, use for debugging only!
#endif
#ifdef THREADS_DEBUG
AssertUseable();
#endif
return Wait( 0 );
}
bool CThreadEvent::Wait( uint32 dwTimeout )
{
//////////////////////////////////////////////////////////////
#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
#if defined( _WIN32 ) || ( defined( POSIX ) && !defined( _PS3 ) )
return CThreadSyncObject::Wait( dwTimeout );
#elif defined( _PS3 )
{
if (dwTimeout == 0)
{
//If timeout is 0 then just test it now (and reset it if manual )
if (m_bSet)
{
if ( !m_bManualReset ) m_bSet=false;
return true;
}
return false;
}
if (!AddWaitingThread())
{
//Waiting thread NOT added because m_bSet was already set
if ( !m_bManualReset ) m_bSet=false;
return true;
}
uint32 timeout;
int countTimeout = 0;
int ret = ETIMEDOUT;
while ( timeout=MIN(1, dwTimeout) )
{
// on the PS3, "infinite timeout" is specified by zero, not
// 0xFFFFFFFF, so we need to perform that ternary here.
//#error Untested code:
ret = sys_semaphore_wait( m_Semaphore, timeout == TT_INFINITE ? 0 : timeout * 1000 );
Assert( (ret == CELL_OK) || (ret == ETIMEDOUT) );
if ( ret == CELL_OK )
break;
dwTimeout -= timeout;
countTimeout++;
if (countTimeout > 30)
{
// printf("WARNING: possible deadlock in CThreadEvent::Wait() !!!\n");
}
}
RemoveWaitingThread();
if ( !m_bManualReset ) m_bSet=false;
return ret == CELL_OK;
}
#endif
//////////////////////////////////////////////////////////////
#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
CThreadEvent *pThis = this;
DWORD res = WaitForMultipleObjects(1, &pThis, true, dwTimeout);
return res == WAIT_OBJECT_0;
//////////////////////////////////////////////////////////////
#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
}
#ifdef _WIN32
//-----------------------------------------------------------------------------
//
// CThreadSemaphore
//
// To get Posix implementation, try http://www-128.ibm.com/developerworks/eserver/library/es-win32linux-sem.html
//
//-----------------------------------------------------------------------------
CThreadSemaphore::CThreadSemaphore( int32 initialValue, int32 maxValue )
{
#ifdef _WIN32
if ( maxValue )
{
AssertMsg( maxValue > 0, "Invalid max value for semaphore" );
AssertMsg( initialValue >= 0 && initialValue <= maxValue, "Invalid initial value for semaphore" );
m_hSyncObject = CreateSemaphore( NULL, initialValue, maxValue, NULL );
AssertMsg1(m_hSyncObject, "Failed to create semaphore (error 0x%x)", GetLastError());
}
else
{
m_hSyncObject = NULL;
}
#elif defined( _PS3 )
if ( maxValue )
{
m_sema_max_val = maxValue;
m_semaCount = initialValue;
}
#endif
}
#ifdef _PS3
//---------------------------------------------------------
bool CThreadSemaphore::AddWaitingThread()
{
bool result;
sys_lwmutex_lock(&m_staticMutex, 0);
if (cellAtomicTestAndDecr32(&m_semaCount) > 0)
{
result=false;
}
else
{
result=true;
m_numWaitingThread++;
if ( m_numWaitingThread == 1 )
{
sys_semaphore_attribute_t semAttr;
sys_semaphore_attribute_initialize( semAttr );
Assert(m_semaCount == 0);
int err = sys_semaphore_create( &m_Semaphore, &semAttr, 0, m_sema_max_val );
Assert( err == CELL_OK );
m_bInitalized = true;
}
}
sys_lwmutex_unlock(&m_staticMutex);
return result;
}
void CThreadSemaphore::RemoveWaitingThread()
{
sys_lwmutex_lock(&m_staticMutex, 0);
m_numWaitingThread--;
if ( m_numWaitingThread == 0)
{
int err = sys_semaphore_destroy( m_Semaphore );
Assert( err == CELL_OK );
m_bInitalized = false;
}
sys_lwmutex_unlock(&m_staticMutex);
}
#endif
#ifdef _PS3
bool CThreadSemaphore::Wait( uint32 dwTimeout )
{
#ifdef THREADS_DEBUG
AssertUseable();
#endif
#ifndef NO_THREAD_SYNC
if (!AddWaitingThread())
{
//Waiting thread NOT added because semaphore was already in a signaled state
return true;
}
int ret = sys_semaphore_wait( m_Semaphore, dwTimeout == TT_INFINITE ? 0 : dwTimeout * 1000 );
Assert( (ret == CELL_OK) || (ret == ETIMEDOUT) );
RemoveWaitingThread();
int old = cellAtomicDecr32(&m_semaCount);
Assert(old>0);
#else
int ret = CELL_OK;
#endif
// sys_ppu_thread_yield doesn't seem to function properly, so sleep instead.
// sys_timer_usleep( 60 );
sys_ppu_thread_yield();
return ret == CELL_OK;
}
#endif
//---------------------------------------------------------
bool CThreadSemaphore::Release( int32 releaseCount, int32 *pPreviousCount )
{
#ifdef THRDTOOL_DEBUG
AssertUseable();
#endif
#ifdef _WIN32
return ( ReleaseSemaphore( m_hSyncObject, releaseCount, (LPLONG)pPreviousCount ) != 0 );
#elif defined( _PS3 )
#ifndef NO_THREAD_SYNC
if (m_bInitalized)
{
sys_semaphore_value_t previousVal;
sys_semaphore_get_value( m_Semaphore, &previousVal );
cellAtomicAdd32(&m_semaCount, releaseCount);
*pPreviousCount = previousVal;
int err = sys_semaphore_post( m_Semaphore, releaseCount );
Assert(err == CELL_OK);
}
#endif
return true;
#endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CThreadFullMutex::CThreadFullMutex( bool bEstablishInitialOwnership, const char *pszName )
{
m_hSyncObject = CreateMutex( NULL, bEstablishInitialOwnership, pszName );
AssertMsg1( m_hSyncObject, "Failed to create mutex (error 0x%x)", GetLastError() );
}
//---------------------------------------------------------
bool CThreadFullMutex::Release()
{
#ifdef THRDTOOL_DEBUG
AssertUseable();
#endif
return ( ReleaseMutex( m_hSyncObject ) != 0 );
}
#endif
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#if defined( WIN32 ) || defined( _PS3 ) || defined( _OSX ) || defined (_LINUX)
#if !defined(_PS3)
namespace GenericThreadLocals
{
#endif
CThreadLocalBase::CThreadLocalBase()
{
#if defined(_WIN32) || defined(_PS3)
m_index = TlsAlloc();
AssertMsg( m_index != 0xFFFFFFFF, "Bad thread local" );
if ( m_index == 0xFFFFFFFF )
Error( "Out of thread local storage!\n" );
#elif defined(POSIX)
if ( pthread_key_create( (pthread_key_t *)&m_index, NULL ) != 0 )
Error( "Out of thread local storage!\n" );
#endif
}
//---------------------------------------------------------
CThreadLocalBase::~CThreadLocalBase()
{
#if defined(_WIN32) || defined(_PS3)
if ( m_index != 0xFFFFFFFF )
TlsFree( m_index );
m_index = 0xFFFFFFFF;
#elif defined(POSIX)
pthread_key_delete( m_index );
#endif
}
//---------------------------------------------------------
void * CThreadLocalBase::Get() const
{
#if defined(_WIN32) || defined(_PS3)
if ( m_index != 0xFFFFFFFF )
return TlsGetValue( m_index );
AssertMsg( 0, "Bad thread local" );
return NULL;
#elif defined(POSIX)
void *value = pthread_getspecific( m_index );
return value;
#endif
}
//---------------------------------------------------------
void CThreadLocalBase::Set( void *value )
{
#if defined(_WIN32) || defined(_PS3)
if (m_index != 0xFFFFFFFF)
TlsSetValue(m_index, value);
else
AssertMsg( 0, "Bad thread local" );
#elif defined(POSIX)
if ( pthread_setspecific( m_index, value ) != 0 )
AssertMsg( 0, "Bad thread local" );
#endif
}
#if !defined(_PS3)
} // namespace GenericThreadLocals
#endif
#endif // ( defined(WIN32) )
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifdef MSVC
//#ifdef _X360
#define TO_INTERLOCK_PARAM(p) ((volatile long *)p)
#define TO_INTERLOCK_PTR_PARAM(p) ((void **)p)
//#else
//#define TO_INTERLOCK_PARAM(p) (p)
//#define TO_INTERLOCK_PTR_PARAM(p) (p)
//#endif
#if !defined(USE_INTRINSIC_INTERLOCKED) && !defined(_X360)
int32 ThreadInterlockedIncrement( int32 volatile *pDest )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedIncrement( TO_INTERLOCK_PARAM(pDest) );
}
int32 ThreadInterlockedDecrement( int32 volatile *pDest )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedDecrement( TO_INTERLOCK_PARAM(pDest) );
}
int32 ThreadInterlockedExchange( int32 volatile *pDest, int32 value )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedExchange( TO_INTERLOCK_PARAM(pDest), value );
}
int32 ThreadInterlockedExchangeAdd( int32 volatile *pDest, int32 value )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedExchangeAdd( TO_INTERLOCK_PARAM(pDest), value );
}
int32 ThreadInterlockedCompareExchange( int32 volatile *pDest, int32 value, int32 comperand )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedCompareExchange( TO_INTERLOCK_PARAM(pDest), value, comperand );
}
bool ThreadInterlockedAssignIf( int32 volatile *pDest, int32 value, int32 comperand )
{
Assert( (size_t)pDest % 4 == 0 );
#if !(defined(_WIN64) || defined (_X360))
__asm
{
mov eax,comperand
mov ecx,pDest
mov edx,value
lock cmpxchg [ecx],edx
mov eax,0
setz al
}
#else
return ( InterlockedCompareExchange( TO_INTERLOCK_PARAM(pDest), value, comperand ) == comperand );
#endif
}
#endif
#if !defined( USE_INTRINSIC_INTERLOCKED ) || defined( _WIN64 )
void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value );
}
void *ThreadInterlockedCompareExchangePointer( void * volatile *pDest, void *value, void *comperand )
{
Assert( (size_t)pDest % 4 == 0 );
return InterlockedCompareExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value, comperand );
}
bool ThreadInterlockedAssignPointerIf( void * volatile *pDest, void *value, void *comperand )
{
Assert( (size_t)pDest % 4 == 0 );
#if !(defined(_WIN64) || defined (_X360))
__asm
{
mov eax,comperand
mov ecx,pDest
mov edx,value
lock cmpxchg [ecx],edx
mov eax,0
setz al
}
#else
return ( InterlockedCompareExchangePointer( TO_INTERLOCK_PTR_PARAM(pDest), value, comperand ) == comperand );
#endif
}
#endif
#ifdef COMPILER_MSVC32
int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand )
{
Assert( (size_t)pDest % 8 == 0 );
__asm
{
lea esi,comperand;
lea edi,value;
mov eax,[esi];
mov edx,4[esi];
mov ebx,[edi];
mov ecx,4[edi];
mov esi,pDest;
lock CMPXCHG8B [esi];
}
}
#endif
bool ThreadInterlockedAssignIf64(volatile int64 *pDest, int64 value, int64 comperand )
{
Assert( (size_t)pDest % 8 == 0 );
#if defined(_X360) || defined(_WIN64)
return ( ThreadInterlockedCompareExchange64( pDest, value, comperand ) == comperand );
#else
__asm
{
lea esi,comperand;
lea edi,value;
mov eax,[esi];
mov edx,4[esi];
mov ebx,[edi];
mov ecx,4[edi];
mov esi,pDest;
lock CMPXCHG8B [esi];
mov eax,0;
setz al;
}
#endif
}
#ifdef _WIN64
bool ThreadInterlockedAssignIf128( volatile int128 *pDest, const int128 &value, const int128 &comperand )
{
DbgAssert( ( (size_t)pDest % 16 ) == 0 );
// Must copy comperand to stack because the intrinsic uses it as an in/out param
int64 comperandInOut[2] = { comperand.m128i_i64[0], comperand.m128i_i64[1] };
// Description:
// The CMPXCHG16B instruction compares the 128-bit value in the RDX:RAX and RCX:RBX registers
// with a 128-bit memory location. If the values are equal, the zero flag (ZF) is set,
// and the RCX:RBX value is copied to the memory location.
// Otherwise, the ZF flag is cleared, and the memory value is copied to RDX:RAX.
// _InterlockedCompareExchange128: http://msdn.microsoft.com/en-us/library/bb514094.aspx
if ( _InterlockedCompareExchange128( ( volatile int64 * )pDest, value.m128i_i64[1], value.m128i_i64[0], comperandInOut ) )
return true;
return false;
}
#endif
#elif defined(GNUC)
#ifdef OSX
#include <libkern/OSAtomic.h>
#endif
long ThreadInterlockedIncrement( long volatile *pDest )
{
return __sync_fetch_and_add( pDest, 1 ) + 1;
}
long ThreadInterlockedDecrement( long volatile *pDest )
{
return __sync_fetch_and_sub( pDest, 1 ) - 1;
}
long ThreadInterlockedExchange( long volatile *pDest, long value )
{
return __sync_lock_test_and_set( pDest, value );
}
long ThreadInterlockedExchangeAdd( long volatile *pDest, long value )
{
return __sync_fetch_and_add( pDest, value );
}
long ThreadInterlockedCompareExchange( long volatile *pDest, long value, long comperand )
{
return __sync_val_compare_and_swap( pDest, comperand, value );
}
bool ThreadInterlockedAssignIf( long volatile *pDest, long value, long comperand )
{
return __sync_bool_compare_and_swap( pDest, comperand, value );
}
#if !defined( USE_INTRINSIC_INTERLOCKED )
void *ThreadInterlockedCompareExchangePointer( void *volatile *pDest, void *value, void *comperand )
{
return __sync_val_compare_and_swap( pDest, comperand, value );
}
bool ThreadInterlockedAssignPointerIf( void * volatile *pDest, void *value, void *comperand )
{
return __sync_bool_compare_and_swap( pDest, comperand, value );
}
#elif defined( PLATFORM_64BITS )
void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value )
{
return __sync_lock_test_and_set( pDest, value );
}
void *ThreadInterlockedCompareExchangePointer( void * volatile *p, void *value, void *comparand ) {
return (void *)( ( intp )ThreadInterlockedCompareExchange64( reinterpret_cast<intp volatile *>(p), reinterpret_cast<intp>(value), reinterpret_cast<intp>(comparand) ) );
}
#endif
int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand )
{
return __sync_val_compare_and_swap( pDest, comperand, value );
}
bool ThreadInterlockedAssignIf64( int64 volatile * pDest, int64 value, int64 comperand )
{
return __sync_bool_compare_and_swap( pDest, comperand, value );
}
#elif defined( _PS3 )
// This is defined in the header!
#else
// This will perform horribly,
#error "Falling back to mutexed interlocked operations, you really don't have intrinsics you can use?"ß
CThreadMutex g_InterlockedMutex;
long ThreadInterlockedIncrement( long volatile *pDest )
{
AUTO_LOCK( g_InterlockedMutex );
return ++(*pDest);
}
long ThreadInterlockedDecrement( long volatile *pDest )
{
AUTO_LOCK( g_InterlockedMutex );
return --(*pDest);
}
long ThreadInterlockedExchange( long volatile *pDest, long value )
{
AUTO_LOCK( g_InterlockedMutex );
long retVal = *pDest;
*pDest = value;
return retVal;
}
void *ThreadInterlockedExchangePointer( void * volatile *pDest, void *value )
{
AUTO_LOCK( g_InterlockedMutex );
void *retVal = *pDest;
*pDest = value;
return retVal;
}
long ThreadInterlockedExchangeAdd( long volatile *pDest, long value )
{
AUTO_LOCK( g_InterlockedMutex );
long retVal = *pDest;
*pDest += value;
return retVal;
}
long ThreadInterlockedCompareExchange( long volatile *pDest, long value, long comperand )
{
AUTO_LOCK( g_InterlockedMutex );
long retVal = *pDest;
if ( *pDest == comperand )
*pDest = value;
return retVal;
}
void *ThreadInterlockedCompareExchangePointer( void * volatile *pDest, void *value, void *comperand )
{
AUTO_LOCK( g_InterlockedMutex );
void *retVal = *pDest;
if ( *pDest == comperand )
*pDest = value;
return retVal;
}
int64 ThreadInterlockedCompareExchange64( int64 volatile *pDest, int64 value, int64 comperand )
{
Assert( (size_t)pDest % 8 == 0 );
AUTO_LOCK( g_InterlockedMutex );
int64 retVal = *pDest;
if ( *pDest == comperand )
*pDest = value;
return retVal;
}
#endif
#ifdef COMPILER_MSVC32
PLATFORM_INTERFACE int64 ThreadInterlockedOr64( int64 volatile *pDest, int64 value )
{
int64 Old;
do
{
Old = *pDest;
} while ( ThreadInterlockedCompareExchange64( pDest, Old | value, Old ) != Old );
return Old;
}
PLATFORM_INTERFACE int64 ThreadInterlockedAnd64( int64 volatile *pDest, int64 value )
{
int64 Old;
do
{
Old = *pDest;
} while ( ThreadInterlockedCompareExchange64( pDest, Old & value, Old ) != Old );
return Old;
}
PLATFORM_INTERFACE int64 ThreadInterlockedIncrement64( int64 volatile *pDest )
{
int64 Old;
do
{
Old = *pDest;
} while ( ThreadInterlockedCompareExchange64( pDest, Old + 1, Old ) != Old );
return Old + 1;
}
PLATFORM_INTERFACE int64 ThreadInterlockedDecrement64( int64 volatile *pDest )
{
int64 Old;
do
{
Old = *pDest;
} while ( ThreadInterlockedCompareExchange64( pDest, Old - 1, Old ) != Old );
return Old - 1;
}
PLATFORM_INTERFACE int64 ThreadInterlockedExchangeAdd64( int64 volatile *pDest, int64 value )
{
int64 Old;
do
{
Old = *pDest;
} while ( ThreadInterlockedCompareExchange64( pDest, Old + value, Old ) != Old );
return Old;
}
#endif
int64 ThreadInterlockedExchange64( int64 volatile *pDest, int64 value )
{
Assert( (size_t)pDest % 8 == 0 );
int64 Old;
do
{
Old = *pDest;
} while (ThreadInterlockedCompareExchange64(pDest, value, Old) != Old);
return Old;
}
//-----------------------------------------------------------------------------
#if defined(_WIN32) && defined(THREAD_PROFILER)
void ThreadNotifySyncNoop(void *p) {}
#define MAP_THREAD_PROFILER_CALL( from, to ) \
void from(void *p) \
{ \
static CDynamicFunction<void (*)(void *)> dynFunc( "libittnotify.dll", #to, ThreadNotifySyncNoop ); \
(*dynFunc)(p); \
}
MAP_THREAD_PROFILER_CALL( ThreadNotifySyncPrepare, __itt_notify_sync_prepare );
MAP_THREAD_PROFILER_CALL( ThreadNotifySyncCancel, __itt_notify_sync_cancel );
MAP_THREAD_PROFILER_CALL( ThreadNotifySyncAcquired, __itt_notify_sync_acquired );
MAP_THREAD_PROFILER_CALL( ThreadNotifySyncReleasing, __itt_notify_sync_releasing );
#endif
//-----------------------------------------------------------------------------
//
// CThreadMutex
//
//-----------------------------------------------------------------------------
#ifdef _PS3
CThreadMutex::CThreadMutex()
{
// sys_mutex with recursion enabled is like a win32 critical section
sys_mutex_attribute_t mutexAttr;
sys_mutex_attribute_initialize( mutexAttr );
mutexAttr.attr_recursive = SYS_SYNC_RECURSIVE;
sys_mutex_create( &m_Mutex, &mutexAttr );
}
CThreadMutex::~CThreadMutex()
{
sys_mutex_destroy( m_Mutex );
}
#elif !defined( POSIX )
CThreadMutex::CThreadMutex()
{
#ifdef THREAD_MUTEX_TRACING_ENABLED
memset( &m_CriticalSection, 0, sizeof(m_CriticalSection) );
#endif
InitializeCriticalSectionAndSpinCount((CRITICAL_SECTION *)&m_CriticalSection, 4000);
#ifdef THREAD_MUTEX_TRACING_SUPPORTED
// These need to be initialized unconditionally in case mixing release & debug object modules
// Lock and unlock may be emitted as COMDATs, in which case may get spurious output
m_currentOwnerID = m_lockCount = 0;
m_bTrace = false;
#endif
}
CThreadMutex::~CThreadMutex()
{
DeleteCriticalSection((CRITICAL_SECTION *)&m_CriticalSection);
}
#endif // !POSIX
#ifdef IS_WINDOWS_PC
typedef BOOL (WINAPI*TryEnterCriticalSectionFunc_t)(LPCRITICAL_SECTION);
static CDynamicFunction<TryEnterCriticalSectionFunc_t> DynTryEnterCriticalSection( "Kernel32.dll", "TryEnterCriticalSection" );
#elif defined( _X360 )
#define DynTryEnterCriticalSection TryEnterCriticalSection
#endif
bool CThreadMutex::TryLock()
{
#if defined( MSVC )
#ifdef THREAD_MUTEX_TRACING_ENABLED
uint thisThreadID = ThreadGetCurrentId();
if ( m_bTrace && m_currentOwnerID && ( m_currentOwnerID != thisThreadID ) )
Msg( "Thread %u about to try-wait for lock %p owned by %u\n", ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection, m_currentOwnerID );
#endif
if ( DynTryEnterCriticalSection != NULL )
{
if ( (*DynTryEnterCriticalSection )( (CRITICAL_SECTION *)&m_CriticalSection ) != FALSE )
{
#ifdef THREAD_MUTEX_TRACING_ENABLED
if (m_lockCount == 0)
{
// we now own it for the first time. Set owner information
m_currentOwnerID = thisThreadID;
if ( m_bTrace )
Msg( "Thread %u now owns lock %p\n", m_currentOwnerID, (CRITICAL_SECTION *)&m_CriticalSection );
}
m_lockCount++;
#endif
return true;
}
return false;
}
Lock();
return true;
#elif defined( _PS3 )
#ifndef NO_THREAD_SYNC
if ( sys_mutex_trylock( m_Mutex ) == CELL_OK )
#endif
return true;
return false; // ?? moved from EA code
#elif defined( POSIX )
return pthread_mutex_trylock( &m_Mutex ) == 0;
#else
#error "Implement me!"
return true;
#endif
}
//-----------------------------------------------------------------------------
//
// CThreadFastMutex
//
//-----------------------------------------------------------------------------
#ifdef THREAD_FAST_MUTEX_TIMINGS
// This is meant to be used in combination with breakpoints and in-debugee, so we turn the optimizer off
#pragma optimize( "", off )
CThreadFastMutex *g_pIgnoredMutexes[256]; // Ignore noisy non-problem mutex. Probably could be an array. Right now needed only for sound thread
float g_MutexTimingTolerance = 5;
bool g_bMutexTimingOutput;
void TrapMutexTimings( uint32 probableBlocker, uint32 thisThread, volatile CThreadFastMutex *pMutex, CFastTimer &spikeTimer, CAverageCycleCounter &sleepTimer )
{
spikeTimer.End();
if ( spikeTimer.GetDuration().GetMillisecondsF() > g_MutexTimingTolerance )
{
bool bIgnore = false;
for ( int j = 0; j < ARRAYSIZE( g_pIgnoredMutexes ) && g_pIgnoredMutexes[j]; j++ )
{
if ( g_pIgnoredMutexes[j] == pMutex )
{
bIgnore = true;
break;
}
}
if ( !bIgnore && spikeTimer.GetDuration().GetMillisecondsF() < 100 )
{
volatile float FastMutexDuration = spikeTimer.GetDuration().GetMillisecondsF();
volatile float average = sleepTimer.GetAverageMilliseconds();
volatile float peak = sleepTimer.GetPeakMilliseconds(); volatile int xx = 6;
if ( g_bMutexTimingOutput )
{
char szBuf[256];
Msg( "M (%.8x): [%.8x <-- %.8x] (%f,%f,%f)\n", pMutex, probableBlocker, thisThread, FastMutexDuration, average, peak );
}
}
}
}
#else
#define TrapMutexTimings( a, b, c, d, e ) ((void)0)
#endif
//-------------------------------------
#define THREAD_SPIN (8*1024)
void CThreadFastMutex::Lock( const uint32 threadId, unsigned nSpinSleepTime ) volatile
{
#ifdef THREAD_FAST_MUTEX_TIMINGS
CAverageCycleCounter sleepTimer;
CFastTimer spikeTimer;
uint32 currentOwner = m_ownerID;
spikeTimer.Start();
sleepTimer.Init();
#endif
int i;
if ( nSpinSleepTime != TT_INFINITE )
{
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLock( threadId ) )
{
TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer );
return;
}
ThreadPause();
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLock( threadId ) )
{
TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer );
return;
}
ThreadPause();
if ( i % 1024 == 0 )
{
#ifdef THREAD_FAST_MUTEX_TIMINGS
CAverageTimeMarker marker( &sleepTimer );
#endif
ThreadSleep( 0 );
}
}
#ifdef _WIN32
if ( !nSpinSleepTime && GetThreadPriority( GetCurrentThread() ) > THREAD_PRIORITY_NORMAL )
{
nSpinSleepTime = 1;
}
#endif
if ( nSpinSleepTime )
{
for ( i = THREAD_SPIN; i != 0; --i )
{
#ifdef THREAD_FAST_MUTEX_TIMINGS
CAverageTimeMarker marker( &sleepTimer );
#endif
if ( TryLock( threadId ) )
{
TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer );
return;
}
ThreadPause();
ThreadSleep( 0 );
}
}
for ( ;; )
{
#ifdef THREAD_FAST_MUTEX_TIMINGS
CAverageTimeMarker marker( &sleepTimer );
#endif
if ( TryLock( threadId ) )
{
TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer );
return;
}
ThreadPause();
ThreadSleep( nSpinSleepTime );
}
}
else
{
for ( ;; )
{
if ( TryLock( threadId ) )
{
TrapMutexTimings( currentOwner, threadId, this, spikeTimer, sleepTimer );
return;
}
ThreadPause();
}
}
}
#ifdef THREAD_FAST_MUTEX_TIMINGS
#pragma optimize( "", on )
#endif
//-----------------------------------------------------------------------------
//
// CThreadRWLock
//
//-----------------------------------------------------------------------------
void CThreadRWLock::WaitForRead()
{
m_nPendingReaders++;
do
{
m_mutex.Unlock();
m_CanRead.Wait();
m_mutex.Lock();
}
while (m_nWriters);
m_nPendingReaders--;
}
void CThreadRWLock::LockForWrite()
{
m_mutex.Lock();
bool bWait = ( m_nWriters != 0 || m_nActiveReaders != 0 );
m_nWriters++;
m_CanRead.Reset();
m_mutex.Unlock();
if ( bWait )
{
m_CanWrite.Wait();
}
}
void CThreadRWLock::UnlockWrite()
{
m_mutex.Lock();
m_nWriters--;
if ( m_nWriters == 0)
{
if ( m_nPendingReaders )
{
m_CanRead.Set();
}
}
else
{
m_CanWrite.Set();
}
m_mutex.Unlock();
}
//-----------------------------------------------------------------------------
//
// CThreadSpinRWLock
//
//-----------------------------------------------------------------------------
#ifndef OLD_SPINRWLOCK
void CThreadSpinRWLock::SpinLockForWrite()
{
int i;
if ( TryLockForWrite_UnforcedInline() )
{
return;
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForWrite_UnforcedInline() )
{
return;
}
ThreadPause();
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForWrite_UnforcedInline() )
{
return;
}
ThreadPause();
if ( i % 1024 == 0 )
{
ThreadSleep( 0 );
}
}
for ( i = THREAD_SPIN * 4; i != 0; --i )
{
if ( TryLockForWrite_UnforcedInline() )
{
return;
}
ThreadPause();
ThreadSleep( 0 );
}
for ( ;; ) // coded as for instead of while to make easy to breakpoint success
{
if ( TryLockForWrite_UnforcedInline() )
{
return;
}
ThreadPause();
ThreadSleep( 1 );
}
}
void CThreadSpinRWLock::SpinLockForRead()
{
int i;
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForRead_UnforcedInline() )
{
return;
}
ThreadPause();
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForRead_UnforcedInline() )
{
return;
}
ThreadPause();
if ( i % 1024 == 0 )
{
ThreadSleep( 0 );
}
}
for ( i = THREAD_SPIN * 4; i != 0; --i )
{
if ( TryLockForRead_UnforcedInline() )
{
return;
}
ThreadPause();
ThreadSleep( 0 );
}
for ( ;; ) // coded as for instead of while to make easy to breakpoint success
{
if ( TryLockForRead_UnforcedInline() )
{
return;
}
ThreadPause();
ThreadSleep( 1 );
}
}
#else
/* (commented out to reduce distraction in colorized editor, remove entirely when new implementation settles)
void CThreadSpinRWLock::SpinLockForWrite( const uint32 threadId )
{
int i;
if ( TryLockForWrite( threadId ) )
{
return;
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForWrite( threadId ) )
{
return;
}
ThreadPause();
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForWrite( threadId ) )
{
return;
}
ThreadPause();
if ( i % 1024 == 0 )
{
ThreadSleep( 0 );
}
}
for ( i = THREAD_SPIN * 4; i != 0; --i )
{
if ( TryLockForWrite( threadId ) )
{
return;
}
ThreadPause();
ThreadSleep( 0 );
}
for ( ;; ) // coded as for instead of while to make easy to breakpoint success
{
if ( TryLockForWrite( threadId ) )
{
return;
}
ThreadPause();
ThreadSleep( 1 );
}
}
void CThreadSpinRWLock::LockForRead()
{
int i;
if ( TryLockForRead() )
{
return;
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForRead() )
{
return;
}
ThreadPause();
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if ( TryLockForRead() )
{
return;
}
ThreadPause();
if ( i % 1024 == 0 )
{
ThreadSleep( 0 );
}
}
for ( i = THREAD_SPIN * 4; i != 0; --i )
{
if ( TryLockForRead() )
{
return;
}
ThreadPause();
ThreadSleep( 0 );
}
for ( ;; ) // coded as for instead of while to make easy to breakpoint success
{
if ( TryLockForRead() )
{
return;
}
ThreadPause();
ThreadSleep( 1 );
}
}
void CThreadSpinRWLock::UnlockRead()
{
int i;
Assert( m_lockInfo.m_nReaders > 0 && m_lockInfo.m_writerId == 0 );
//uint32 nLockInfoReaders = m_lockInfo.m_nReaders;
LockInfo_t oldValue;
LockInfo_t newValue;
if( IsX360() )
{
// this is the code equivalent to original code (see below) that doesn't cause LHS on Xbox360
// WARNING: This code assumes BIG Endian CPU
oldValue.m_i64 = uint32( m_lockInfo.m_nReaders );
newValue.m_i64 = oldValue.m_i64 - 1; // NOTE: when we have -1 (or 0xFFFFFFFF) readers, this will result in non-equivalent code
}
else
{
// this is the original code that worked here for a while
oldValue.m_nReaders = m_lockInfo.m_nReaders;
oldValue.m_writerId = 0;
newValue.m_nReaders = oldValue.m_nReaders - 1;
newValue.m_writerId = 0;
}
ThreadMemoryBarrier();
if( AssignIf( newValue, oldValue ) )
return;
ThreadPause();
oldValue.m_nReaders = m_lockInfo.m_nReaders;
newValue.m_nReaders = oldValue.m_nReaders - 1;
for ( i = THREAD_SPIN; i != 0; --i )
{
if( AssignIf( newValue, oldValue ) )
return;
ThreadPause();
oldValue.m_nReaders = m_lockInfo.m_nReaders;
newValue.m_nReaders = oldValue.m_nReaders - 1;
}
for ( i = THREAD_SPIN; i != 0; --i )
{
if( AssignIf( newValue, oldValue ) )
return;
ThreadPause();
if ( i % 512 == 0 )
{
ThreadSleep( 0 );
}
oldValue.m_nReaders = m_lockInfo.m_nReaders;
newValue.m_nReaders = oldValue.m_nReaders - 1;
}
for ( i = THREAD_SPIN * 4; i != 0; --i )
{
if( AssignIf( newValue, oldValue ) )
return;
ThreadPause();
ThreadSleep( 0 );
oldValue.m_nReaders = m_lockInfo.m_nReaders;
newValue.m_nReaders = oldValue.m_nReaders - 1;
}
for ( ;; ) // coded as for instead of while to make easy to breakpoint success
{
if( AssignIf( newValue, oldValue ) )
return;
ThreadPause();
ThreadSleep( 1 );
oldValue.m_nReaders = m_lockInfo.m_nReaders;
newValue.m_nReaders = oldValue.m_nReaders - 1;
}
}
void CThreadSpinRWLock::UnlockWrite()
{
Assert( m_lockInfo.m_writerId == ThreadGetCurrentId() && m_lockInfo.m_nReaders == 0 );
static const LockInfo_t newValue = { { 0, 0 } };
ThreadMemoryBarrier();
ThreadInterlockedExchange64( (int64 *)&m_lockInfo, *((int64 *)&newValue) );
m_nWriters--;
}
*/
#endif
#if defined( _PS3 )
// All CThread code is inline in the header for PS3
// This function is implemented here rather than the header because g_pCurThread resolves to GetCurThread() on PS3
// and we don't want to create a dependency on the ELF stub for everyone who includes the header.
PLATFORM_INTERFACE CThread *GetCurThreadPS3()
{
return (CThread*)g_pCurThread;
}
PLATFORM_INTERFACE void SetCurThreadPS3( CThread *pThread )
{
g_pCurThread = pThread;
}
#else
// The CThread implementation needs to be inlined for performance on the PS3 - It makes a difference of more than 1ms/frame
// for other platforms, we include the .inl in the .cpp file where it existed before
#include "../public/tier0/threadtools.inl"
#endif
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CWorkerThread::CWorkerThread()
: m_EventSend(true), // must be manual-reset for PeekCall()
m_EventComplete(true), // must be manual-reset to handle multiple wait with thread properly
m_Param(0),
m_ReturnVal(0)
{
}
//---------------------------------------------------------
int CWorkerThread::CallWorker(unsigned dw, unsigned timeout, bool fBoostWorkerPriorityToMaster)
{
return Call(dw, timeout, fBoostWorkerPriorityToMaster);
}
//---------------------------------------------------------
int CWorkerThread::CallMaster(unsigned dw, unsigned timeout)
{
return Call(dw, timeout, false);
}
//---------------------------------------------------------
CThreadEvent &CWorkerThread::GetCallHandle()
{
return m_EventSend;
}
//---------------------------------------------------------
unsigned CWorkerThread::GetCallParam() const
{
return m_Param;
}
//---------------------------------------------------------
int CWorkerThread::BoostPriority()
{
int iInitialPriority = GetPriority();
#ifdef WIN32
const int iNewPriority = ThreadGetPriority( GetThreadHandle() );
if (iNewPriority > iInitialPriority)
ThreadSetPriority( GetThreadHandle(), iNewPriority);
#elif !defined( _PS3 )
const int iNewPriority = ThreadGetPriority( (ThreadHandle_t)GetThreadID() );
if (iNewPriority > iInitialPriority)
ThreadSetPriority( (ThreadHandle_t)GetThreadID(), iNewPriority);
#endif
return iInitialPriority;
}
//---------------------------------------------------------
static uint32 DefaultWaitFunc( uint32 nHandles, CThreadEvent** ppHandles, int bWaitAll, uint32 timeout )
{
return CThreadEvent::WaitForMultiple( nHandles, ppHandles, bWaitAll!=0, timeout ) ;
}
int CWorkerThread::Call(unsigned dwParam, unsigned timeout, bool fBoostPriority, WaitFunc_t waitFunc)
{
AssertMsg(!m_EventSend.Check(), "Cannot perform call if there's an existing call pending" );
AUTO_LOCK( m_Lock );
if (!IsAlive())
return WTCR_FAIL;
int iInitialPriority = 0;
if (fBoostPriority)
{
iInitialPriority = BoostPriority();
}
// set the parameter, signal the worker thread, wait for the completion to be signaled
m_Param = dwParam;
m_EventComplete.Reset();
m_EventSend.Set();
WaitForReply( timeout, waitFunc );
if (fBoostPriority)
SetPriority(iInitialPriority);
return m_ReturnVal;
}
//---------------------------------------------------------
//
// Wait for a request from the client
//
//---------------------------------------------------------
int CWorkerThread::WaitForReply( unsigned timeout )
{
return WaitForReply( timeout, NULL );
}
int CWorkerThread::WaitForReply( unsigned timeout, WaitFunc_t pfnWait )
{
if (!pfnWait)
{
pfnWait = &DefaultWaitFunc;
}
CThreadEvent *waits[] =
{
&m_EventComplete,
&m_ExitEvent
};
unsigned result;
bool bInDebugger = Plat_IsInDebugSession();
uint32 dwActualTimeout = ( (timeout==TT_INFINITE) ? 30000 : timeout );
do
{
#ifdef WIN32
// Make sure the thread handle hasn't been closed
if ( !GetThreadHandle() )
{
result = 1;
break;
}
#endif
result = (*pfnWait)( ARRAYSIZE( waits ), waits, false, dwActualTimeout );
AssertMsg(timeout != TT_INFINITE || result != TW_TIMEOUT, "Possible hung thread, call to thread timed out");
} while ( bInDebugger && ( timeout == TT_INFINITE && result == TW_TIMEOUT ) );
if ( result != 0 )
{
if (result == TW_TIMEOUT)
{
m_ReturnVal = WTCR_TIMEOUT;
}
else if (result == 1)
{
DevMsg( 2, "Thread failed to respond, probably exited\n");
m_EventSend.Reset();
m_ReturnVal = WTCR_TIMEOUT;
}
else
{
m_EventSend.Reset();
m_ReturnVal = WTCR_THREAD_GONE;
}
}
return m_ReturnVal;
}
//---------------------------------------------------------
//
// Wait for a request from the client
//
//---------------------------------------------------------
bool CWorkerThread::WaitForCall(unsigned * pResult)
{
return WaitForCall(TT_INFINITE, pResult);
}
//---------------------------------------------------------
bool CWorkerThread::WaitForCall(unsigned dwTimeout, unsigned * pResult)
{
bool returnVal = m_EventSend.Wait(dwTimeout);
if (pResult)
*pResult = m_Param;
return returnVal;
}
//---------------------------------------------------------
//
// is there a request?
//
bool CWorkerThread::PeekCall(unsigned * pParam)
{
if (!m_EventSend.Check())
{
return false;
}
else
{
if (pParam)
{
*pParam = m_Param;
}
return true;
}
}
//---------------------------------------------------------
//
// Reply to the request
//
void CWorkerThread::Reply(unsigned dw)
{
m_Param = 0;
m_ReturnVal = dw;
// The request is now complete so PeekCall() should fail from
// now on
//
// This event should be reset BEFORE we signal the client
m_EventSend.Reset();
// Tell the client we're finished
m_EventComplete.Set();
}
//-----------------------------------------------------------------------------
#if defined( _PS3 )
/*******************************************************************************
* PS3 equivalent to Win32 function for setting events
*******************************************************************************/
BOOL SetEvent( CThreadEvent *pEvent )
{
bool bRetVal = pEvent->Set();
if ( !bRetVal )
Assert(0);
return bRetVal;
}
/*******************************************************************************
* PS3 equivalent to Win32 function for resetting events
*******************************************************************************/
BOOL ResetEvent( CThreadEvent *pEvent )
{
return pEvent->Reset();
}
#define MAXIMUM_WAIT_OBJECTS 64
/*******************************************************************************
* Wait for a selection of events to terminate
*******************************************************************************/
DWORD WaitForMultipleObjects( DWORD nCount, CThreadEvent **lppHandles, BOOL bWaitAll, DWORD dwMilliseconds )
{
//////////////////////////////////////////////////////////////
#ifndef NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
// Support for a limited amount of events
if ( nCount >= MAXIMUM_WAIT_OBJECTS )
{
Assert(0);
return false;
}
bool bRunning = true;
unsigned int result = TW_FAILED;
// For bWaitAll
int numEvent = 0;
int eventComplete[ MAXIMUM_WAIT_OBJECTS ] = {0};
uint64_t timeDiffMS = 0;
uint64_t startTimeMS = Plat_MSTime();
uint64_t endTimeMS = 0;
while ( bRunning )
{
// Check for a timeout
if ( bRunning && ( dwMilliseconds != INFINITE ) && ( timeDiffMS > dwMilliseconds ) )
{
result = TW_TIMEOUT;
bRunning = false;
}
// Wait for all the events to be set
if ( bWaitAll )
{
for ( int event = 0; event < nCount; ++event )
{
if ( lppHandles[event]->Wait(1) )
{
// If an event is complete, mark it as complete in our list
if ( eventComplete[ event ] == 0 )
{
numEvent++;
eventComplete[ event ] = 1;
}
}
}
// If all the events have been set, terminate the function
if ( numEvent >= nCount )
{
result = WAIT_OBJECT_0;
bRunning = false;
}
}
// Wait for one event to be set
else
{
for ( int event = 0; event < nCount; ++event )
{
if ( lppHandles[event]->Wait(1) )
{
result = WAIT_OBJECT_0 + event;
bRunning = false;
break;
}
}
}
endTimeMS = Plat_MSTime();
timeDiffMS = endTimeMS - startTimeMS;
}
return result;
//////////////////////////////////////////////////////////////
#else // NEW_WAIT_FOR_MULTIPLE_OBJECTS // (expected PS3 only)
//////////////////////////////////////////////////////////////
#ifndef _PS3
#error This code was written expecting to be run on PS3.
#endif
// check if we have a wait objects semaphore
if (!gbWaitObjectsCreated)
{
sys_semaphore_attribute_t semAttr;
sys_semaphore_attribute_initialize(semAttr);
sys_semaphore_create(&gWaitObjectsSemaphore, &semAttr, 0, 0xFFFF);
gbWaitObjectsCreated = true;
}
// Support for a limited amount of events
if ( nCount >= MAXIMUM_WAIT_OBJECTS )
{
Assert(0);
return false;
}
unsigned int result = WAIT_FAILED;
int res = CELL_OK;
int event = -1;
int numEvent = 0;
// run through events registering this thread with each one
for (int i = 0; i < nCount; i++)
{
lppHandles[i]->RegisterWaitingThread(&gWaitObjectsSemaphore, i, &event);
}
// in the Source API, a timeOut of 0 means very short timeOut, not (as in the PS3 spec) an infinite timeout.
// TT_INFINITE is #defined to 2^31-1, which means "infinite timeout" on PC and "72 minutes, 35 seconds" on PS3.
// conversely, the code below (around deltaTime) expects to be able to compare against the timeout
// value given here, so we cannot just replace 0 with 1 and TT_INFINITE with 0.
// So, we replace 0 with 1, meaning "a very short time", and test for the special value TT_INFINITE
// at the moment of calling sys_semaphore_wait, where we replace it with the real "infinite timeout"
// value. It isn't safe to simply increase the declaration size of TT_INFINITE, because as you can
// see it is often assigned to uint32s.
// Also, Source timeouts are specified in milliseconds, and PS3 timeouts are in microseconds,
// so we need to multiply by one thousand.
uint32 timeOut = dwMilliseconds;
if ( timeOut == 0 )
{
timeOut = 1;
}
else if ( timeOut != TT_INFINITE )
{
timeOut *= 1000;
// note that it's impossible for dwMilliseconds * 1000
// to coincidentally equal TT_INFINITE since TT_INFINITE
// is not divisible by 1000.
COMPILE_TIME_ASSERT( TT_INFINITE % 1000 != 0 );
}
COMPILE_TIME_ASSERT( TT_INFINITE != 0 ); // The code here was written expecting (working around) that TT_INFINITE is
// MAXINT, so if you changed this number, please read the comment above and
// carefully examine the code here to make sure that timeouts still work
// correctly on PS3. Be aware that in many places in Source, a timeout of
// 0 has some special meaning other than "infinite timeout", so track those
// down too.
// Wait for all the events to be set
if ( bWaitAll )
{
while (numEvent < nCount)
{
uint64_t deltaTime = Plat_USTime();
res = sys_semaphore_wait(gWaitObjectsSemaphore, timeOut == TT_INFINITE ? 0 : timeOut );
deltaTime = Plat_USTime() - deltaTime;
if (res == ETIMEDOUT)
{
result = TW_TIMEOUT;
break;
}
else if (res == CELL_OK)
{
numEvent++;
if (deltaTime >= timeOut)
{
// note - if this is not truly a time out
// then it will be set to WAIT_OBJECT_0
// after this loop
result = TW_TIMEOUT;
break;
}
else
{
timeOut -= deltaTime;
}
}
else
{
result = TW_FAILED;
break;
}
}
if (numEvent >= nCount)
{
result = WAIT_OBJECT_0;
}
}
else // Wait for one event to be set
{
// no event fired yet, wait on semaphore
res = sys_semaphore_wait( gWaitObjectsSemaphore, timeOut == TT_INFINITE ? 0 : timeOut );
if (res == ETIMEDOUT)
{
result = TW_TIMEOUT;
}
else if (res == CELL_OK)
{
if ((event < 0) || (event >= nCount))
{
DEBUG_ERROR("Bad event\n");
}
result = WAIT_OBJECT_0 + event;
}
}
// run through events unregistering this thread, for benefit
// of those events that did not fire, or fired before semaphore
// was registered
for (int i = 0; i < nCount; i++)
{
lppHandles[i]->UnregisterWaitingThread(&gWaitObjectsSemaphore);
}
// reset semaphore
while (sys_semaphore_trywait(gWaitObjectsSemaphore) != EBUSY);
return result;
//////////////////////////////////////////////////////////////
#endif // NEW_WAIT_FOR_MULTIPLE_OBJECTS
//////////////////////////////////////////////////////////////
}
#endif