1963 lines
60 KiB
C++
1963 lines
60 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: A collection of utility classes to simplify thread handling, and
|
|
// as much as possible contain portability problems. Here
|
|
//avoiding including windows.h.
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef THREADTOOLS_H
|
|
#define THREADTOOLS_H
|
|
|
|
#include <limits.h>
|
|
|
|
#include "dbg.h"
|
|
#include "platform.h"
|
|
#include "vcrmode.h"
|
|
|
|
#ifdef PLATFORM_WINDOWS_PC
|
|
#if !defined(__MINGW32__)
|
|
#include <intrin.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef POSIX
|
|
#include <errno.h>
|
|
#include <pthread.h>
|
|
#define WAIT_OBJECT_0 0
|
|
#define WAIT_TIMEOUT 0x00000102
|
|
#define WAIT_FAILED -1
|
|
#define THREAD_PRIORITY_HIGHEST 2
|
|
#endif
|
|
|
|
#if defined(_WIN32)
|
|
#pragma once
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4251)
|
|
#endif
|
|
|
|
// #define THREAD_PROFILER 1
|
|
|
|
#ifndef _RETAIL
|
|
#define THREAD_MUTEX_TRACING_SUPPORTED
|
|
#if defined(_WIN32) && defined(_DEBUG)
|
|
#define THREAD_MUTEX_TRACING_ENABLED
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
typedef void *HANDLE;
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const unsigned TT_INFINITE = 0xffffffff;
|
|
|
|
#ifndef NO_THREAD_LOCAL
|
|
|
|
#ifndef THREAD_LOCAL
|
|
#ifdef _WIN32
|
|
#define THREAD_LOCAL __declspec(thread)
|
|
#elif POSIX
|
|
#define THREAD_LOCAL __thread
|
|
#endif
|
|
#endif
|
|
|
|
#endif // NO_THREAD_LOCAL
|
|
|
|
typedef unsigned long ThreadId_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Simple thread creation. Differs from VCR mode/CreateThread/_beginthreadex
|
|
// in that it accepts a standard C function rather than compiler specific one.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
FORWARD_DECLARE_HANDLE(ThreadHandle_t);
|
|
typedef unsigned (*ThreadFunc_t)(void *pParam);
|
|
|
|
PLATFORM_OVERLOAD ThreadHandle_t CreateSimpleThread(ThreadFunc_t, void *pParam,
|
|
ThreadId_t *pID,
|
|
unsigned stackSize = 0);
|
|
PLATFORM_INTERFACE ThreadHandle_t CreateSimpleThread(ThreadFunc_t, void *pParam,
|
|
unsigned stackSize = 0);
|
|
PLATFORM_INTERFACE bool ReleaseThreadHandle(ThreadHandle_t);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PLATFORM_INTERFACE void ThreadSleep(unsigned duration = 0);
|
|
PLATFORM_INTERFACE uint ThreadGetCurrentId();
|
|
PLATFORM_INTERFACE ThreadHandle_t ThreadGetCurrentHandle();
|
|
PLATFORM_INTERFACE int ThreadGetPriority(ThreadHandle_t hThread = NULL);
|
|
PLATFORM_INTERFACE bool ThreadSetPriority(ThreadHandle_t hThread, int priority);
|
|
inline bool ThreadSetPriority(int priority) {
|
|
return ThreadSetPriority(NULL, priority);
|
|
}
|
|
PLATFORM_INTERFACE bool ThreadInMainThread();
|
|
PLATFORM_INTERFACE void DeclareCurrentThreadIsMainThread();
|
|
|
|
// NOTE: ThreadedLoadLibraryFunc_t needs to return the sleep time in
|
|
// milliseconds or TT_INFINITE
|
|
typedef int (*ThreadedLoadLibraryFunc_t)();
|
|
PLATFORM_INTERFACE void SetThreadedLoadLibraryFunc(
|
|
ThreadedLoadLibraryFunc_t func);
|
|
PLATFORM_INTERFACE ThreadedLoadLibraryFunc_t GetThreadedLoadLibraryFunc();
|
|
|
|
#if defined(_WIN32) && !defined(_WIN64) && !defined(_X360)
|
|
extern "C" unsigned long __declspec(dllimport) __stdcall GetCurrentThreadId();
|
|
#define ThreadGetCurrentId GetCurrentThreadId
|
|
#endif
|
|
|
|
inline void ThreadPause() {
|
|
#if defined(PLATFORM_WINDOWS_PC)
|
|
// Intrinsic for __asm pause; from <intrin.h>
|
|
_mm_pause();
|
|
#elif POSIX
|
|
__asm __volatile("pause");
|
|
#elif defined(_X360)
|
|
#else
|
|
#error "implement me"
|
|
#endif
|
|
}
|
|
|
|
PLATFORM_INTERFACE bool ThreadJoin(ThreadHandle_t,
|
|
unsigned timeout = TT_INFINITE);
|
|
// If you're not calling ThreadJoin, you need to call ThreadDetach so pthreads
|
|
// on Linux knows it can
|
|
// free the memory for this thread. Otherwise you wind up leaking threads
|
|
//until you run out and CreateSimpleThread() will fail.
|
|
PLATFORM_INTERFACE void ThreadDetach(ThreadHandle_t);
|
|
|
|
PLATFORM_INTERFACE void ThreadSetDebugName(ThreadId_t id, const char *pszName);
|
|
inline void ThreadSetDebugName(const char *pszName) {
|
|
ThreadSetDebugName((ThreadId_t)-1, pszName);
|
|
}
|
|
|
|
PLATFORM_INTERFACE void ThreadSetAffinity(ThreadHandle_t hThread,
|
|
int nAffinityMask);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum ThreadWaitResult_t {
|
|
TW_FAILED = 0xffffffff, // WAIT_FAILED
|
|
TW_TIMEOUT = 0x00000102, // WAIT_TIMEOUT
|
|
};
|
|
|
|
#ifdef _WIN32
|
|
PLATFORM_INTERFACE int ThreadWaitForObjects(int nEvents, const HANDLE *pHandles,
|
|
bool bWaitAll = true,
|
|
unsigned timeout = TT_INFINITE);
|
|
inline int ThreadWaitForObject(HANDLE handle, bool bWaitAll = true,
|
|
unsigned timeout = TT_INFINITE) {
|
|
return ThreadWaitForObjects(1, &handle, bWaitAll, timeout);
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Interlock methods. These perform very fast atomic thread
|
|
// safe operations. These are especially relevant in a multi-core setting.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef _WIN32
|
|
#define NOINLINE
|
|
#elif POSIX
|
|
#define NOINLINE __attribute__((noinline))
|
|
#endif
|
|
|
|
// ThreadMemoryBarrier is a fence/barrier sufficient for most uses. It prevents
|
|
// reads from moving past reads, and writes moving past writes. It is sufficient
|
|
// for read-acquire and write-release barriers. It is not a full barrier and it
|
|
// does not prevent reads from moving past writes -- that would require a full
|
|
// __sync() on PPC and is significantly more expensive.
|
|
#if defined(_X360) || defined(_PS3)
|
|
#define ThreadMemoryBarrier() __lwsync()
|
|
|
|
#elif defined(_MSC_VER)
|
|
// Prevent compiler reordering across this barrier. This is
|
|
// sufficient for most purposes on x86/x64.
|
|
|
|
#if _MSC_VER < 1500
|
|
// !KLUDGE! For VC 2005
|
|
// http://connect.microsoft.com/VisualStudio/feedback/details/100051
|
|
#pragma intrinsic(_ReadWriteBarrier)
|
|
#endif
|
|
#define ThreadMemoryBarrier() _ReadWriteBarrier()
|
|
#elif defined(GNUC)
|
|
// Prevent compiler reordering across this barrier. This is
|
|
// sufficient for most purposes on x86/x64.
|
|
// http://preshing.com/20120625/memory-ordering-at-compile-time
|
|
#define ThreadMemoryBarrier() asm volatile("" ::: "memory")
|
|
#else
|
|
#error Every platform needs to define ThreadMemoryBarrier to at least prevent compiler reordering
|
|
#endif
|
|
|
|
#if defined(_WIN32) && !defined(_X360)
|
|
#if (_MSC_VER >= 1310)
|
|
#define USE_INTRINSIC_INTERLOCKED
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef USE_INTRINSIC_INTERLOCKED
|
|
extern "C" {
|
|
long __cdecl _InterlockedIncrement(volatile long *);
|
|
long __cdecl _InterlockedDecrement(volatile long *);
|
|
long __cdecl _InterlockedExchange(volatile long *, long);
|
|
long __cdecl _InterlockedExchangeAdd(volatile long *, long);
|
|
long __cdecl _InterlockedCompareExchange(volatile long *, long, long);
|
|
}
|
|
|
|
#pragma intrinsic(_InterlockedCompareExchange)
|
|
#pragma intrinsic(_InterlockedDecrement)
|
|
#pragma intrinsic(_InterlockedExchange)
|
|
#pragma intrinsic(_InterlockedExchangeAdd)
|
|
#pragma intrinsic(_InterlockedIncrement)
|
|
|
|
inline long ThreadInterlockedIncrement(long volatile *p) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return _InterlockedIncrement(p);
|
|
}
|
|
inline long ThreadInterlockedDecrement(long volatile *p) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return _InterlockedDecrement(p);
|
|
}
|
|
inline long ThreadInterlockedExchange(long volatile *p, long value) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return _InterlockedExchange(p, value);
|
|
}
|
|
inline long ThreadInterlockedExchangeAdd(long volatile *p, long value) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return _InterlockedExchangeAdd(p, value);
|
|
}
|
|
inline long ThreadInterlockedCompareExchange(long volatile *p, long value,
|
|
long comperand) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return _InterlockedCompareExchange(p, value, comperand);
|
|
}
|
|
inline bool ThreadInterlockedAssignIf(long volatile *p, long value,
|
|
long comperand) {
|
|
Assert((size_t)p % 4 == 0);
|
|
return (_InterlockedCompareExchange(p, value, comperand) == comperand);
|
|
}
|
|
#else
|
|
PLATFORM_INTERFACE long ThreadInterlockedIncrement(long volatile *);
|
|
PLATFORM_INTERFACE long ThreadInterlockedDecrement(long volatile *);
|
|
PLATFORM_INTERFACE long ThreadInterlockedExchange(long volatile *, long value);
|
|
PLATFORM_INTERFACE long ThreadInterlockedExchangeAdd(long volatile *,
|
|
long value);
|
|
PLATFORM_INTERFACE long ThreadInterlockedCompareExchange(long volatile *,
|
|
long value,
|
|
long comperand);
|
|
PLATFORM_INTERFACE bool ThreadInterlockedAssignIf(long volatile *, long value,
|
|
long comperand);
|
|
#endif
|
|
|
|
inline unsigned ThreadInterlockedExchangeSubtract(long volatile *p,
|
|
long value) {
|
|
return ThreadInterlockedExchangeAdd((long volatile *)p, -value);
|
|
}
|
|
|
|
#if defined(USE_INTRINSIC_INTERLOCKED) && !defined(_WIN64)
|
|
#define TIPTR()
|
|
inline void *ThreadInterlockedExchangePointer(void *volatile *p, void *value) {
|
|
return (void *)_InterlockedExchange(reinterpret_cast<long volatile *>(p),
|
|
reinterpret_cast<long>(value));
|
|
}
|
|
inline void *ThreadInterlockedCompareExchangePointer(void *volatile *p,
|
|
void *value,
|
|
void *comperand) {
|
|
return (void *)_InterlockedCompareExchange(
|
|
reinterpret_cast<long volatile *>(p), reinterpret_cast<long>(value),
|
|
reinterpret_cast<long>(comperand));
|
|
}
|
|
inline bool ThreadInterlockedAssignPointerIf(void *volatile *p, void *value,
|
|
void *comperand) {
|
|
return (_InterlockedCompareExchange(reinterpret_cast<long volatile *>(p),
|
|
reinterpret_cast<long>(value),
|
|
reinterpret_cast<long>(comperand)) ==
|
|
reinterpret_cast<long>(comperand));
|
|
}
|
|
#else
|
|
PLATFORM_INTERFACE void *ThreadInterlockedExchangePointer(void *volatile *,
|
|
void *value) NOINLINE;
|
|
PLATFORM_INTERFACE void *ThreadInterlockedCompareExchangePointer(
|
|
void *volatile *, void *value, void *comperand) NOINLINE;
|
|
PLATFORM_INTERFACE bool ThreadInterlockedAssignPointerIf(
|
|
void *volatile *, void *value, void *comperand) NOINLINE;
|
|
#endif
|
|
|
|
inline void const *ThreadInterlockedExchangePointerToConst(
|
|
void const *volatile *p, void const *value) {
|
|
return ThreadInterlockedExchangePointer(const_cast<void *volatile *>(p),
|
|
const_cast<void *>(value));
|
|
}
|
|
inline void const *ThreadInterlockedCompareExchangePointerToConst(
|
|
void const *volatile *p, void const *value, void const *comperand) {
|
|
return ThreadInterlockedCompareExchangePointer(
|
|
const_cast<void *volatile *>(p), const_cast<void *>(value),
|
|
const_cast<void *>(comperand));
|
|
}
|
|
inline bool ThreadInterlockedAssignPointerToConstIf(void const *volatile *p,
|
|
void const *value,
|
|
void const *comperand) {
|
|
return ThreadInterlockedAssignPointerIf(const_cast<void *volatile *>(p),
|
|
const_cast<void *>(value),
|
|
const_cast<void *>(comperand));
|
|
}
|
|
|
|
#if defined(PLATFORM_64BITS)
|
|
#if defined(_WIN32)
|
|
typedef __m128i int128;
|
|
inline int128 int128_zero() { return _mm_setzero_si128(); }
|
|
#else
|
|
typedef __int128_t int128;
|
|
#define int128_zero() 0
|
|
#endif
|
|
|
|
PLATFORM_INTERFACE bool ThreadInterlockedAssignIf128(
|
|
volatile int128 *pDest, const int128 &value,
|
|
const int128 &comperand) NOINLINE;
|
|
|
|
#endif
|
|
|
|
PLATFORM_INTERFACE int64
|
|
ThreadInterlockedIncrement64(int64 volatile *) NOINLINE;
|
|
PLATFORM_INTERFACE int64
|
|
ThreadInterlockedDecrement64(int64 volatile *) NOINLINE;
|
|
PLATFORM_INTERFACE int64 ThreadInterlockedCompareExchange64(
|
|
int64 volatile *, int64 value, int64 comperand) NOINLINE;
|
|
PLATFORM_INTERFACE int64 ThreadInterlockedExchange64(int64 volatile *,
|
|
int64 value) NOINLINE;
|
|
PLATFORM_INTERFACE int64 ThreadInterlockedExchangeAdd64(int64 volatile *,
|
|
int64 value) NOINLINE;
|
|
PLATFORM_INTERFACE bool ThreadInterlockedAssignIf64(volatile int64 *pDest,
|
|
int64 value,
|
|
int64 comperand) NOINLINE;
|
|
|
|
inline unsigned ThreadInterlockedExchangeSubtract(unsigned volatile *p,
|
|
unsigned value) {
|
|
return ThreadInterlockedExchangeAdd((long volatile *)p, value);
|
|
}
|
|
inline unsigned ThreadInterlockedIncrement(unsigned volatile *p) {
|
|
return ThreadInterlockedIncrement((long volatile *)p);
|
|
}
|
|
inline unsigned ThreadInterlockedDecrement(unsigned volatile *p) {
|
|
return ThreadInterlockedDecrement((long volatile *)p);
|
|
}
|
|
inline unsigned ThreadInterlockedExchange(unsigned volatile *p,
|
|
unsigned value) {
|
|
return ThreadInterlockedExchange((long volatile *)p, value);
|
|
}
|
|
inline unsigned ThreadInterlockedExchangeAdd(unsigned volatile *p,
|
|
unsigned value) {
|
|
return ThreadInterlockedExchangeAdd((long volatile *)p, value);
|
|
}
|
|
inline unsigned ThreadInterlockedCompareExchange(unsigned volatile *p,
|
|
unsigned value,
|
|
unsigned comperand) {
|
|
return ThreadInterlockedCompareExchange((long volatile *)p, value,
|
|
comperand);
|
|
}
|
|
inline bool ThreadInterlockedAssignIf(unsigned volatile *p, unsigned value,
|
|
unsigned comperand) {
|
|
return ThreadInterlockedAssignIf((long volatile *)p, value, comperand);
|
|
}
|
|
|
|
inline int ThreadInterlockedExchangeSubtract(int volatile *p, int value) {
|
|
return ThreadInterlockedExchangeAdd((long volatile *)p, value);
|
|
}
|
|
inline int ThreadInterlockedIncrement(int volatile *p) {
|
|
return ThreadInterlockedIncrement((long volatile *)p);
|
|
}
|
|
inline int ThreadInterlockedDecrement(int volatile *p) {
|
|
return ThreadInterlockedDecrement((long volatile *)p);
|
|
}
|
|
inline int ThreadInterlockedExchange(int volatile *p, int value) {
|
|
return ThreadInterlockedExchange((long volatile *)p, value);
|
|
}
|
|
inline int ThreadInterlockedExchangeAdd(int volatile *p, int value) {
|
|
return ThreadInterlockedExchangeAdd((long volatile *)p, value);
|
|
}
|
|
inline int ThreadInterlockedCompareExchange(int volatile *p, int value,
|
|
int comperand) {
|
|
return ThreadInterlockedCompareExchange((long volatile *)p, value,
|
|
comperand);
|
|
}
|
|
inline bool ThreadInterlockedAssignIf(int volatile *p, int value,
|
|
int comperand) {
|
|
return ThreadInterlockedAssignIf((long volatile *)p, value, comperand);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Access to VTune thread profiling
|
|
//-----------------------------------------------------------------------------
|
|
#if defined(_WIN32) && defined(THREAD_PROFILER)
|
|
PLATFORM_INTERFACE void ThreadNotifySyncPrepare(void *p);
|
|
PLATFORM_INTERFACE void ThreadNotifySyncCancel(void *p);
|
|
PLATFORM_INTERFACE void ThreadNotifySyncAcquired(void *p);
|
|
PLATFORM_INTERFACE void ThreadNotifySyncReleasing(void *p);
|
|
#else
|
|
#define ThreadNotifySyncPrepare(p) ((void)0)
|
|
#define ThreadNotifySyncCancel(p) ((void)0)
|
|
#define ThreadNotifySyncAcquired(p) ((void)0)
|
|
#define ThreadNotifySyncReleasing(p) ((void)0)
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Encapsulation of a thread local datum (needed because THREAD_LOCAL doesn't
|
|
// work in a DLL loaded with LoadLibrary()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef NO_THREAD_LOCAL
|
|
|
|
#if defined(_LINUX) && !defined(OSX)
|
|
// linux totally supports compiler thread locals, even across dll's.
|
|
#define PLAT_COMPILER_SUPPORTED_THREADLOCALS 1
|
|
#define CTHREADLOCALINTEGER(typ) __thread int
|
|
#define CTHREADLOCALINT __thread int
|
|
#define CTHREADLOCALPTR(typ) __thread typ *
|
|
#define CTHREADLOCAL(typ) __thread typ
|
|
#define GETLOCAL(x) (x)
|
|
#endif // _LINUX && !OSX
|
|
|
|
#if defined(WIN32) || defined(OSX)
|
|
#ifndef __AFXTLS_H__ // not compatible with some Windows headers
|
|
#define CTHREADLOCALINT CThreadLocalInt<int>
|
|
#define CTHREADLOCALINTEGER(typ) CThreadLocalInt<typ>
|
|
#define CTHREADLOCALPTR(typ) CThreadLocalPtr<typ>
|
|
#define CTHREADLOCAL(typ) CThreadLocal<typ>
|
|
#define GETLOCAL(x) (x.Get())
|
|
#endif
|
|
#endif // WIN32 || OSX
|
|
|
|
#endif // NO_THREAD_LOCALS
|
|
|
|
#ifndef __AFXTLS_H__ // not compatible with some Windows headers
|
|
#ifndef NO_THREAD_LOCAL
|
|
|
|
class PLATFORM_CLASS CThreadLocalBase {
|
|
public:
|
|
CThreadLocalBase();
|
|
~CThreadLocalBase();
|
|
|
|
void *Get() const;
|
|
void Set(void *);
|
|
|
|
private:
|
|
#ifdef _WIN32
|
|
uint32 m_index;
|
|
#elif POSIX
|
|
pthread_key_t m_index;
|
|
#endif
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
#ifndef __AFXTLS_H__
|
|
|
|
template <class T>
|
|
class CThreadLocal : public CThreadLocalBase {
|
|
public:
|
|
CThreadLocal() { COMPILE_TIME_ASSERT(sizeof(T) == sizeof(void *)); }
|
|
|
|
T Get() const { return reinterpret_cast<T>(CThreadLocalBase::Get()); }
|
|
|
|
void Set(T val) { CThreadLocalBase::Set(reinterpret_cast<void *>(val)); }
|
|
};
|
|
|
|
#endif
|
|
|
|
//---------------------------------------------------------
|
|
|
|
template <class T = intp>
|
|
class CThreadLocalInt : public CThreadLocal<T> {
|
|
public:
|
|
CThreadLocalInt() { COMPILE_TIME_ASSERT(sizeof(T) >= sizeof(int)); }
|
|
|
|
operator int() const { return (int)this->Get(); }
|
|
int operator=(int i) {
|
|
this->Set((intp)i);
|
|
return i;
|
|
}
|
|
|
|
int operator++() {
|
|
T i = this->Get();
|
|
this->Set(++i);
|
|
return (int)i;
|
|
}
|
|
int operator++(int) {
|
|
T i = this->Get();
|
|
this->Set(i + 1);
|
|
return (int)i;
|
|
}
|
|
|
|
int operator--() {
|
|
T i = this->Get();
|
|
this->Set(--i);
|
|
return (int)i;
|
|
}
|
|
int operator--(int) {
|
|
T i = this->Get();
|
|
this->Set(i - 1);
|
|
return (int)i;
|
|
}
|
|
};
|
|
|
|
//---------------------------------------------------------
|
|
|
|
template <class T>
|
|
class CThreadLocalPtr : private CThreadLocalBase {
|
|
public:
|
|
CThreadLocalPtr() {}
|
|
|
|
operator const void *() const { return (T *)Get(); }
|
|
operator void *() { return (T *)Get(); }
|
|
|
|
operator const T *() const { return (T *)Get(); }
|
|
operator const T *() { return (T *)Get(); }
|
|
operator T *() { return (T *)Get(); }
|
|
|
|
int operator=(int i) {
|
|
AssertMsg(i == 0, "Only NULL allowed on integer assign");
|
|
Set(NULL);
|
|
return 0;
|
|
}
|
|
T *operator=(T *p) {
|
|
Set(p);
|
|
return p;
|
|
}
|
|
|
|
bool operator!() const { return (!Get()); }
|
|
bool operator!=(int i) const {
|
|
AssertMsg(i == 0, "Only NULL allowed on integer compare");
|
|
return (Get() != NULL);
|
|
}
|
|
bool operator==(int i) const {
|
|
AssertMsg(i == 0, "Only NULL allowed on integer compare");
|
|
return (Get() == NULL);
|
|
}
|
|
bool operator==(const void *p) const { return (Get() == p); }
|
|
bool operator!=(const void *p) const { return (Get() != p); }
|
|
bool operator==(const T *p) const { return operator==((void *)p); }
|
|
bool operator!=(const T *p) const { return operator!=((void *)p); }
|
|
|
|
T *operator->() { return (T *)Get(); }
|
|
T &operator*() { return *((T *)Get()); }
|
|
|
|
const T *operator->() const { return (T *)Get(); }
|
|
const T &operator*() const { return *((T *)Get()); }
|
|
|
|
const T &operator[](int i) const { return *((T *)Get() + i); }
|
|
T &operator[](int i) { return *((T *)Get() + i); }
|
|
|
|
private:
|
|
// Disallowed operations
|
|
CThreadLocalPtr(T *pFrom);
|
|
CThreadLocalPtr(const CThreadLocalPtr<T> &from);
|
|
T **operator&();
|
|
T *const *operator&() const;
|
|
void operator=(const CThreadLocalPtr<T> &from);
|
|
bool operator==(const CThreadLocalPtr<T> &p) const;
|
|
bool operator!=(const CThreadLocalPtr<T> &p) const;
|
|
};
|
|
|
|
#endif // NO_THREAD_LOCAL
|
|
#endif // !__AFXTLS_H__
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// A super-fast thread-safe integer A simple class encapsulating the notion of
|
|
// an atomic integer used across threads that uses the built in and faster
|
|
// "interlocked" functionality rather than a full-blown mutex. Useful for simple
|
|
// things like reference counts, etc.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
class CInterlockedIntT {
|
|
public:
|
|
CInterlockedIntT() : m_value(0) {
|
|
COMPILE_TIME_ASSERT(sizeof(T) == sizeof(long));
|
|
}
|
|
CInterlockedIntT(T value) : m_value(value) {}
|
|
|
|
T GetRaw() const { return m_value; }
|
|
|
|
operator T() const { return m_value; }
|
|
|
|
bool operator!() const { return (m_value == 0); }
|
|
bool operator==(T rhs) const { return (m_value == rhs); }
|
|
bool operator!=(T rhs) const { return (m_value != rhs); }
|
|
|
|
T operator++() { return (T)ThreadInterlockedIncrement((long *)&m_value); }
|
|
T operator++(int) { return operator++() - 1; }
|
|
|
|
T operator--() { return (T)ThreadInterlockedDecrement((long *)&m_value); }
|
|
T operator--(int) { return operator--() + 1; }
|
|
|
|
bool AssignIf(T conditionValue, T newValue) {
|
|
return ThreadInterlockedAssignIf((long *)&m_value, (long)newValue,
|
|
(long)conditionValue);
|
|
}
|
|
|
|
T operator=(T newValue) {
|
|
ThreadInterlockedExchange((long *)&m_value, newValue);
|
|
return m_value;
|
|
}
|
|
|
|
void operator+=(T add) {
|
|
ThreadInterlockedExchangeAdd((long *)&m_value, (long)add);
|
|
}
|
|
void operator-=(T subtract) { operator+=(-subtract); }
|
|
void operator*=(T multiplier) {
|
|
T original, result;
|
|
do {
|
|
original = m_value;
|
|
result = original * multiplier;
|
|
} while (!AssignIf(original, result));
|
|
}
|
|
void operator/=(T divisor) {
|
|
T original, result;
|
|
do {
|
|
original = m_value;
|
|
result = original / divisor;
|
|
} while (!AssignIf(original, result));
|
|
}
|
|
|
|
T operator+(T rhs) const { return m_value + rhs; }
|
|
T operator-(T rhs) const { return m_value - rhs; }
|
|
|
|
private:
|
|
volatile T m_value;
|
|
};
|
|
|
|
typedef CInterlockedIntT<int> CInterlockedInt;
|
|
typedef CInterlockedIntT<unsigned> CInterlockedUInt;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
class CInterlockedPtr {
|
|
public:
|
|
CInterlockedPtr() : m_value(0) {}
|
|
CInterlockedPtr(T *value) : m_value(value) {}
|
|
|
|
operator T *() const { return m_value; }
|
|
|
|
bool operator!() const { return (m_value == 0); }
|
|
bool operator==(T *rhs) const { return (m_value == rhs); }
|
|
bool operator!=(T *rhs) const { return (m_value != rhs); }
|
|
|
|
#if defined(PLATFORM_64BITS)
|
|
T *operator++() {
|
|
return ((T *)ThreadInterlockedExchangeAdd64((int64 *)&m_value,
|
|
sizeof(T))) +
|
|
1;
|
|
}
|
|
T *operator++(int) {
|
|
return (T *)ThreadInterlockedExchangeAdd64((int64 *)&m_value,
|
|
sizeof(T));
|
|
}
|
|
|
|
T *operator--() {
|
|
return ((T *)ThreadInterlockedExchangeAdd64((int64 *)&m_value,
|
|
-sizeof(T))) -
|
|
1;
|
|
}
|
|
T *operator--(int) {
|
|
return (T *)ThreadInterlockedExchangeAdd64((int64 *)&m_value,
|
|
-sizeof(T));
|
|
}
|
|
|
|
bool AssignIf(T *conditionValue, T *newValue) {
|
|
return ThreadInterlockedAssignPointerToConstIf(
|
|
(void const **)&m_value, (void const *)newValue,
|
|
(void const *)conditionValue);
|
|
}
|
|
|
|
T *operator=(T *newValue) {
|
|
ThreadInterlockedExchangePointerToConst((void const **)&m_value,
|
|
(void const *)newValue);
|
|
return newValue;
|
|
}
|
|
|
|
void operator+=(int add) {
|
|
ThreadInterlockedExchangeAdd64((int64 *)&m_value, add * sizeof(T));
|
|
}
|
|
#else
|
|
T *operator++() {
|
|
return ((T *)ThreadInterlockedExchangeAdd((long *)&m_value,
|
|
sizeof(T))) +
|
|
1;
|
|
}
|
|
T *operator++(int) {
|
|
return (T *)ThreadInterlockedExchangeAdd((long *)&m_value, sizeof(T));
|
|
}
|
|
|
|
T *operator--() {
|
|
return ((T *)ThreadInterlockedExchangeAdd((long *)&m_value,
|
|
-sizeof(T))) -
|
|
1;
|
|
}
|
|
T *operator--(int) {
|
|
return (T *)ThreadInterlockedExchangeAdd((long *)&m_value, -sizeof(T));
|
|
}
|
|
|
|
bool AssignIf(T *conditionValue, T *newValue) {
|
|
return ThreadInterlockedAssignPointerToConstIf(
|
|
(void const **)&m_value, (void const *)newValue,
|
|
(void const *)conditionValue);
|
|
}
|
|
|
|
T *operator=(T *newValue) {
|
|
ThreadInterlockedExchangePointerToConst((void const **)&m_value,
|
|
(void const *)newValue);
|
|
return newValue;
|
|
}
|
|
|
|
void operator+=(int add) {
|
|
ThreadInterlockedExchangeAdd((long *)&m_value, add * sizeof(T));
|
|
}
|
|
#endif
|
|
|
|
void operator-=(int subtract) { operator+=(-subtract); }
|
|
|
|
T *operator+(int rhs) const { return m_value + rhs; }
|
|
T *operator-(int rhs) const { return m_value - rhs; }
|
|
T *operator+(unsigned rhs) const { return m_value + rhs; }
|
|
T *operator-(unsigned rhs) const { return m_value - rhs; }
|
|
size_t operator-(T *p) const { return m_value - p; }
|
|
size_t operator-(const CInterlockedPtr<T> &p) const {
|
|
return m_value - p.m_value;
|
|
}
|
|
|
|
private:
|
|
T *volatile m_value;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Platform independent verification that multiple threads aren't getting into
|
|
// the same code at the same time. Note: This is intended for use to identify
|
|
// problems, it doesn't provide any sort of thread safety.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class ReentrancyVerifier {
|
|
public:
|
|
inline ReentrancyVerifier(CInterlockedInt *counter, int sleepTimeMS)
|
|
: mCounter(counter) {
|
|
Assert(mCounter != NULL);
|
|
|
|
if (++(*mCounter) != 1) {
|
|
DebuggerBreakIfDebugging_StagingOnly();
|
|
}
|
|
|
|
if (sleepTimeMS > 0) {
|
|
ThreadSleep(sleepTimeMS);
|
|
}
|
|
}
|
|
|
|
inline ~ReentrancyVerifier() {
|
|
if (--(*mCounter) != 0) {
|
|
DebuggerBreakIfDebugging_StagingOnly();
|
|
}
|
|
}
|
|
|
|
private:
|
|
CInterlockedInt *mCounter;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Platform independent for critical sections management
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThreadMutex {
|
|
public:
|
|
CThreadMutex();
|
|
~CThreadMutex();
|
|
|
|
//------------------------------------------------------
|
|
// Mutex acquisition/release. Const intentionally defeated.
|
|
//------------------------------------------------------
|
|
void Lock();
|
|
void Lock() const { (const_cast<CThreadMutex *>(this))->Lock(); }
|
|
void Unlock();
|
|
void Unlock() const { (const_cast<CThreadMutex *>(this))->Unlock(); }
|
|
|
|
bool TryLock();
|
|
bool TryLock() const {
|
|
return (const_cast<CThreadMutex *>(this))->TryLock();
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
// Use this to make deadlocks easier to track by asserting
|
|
// when it is expected that the current thread owns the mutex
|
|
//------------------------------------------------------
|
|
bool AssertOwnedByCurrentThread();
|
|
|
|
//------------------------------------------------------
|
|
// Enable tracing to track deadlock problems
|
|
//------------------------------------------------------
|
|
void SetTrace(bool);
|
|
|
|
private:
|
|
// Disallow copying
|
|
CThreadMutex(const CThreadMutex &);
|
|
CThreadMutex &operator=(const CThreadMutex &);
|
|
|
|
#if defined(_WIN32)
|
|
// Efficient solution to breaking the windows.h dependency, invariant is
|
|
// tested.
|
|
#ifdef _WIN64
|
|
#define TT_SIZEOF_CRITICALSECTION 40
|
|
#else
|
|
#ifndef _X360
|
|
#define TT_SIZEOF_CRITICALSECTION 24
|
|
#else
|
|
#define TT_SIZEOF_CRITICALSECTION 28
|
|
#endif // !_XBOX
|
|
#endif // _WIN64
|
|
byte m_CriticalSection[TT_SIZEOF_CRITICALSECTION];
|
|
#elif defined(POSIX)
|
|
pthread_mutex_t m_Mutex;
|
|
pthread_mutexattr_t m_Attr;
|
|
#else
|
|
#error
|
|
#endif
|
|
|
|
#ifdef THREAD_MUTEX_TRACING_SUPPORTED
|
|
// Debugging (always here to allow mixed debug/release builds w/o changing
|
|
// size)
|
|
uint m_currentOwnerID;
|
|
uint16 m_lockCount;
|
|
bool m_bTrace;
|
|
#endif
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// An alternative mutex that is useful for cases when thread contention is
|
|
// rare, but a mutex is required. Instances should be declared volatile.
|
|
// Sleep of 0 may not be sufficient to keep high priority threads from starving
|
|
// lesser threads. This class is not a suitable replacement for a critical
|
|
// section if the resource contention is high.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if !defined(THREAD_PROFILER)
|
|
|
|
class CThreadFastMutex {
|
|
public:
|
|
CThreadFastMutex() : m_ownerID(0), m_depth(0) {}
|
|
|
|
private:
|
|
FORCEINLINE bool TryLockInline(const uint32 threadId) volatile {
|
|
if (threadId != m_ownerID &&
|
|
!ThreadInterlockedAssignIf((volatile long *)&m_ownerID,
|
|
(long)threadId, 0))
|
|
return false;
|
|
|
|
ThreadMemoryBarrier();
|
|
++m_depth;
|
|
return true;
|
|
}
|
|
|
|
bool TryLock(const uint32 threadId) volatile {
|
|
return TryLockInline(threadId);
|
|
}
|
|
|
|
PLATFORM_CLASS void Lock(const uint32 threadId,
|
|
unsigned nSpinSleepTime) volatile;
|
|
|
|
public:
|
|
bool TryLock() volatile {
|
|
#ifdef _DEBUG
|
|
if (m_depth == INT_MAX) DebuggerBreak();
|
|
|
|
if (m_depth < 0) DebuggerBreak();
|
|
#endif
|
|
return TryLockInline(ThreadGetCurrentId());
|
|
}
|
|
|
|
#ifndef _DEBUG
|
|
FORCEINLINE
|
|
#endif
|
|
void Lock(unsigned int nSpinSleepTime = 0) volatile {
|
|
const uint32 threadId = ThreadGetCurrentId();
|
|
|
|
if (!TryLockInline(threadId)) {
|
|
ThreadPause();
|
|
Lock(threadId, nSpinSleepTime);
|
|
}
|
|
#ifdef _DEBUG
|
|
if (m_ownerID != ThreadGetCurrentId()) DebuggerBreak();
|
|
|
|
if (m_depth == INT_MAX) DebuggerBreak();
|
|
|
|
if (m_depth < 0) DebuggerBreak();
|
|
#endif
|
|
}
|
|
|
|
#ifndef _DEBUG
|
|
FORCEINLINE
|
|
#endif
|
|
void Unlock() volatile {
|
|
#ifdef _DEBUG
|
|
if (m_ownerID != ThreadGetCurrentId()) DebuggerBreak();
|
|
|
|
if (m_depth <= 0) DebuggerBreak();
|
|
#endif
|
|
|
|
--m_depth;
|
|
if (!m_depth) {
|
|
ThreadMemoryBarrier();
|
|
ThreadInterlockedExchange(&m_ownerID, 0);
|
|
}
|
|
}
|
|
|
|
#ifdef WIN32
|
|
bool TryLock() const volatile {
|
|
return (const_cast<CThreadFastMutex *>(this))->TryLock();
|
|
}
|
|
void Lock(unsigned nSpinSleepTime = 1) const volatile {
|
|
(const_cast<CThreadFastMutex *>(this))->Lock(nSpinSleepTime);
|
|
}
|
|
void Unlock() const volatile {
|
|
(const_cast<CThreadFastMutex *>(this))->Unlock();
|
|
}
|
|
#endif
|
|
// To match regular CThreadMutex:
|
|
bool AssertOwnedByCurrentThread() { return true; }
|
|
void SetTrace(bool) {}
|
|
|
|
uint32 GetOwnerId() const { return m_ownerID; }
|
|
int GetDepth() const { return m_depth; }
|
|
|
|
private:
|
|
volatile uint32 m_ownerID;
|
|
int m_depth;
|
|
};
|
|
|
|
class ALIGN128 CAlignedThreadFastMutex : public CThreadFastMutex {
|
|
public:
|
|
CAlignedThreadFastMutex() {
|
|
Assert((size_t)this % 128 == 0 && sizeof(*this) == 128);
|
|
}
|
|
|
|
private:
|
|
uint8 pad[128 - sizeof(CThreadFastMutex)];
|
|
} ALIGN128_POST;
|
|
|
|
#else
|
|
typedef CThreadMutex CThreadFastMutex;
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CThreadNullMutex {
|
|
public:
|
|
static void Lock() {}
|
|
static void Unlock() {}
|
|
|
|
static bool TryLock() { return true; }
|
|
static bool AssertOwnedByCurrentThread() { return true; }
|
|
static void SetTrace(bool b) {}
|
|
|
|
static uint32 GetOwnerId() { return 0; }
|
|
static int GetDepth() { return 0; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// A mutex decorator class used to control the use of a mutex, to make it
|
|
// less expensive when not multithreading
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class BaseClass, bool *pCondition>
|
|
class CThreadConditionalMutex : public BaseClass {
|
|
public:
|
|
void Lock() {
|
|
if (*pCondition) BaseClass::Lock();
|
|
}
|
|
void Lock() const {
|
|
if (*pCondition) BaseClass::Lock();
|
|
}
|
|
void Unlock() {
|
|
if (*pCondition) BaseClass::Unlock();
|
|
}
|
|
void Unlock() const {
|
|
if (*pCondition) BaseClass::Unlock();
|
|
}
|
|
|
|
bool TryLock() {
|
|
if (*pCondition)
|
|
return BaseClass::TryLock();
|
|
else
|
|
return true;
|
|
}
|
|
bool TryLock() const {
|
|
if (*pCondition)
|
|
return BaseClass::TryLock();
|
|
else
|
|
return true;
|
|
}
|
|
bool AssertOwnedByCurrentThread() {
|
|
if (*pCondition)
|
|
return BaseClass::AssertOwnedByCurrentThread();
|
|
else
|
|
return true;
|
|
}
|
|
void SetTrace(bool b) {
|
|
if (*pCondition) BaseClass::SetTrace(b);
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Mutex decorator that blows up if another thread enters
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class BaseClass>
|
|
class CThreadTerminalMutex : public BaseClass {
|
|
public:
|
|
bool TryLock() {
|
|
if (!BaseClass::TryLock()) {
|
|
DebuggerBreak();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
bool TryLock() const {
|
|
if (!BaseClass::TryLock()) {
|
|
DebuggerBreak();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
void Lock() {
|
|
if (!TryLock()) BaseClass::Lock();
|
|
}
|
|
void Lock() const {
|
|
if (!TryLock()) BaseClass::Lock();
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Class to Lock a critical section, and unlock it automatically
|
|
// when the lock goes out of scope
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class MUTEX_TYPE = CThreadMutex>
|
|
class CAutoLockT {
|
|
public:
|
|
FORCEINLINE CAutoLockT(MUTEX_TYPE &lock) : m_lock(lock) { m_lock.Lock(); }
|
|
|
|
FORCEINLINE CAutoLockT(const MUTEX_TYPE &lock)
|
|
: m_lock(const_cast<MUTEX_TYPE &>(lock)) {
|
|
m_lock.Lock();
|
|
}
|
|
|
|
FORCEINLINE ~CAutoLockT() { m_lock.Unlock(); }
|
|
|
|
private:
|
|
MUTEX_TYPE &m_lock;
|
|
|
|
// Disallow copying
|
|
CAutoLockT<MUTEX_TYPE>(const CAutoLockT<MUTEX_TYPE> &);
|
|
CAutoLockT<MUTEX_TYPE> &operator=(const CAutoLockT<MUTEX_TYPE> &);
|
|
};
|
|
|
|
typedef CAutoLockT<CThreadMutex> CAutoLock;
|
|
|
|
//---------------------------------------------------------
|
|
|
|
template <int size>
|
|
struct CAutoLockTypeDeducer {};
|
|
template <>
|
|
struct CAutoLockTypeDeducer<sizeof(CThreadMutex)> {
|
|
typedef CThreadMutex Type_t;
|
|
};
|
|
template <>
|
|
struct CAutoLockTypeDeducer<sizeof(CThreadNullMutex)> {
|
|
typedef CThreadNullMutex Type_t;
|
|
};
|
|
#if !defined(THREAD_PROFILER)
|
|
template <>
|
|
struct CAutoLockTypeDeducer<sizeof(CThreadFastMutex)> {
|
|
typedef CThreadFastMutex Type_t;
|
|
};
|
|
template <>
|
|
struct CAutoLockTypeDeducer<sizeof(CAlignedThreadFastMutex)> {
|
|
typedef CAlignedThreadFastMutex Type_t;
|
|
};
|
|
#endif
|
|
|
|
#define AUTO_LOCK_(type, mutex) \
|
|
CAutoLockT<type> UNIQUE_ID(static_cast<const type &>(mutex))
|
|
|
|
#if defined(GNUC)
|
|
|
|
template <typename T>
|
|
T strip_cv_quals_for_mutex(T &);
|
|
template <typename T>
|
|
T strip_cv_quals_for_mutex(const T &);
|
|
template <typename T>
|
|
T strip_cv_quals_for_mutex(volatile T &);
|
|
template <typename T>
|
|
T strip_cv_quals_for_mutex(const volatile T &);
|
|
|
|
#define AUTO_LOCK(mutex) \
|
|
AUTO_LOCK_(typeof(::strip_cv_quals_for_mutex(mutex)), mutex)
|
|
|
|
#else // GNUC
|
|
|
|
#define AUTO_LOCK(mutex) \
|
|
AUTO_LOCK_(CAutoLockTypeDeducer<sizeof(mutex)>::Type_t, mutex)
|
|
|
|
#endif
|
|
|
|
#define AUTO_LOCK_FM(mutex) AUTO_LOCK_(CThreadFastMutex, mutex)
|
|
|
|
#define LOCAL_THREAD_LOCK_(tag) \
|
|
; \
|
|
static CThreadFastMutex autoMutex_##tag; \
|
|
AUTO_LOCK(autoMutex_##tag)
|
|
|
|
#define LOCAL_THREAD_LOCK() LOCAL_THREAD_LOCK_(_)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Base class for event, semaphore and mutex objects.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThreadSyncObject {
|
|
public:
|
|
~CThreadSyncObject();
|
|
|
|
//-----------------------------------------------------
|
|
// Query if object is useful
|
|
//-----------------------------------------------------
|
|
bool operator!() const;
|
|
|
|
//-----------------------------------------------------
|
|
// Access handle
|
|
//-----------------------------------------------------
|
|
#ifdef _WIN32
|
|
operator HANDLE() { return GetHandle(); }
|
|
const HANDLE GetHandle() const { return m_hSyncObject; }
|
|
#endif
|
|
//-----------------------------------------------------
|
|
// Wait for a signal from the object
|
|
//-----------------------------------------------------
|
|
bool Wait(uint32 dwTimeout = TT_INFINITE);
|
|
|
|
protected:
|
|
CThreadSyncObject();
|
|
void AssertUseable();
|
|
|
|
#ifdef _WIN32
|
|
HANDLE m_hSyncObject;
|
|
bool m_bCreatedHandle;
|
|
#elif defined(POSIX)
|
|
pthread_mutex_t m_Mutex;
|
|
pthread_cond_t m_Condition;
|
|
bool m_bInitalized;
|
|
int m_cSet;
|
|
bool m_bManualReset;
|
|
bool m_bWakeForEvent;
|
|
#else
|
|
#error "Implement me"
|
|
#endif
|
|
|
|
private:
|
|
CThreadSyncObject(const CThreadSyncObject &);
|
|
CThreadSyncObject &operator=(const CThreadSyncObject &);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Wrapper for unnamed event objects
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if defined(_WIN32)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadSemaphore
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThreadSemaphore : public CThreadSyncObject {
|
|
public:
|
|
CThreadSemaphore(long initialValue, long maxValue);
|
|
|
|
//-----------------------------------------------------
|
|
// Increases the count of the semaphore object by a specified
|
|
// amount. Wait() decreases the count by one on return.
|
|
//-----------------------------------------------------
|
|
bool Release(long releaseCount = 1, long *pPreviousCount = NULL);
|
|
|
|
private:
|
|
CThreadSemaphore(const CThreadSemaphore &);
|
|
CThreadSemaphore &operator=(const CThreadSemaphore &);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// A mutex suitable for out-of-process, multi-processor usage
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThreadFullMutex : public CThreadSyncObject {
|
|
public:
|
|
CThreadFullMutex(bool bEstablishInitialOwnership = false,
|
|
const char *pszName = NULL);
|
|
|
|
//-----------------------------------------------------
|
|
// Release ownership of the mutex
|
|
//-----------------------------------------------------
|
|
bool Release();
|
|
|
|
// To match regular CThreadMutex:
|
|
void Lock() { Wait(); }
|
|
void Lock(unsigned timeout) { Wait(timeout); }
|
|
void Unlock() { Release(); }
|
|
bool AssertOwnedByCurrentThread() { return true; }
|
|
void SetTrace(bool) {}
|
|
|
|
private:
|
|
CThreadFullMutex(const CThreadFullMutex &);
|
|
CThreadFullMutex &operator=(const CThreadFullMutex &);
|
|
};
|
|
#endif
|
|
|
|
class PLATFORM_CLASS CThreadEvent : public CThreadSyncObject {
|
|
public:
|
|
CThreadEvent(bool fManualReset = false);
|
|
#ifdef WIN32
|
|
CThreadEvent(HANDLE hHandle);
|
|
#endif
|
|
//-----------------------------------------------------
|
|
// Set the state to signaled
|
|
//-----------------------------------------------------
|
|
bool Set();
|
|
|
|
//-----------------------------------------------------
|
|
// Set the state to nonsignaled
|
|
//-----------------------------------------------------
|
|
bool Reset();
|
|
|
|
//-----------------------------------------------------
|
|
// Check if the event is signaled
|
|
//-----------------------------------------------------
|
|
bool Check();
|
|
|
|
bool Wait(uint32 dwTimeout = TT_INFINITE);
|
|
|
|
private:
|
|
CThreadEvent(const CThreadEvent &);
|
|
CThreadEvent &operator=(const CThreadEvent &);
|
|
};
|
|
|
|
// Hard-wired manual event for use in array declarations
|
|
class CThreadManualEvent : public CThreadEvent {
|
|
public:
|
|
CThreadManualEvent() : CThreadEvent(true) {}
|
|
};
|
|
|
|
inline int ThreadWaitForEvents(int nEvents, CThreadEvent *const *pEvents,
|
|
bool bWaitAll = true,
|
|
unsigned timeout = TT_INFINITE) {
|
|
#ifdef POSIX
|
|
Assert(nEvents == 1);
|
|
if (pEvents[0]->Wait(timeout))
|
|
return WAIT_OBJECT_0;
|
|
else
|
|
return WAIT_TIMEOUT;
|
|
#else
|
|
HANDLE handles[64];
|
|
for (unsigned int i = 0; i < min(nEvents, ARRAYSIZE(handles)); i++)
|
|
handles[i] = pEvents[i]->GetHandle();
|
|
return ThreadWaitForObjects(nEvents, handles, bWaitAll, timeout);
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadRWLock
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThreadRWLock {
|
|
public:
|
|
CThreadRWLock();
|
|
|
|
void LockForRead();
|
|
void UnlockRead();
|
|
void LockForWrite();
|
|
void UnlockWrite();
|
|
|
|
void LockForRead() const {
|
|
const_cast<CThreadRWLock *>(this)->LockForRead();
|
|
}
|
|
void UnlockRead() const { const_cast<CThreadRWLock *>(this)->UnlockRead(); }
|
|
void LockForWrite() const {
|
|
const_cast<CThreadRWLock *>(this)->LockForWrite();
|
|
}
|
|
void UnlockWrite() const {
|
|
const_cast<CThreadRWLock *>(this)->UnlockWrite();
|
|
}
|
|
|
|
private:
|
|
void WaitForRead();
|
|
|
|
#ifdef WIN32
|
|
CThreadFastMutex m_mutex;
|
|
#else
|
|
CThreadMutex m_mutex;
|
|
#endif
|
|
CThreadEvent m_CanWrite;
|
|
CThreadEvent m_CanRead;
|
|
|
|
int m_nWriters;
|
|
int m_nActiveReaders;
|
|
int m_nPendingReaders;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadSpinRWLock
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class ALIGN8 PLATFORM_CLASS CThreadSpinRWLock {
|
|
public:
|
|
CThreadSpinRWLock() {
|
|
COMPILE_TIME_ASSERT(sizeof(LockInfo_t) == sizeof(int64));
|
|
Assert((intp)this % 8 == 0);
|
|
memset(this, 0, sizeof(*this));
|
|
}
|
|
|
|
bool TryLockForWrite();
|
|
bool TryLockForRead();
|
|
|
|
void LockForRead();
|
|
void UnlockRead();
|
|
void LockForWrite();
|
|
void UnlockWrite();
|
|
|
|
bool TryLockForWrite() const {
|
|
return const_cast<CThreadSpinRWLock *>(this)->TryLockForWrite();
|
|
}
|
|
bool TryLockForRead() const {
|
|
return const_cast<CThreadSpinRWLock *>(this)->TryLockForRead();
|
|
}
|
|
void LockForRead() const {
|
|
const_cast<CThreadSpinRWLock *>(this)->LockForRead();
|
|
}
|
|
void UnlockRead() const {
|
|
const_cast<CThreadSpinRWLock *>(this)->UnlockRead();
|
|
}
|
|
void LockForWrite() const {
|
|
const_cast<CThreadSpinRWLock *>(this)->LockForWrite();
|
|
}
|
|
void UnlockWrite() const {
|
|
const_cast<CThreadSpinRWLock *>(this)->UnlockWrite();
|
|
}
|
|
|
|
private:
|
|
struct LockInfo_t {
|
|
uint32 m_writerId;
|
|
int m_nReaders;
|
|
};
|
|
|
|
bool AssignIf(const LockInfo_t &newValue, const LockInfo_t &comperand);
|
|
bool TryLockForWrite(const uint32 threadId);
|
|
void SpinLockForWrite(const uint32 threadId);
|
|
|
|
volatile LockInfo_t m_lockInfo;
|
|
CInterlockedInt m_nWriters;
|
|
} ALIGN8_POST;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// A thread wrapper similar to a Java thread.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class PLATFORM_CLASS CThread {
|
|
public:
|
|
CThread();
|
|
virtual ~CThread();
|
|
|
|
//-----------------------------------------------------
|
|
|
|
const char *GetName();
|
|
void SetName(const char *);
|
|
|
|
size_t CalcStackDepth(void *pStackVariable) {
|
|
return ((byte *)m_pStackBase - (byte *)pStackVariable);
|
|
}
|
|
|
|
//-----------------------------------------------------
|
|
// Functions for the other threads
|
|
//-----------------------------------------------------
|
|
|
|
// Start thread running - error if already running
|
|
virtual bool Start(unsigned nBytesStack = 0);
|
|
|
|
// Returns true if thread has been created and hasn't yet exited
|
|
bool IsAlive();
|
|
|
|
// This method causes the current thread to wait until this thread
|
|
// is no longer alive.
|
|
bool Join(unsigned timeout = TT_INFINITE);
|
|
|
|
#ifdef _WIN32
|
|
// Access the thread handle directly
|
|
HANDLE GetThreadHandle();
|
|
uint GetThreadId();
|
|
#elif defined(LINUX)
|
|
uint GetThreadId();
|
|
#endif
|
|
|
|
//-----------------------------------------------------
|
|
|
|
int GetResult();
|
|
|
|
//-----------------------------------------------------
|
|
// Functions for both this, and maybe, and other threads
|
|
//-----------------------------------------------------
|
|
|
|
// Forcibly, abnormally, but relatively cleanly stop the thread
|
|
void Stop(int exitCode = 0);
|
|
|
|
// Get the priority
|
|
int GetPriority() const;
|
|
|
|
// Set the priority
|
|
bool SetPriority(int);
|
|
|
|
// Request a thread to suspend, this must ONLY be called from the thread
|
|
// itself, not the main thread This suspend variant causes the thread in
|
|
// question to suspend at a known point in its execution which means you
|
|
// don't risk the global deadlocks/hangs potentially caused by the raw
|
|
// Suspend() call
|
|
void SuspendCooperative();
|
|
|
|
// Resume a previously suspended thread from the Cooperative call
|
|
void ResumeCooperative();
|
|
|
|
// wait for a thread to execute its SuspendCooperative call
|
|
void BWaitForThreadSuspendCooperative();
|
|
|
|
#ifndef LINUX
|
|
// forcefully Suspend a thread
|
|
unsigned int Suspend();
|
|
|
|
// forcefully Resume a previously suspended thread
|
|
unsigned int Resume();
|
|
#endif
|
|
|
|
// Force hard-termination of thread. Used for critical failures.
|
|
bool Terminate(int exitCode = 0);
|
|
|
|
//-----------------------------------------------------
|
|
// Global methods
|
|
//-----------------------------------------------------
|
|
|
|
// Get the Thread object that represents the current thread, if any.
|
|
// Can return NULL if the current thread was not created using
|
|
// CThread
|
|
static CThread *GetCurrentCThread();
|
|
|
|
// Offer a context switch. Under Win32, equivalent to Sleep(0)
|
|
#ifdef Yield
|
|
#undef Yield
|
|
#endif
|
|
static void Yield();
|
|
|
|
// This method causes the current thread to yield and not to be
|
|
// scheduled for further execution until a certain amount of real
|
|
// time has elapsed, more or less.
|
|
static void Sleep(unsigned duration);
|
|
|
|
protected:
|
|
// Optional pre-run call, with ability to fail-create. Note Init()
|
|
// is forced synchronous with Start()
|
|
virtual bool Init();
|
|
|
|
// Thread will run this function on startup, must be supplied by
|
|
// derived class, performs the intended action of the thread.
|
|
virtual int Run() = 0;
|
|
|
|
// Called when the thread is about to exit, by the about-to-exit thread.
|
|
virtual void OnExit();
|
|
|
|
// Called after OnExit when a thread finishes or is killed. Not virtual
|
|
// because no inherited classes override it and we don't want to change the
|
|
// vtable from the published SDK version.
|
|
void Cleanup();
|
|
|
|
bool WaitForCreateComplete(CThreadEvent *pEvent);
|
|
|
|
// "Virtual static" facility
|
|
typedef unsigned(__stdcall *ThreadProc_t)(void *);
|
|
virtual ThreadProc_t GetThreadProc();
|
|
virtual bool IsThreadRunning();
|
|
|
|
CThreadMutex m_Lock;
|
|
|
|
#ifdef WIN32
|
|
ThreadHandle_t GetThreadID() const { return (ThreadHandle_t)m_hThread; }
|
|
#else
|
|
ThreadId_t GetThreadID() const { return (ThreadId_t)m_threadId; }
|
|
#endif
|
|
|
|
private:
|
|
enum Flags { SUPPORT_STOP_PROTOCOL = 1 << 0 };
|
|
|
|
// Thread initially runs this. param is actually 'this'. function
|
|
// just gets this and calls ThreadProc
|
|
struct ThreadInit_t {
|
|
CThread *pThread;
|
|
CThreadEvent *pInitCompleteEvent;
|
|
bool *pfInitSuccess;
|
|
};
|
|
|
|
static unsigned __stdcall ThreadProc(void *pv);
|
|
|
|
// make copy constructor and assignment operator inaccessible
|
|
CThread(const CThread &);
|
|
CThread &operator=(const CThread &);
|
|
|
|
#ifdef _WIN32
|
|
HANDLE m_hThread;
|
|
ThreadId_t m_threadId;
|
|
#elif defined(POSIX)
|
|
pthread_t m_threadId;
|
|
#endif
|
|
CInterlockedInt m_nSuspendCount;
|
|
CThreadEvent m_SuspendEvent;
|
|
CThreadEvent m_SuspendEventSignal;
|
|
int m_result;
|
|
char m_szName[32];
|
|
void *m_pStackBase;
|
|
unsigned m_flags;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// A helper class to let you sleep a thread for memory validation, you need to
|
|
// handle
|
|
// m_bSleepForValidate in your ::Run() call and set m_bSleepingForValidate
|
|
//when sleeping
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class PLATFORM_CLASS CValidatableThread : public CThread {
|
|
public:
|
|
CValidatableThread() {
|
|
m_bSleepForValidate = false;
|
|
m_bSleepingForValidate = false;
|
|
}
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
virtual void SleepForValidate() { m_bSleepForValidate = true; }
|
|
bool BSleepingForValidate() { return m_bSleepingForValidate; }
|
|
virtual void WakeFromValidate() { m_bSleepForValidate = false; }
|
|
#endif
|
|
protected:
|
|
bool m_bSleepForValidate;
|
|
bool m_bSleepingForValidate;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Simple thread class encompasses the notion of a worker thread, handing
|
|
// synchronized communication.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// These are internal reserved error results from a call attempt
|
|
enum WTCallResult_t {
|
|
WTCR_FAIL = -1,
|
|
WTCR_TIMEOUT = -2,
|
|
WTCR_THREAD_GONE = -3,
|
|
};
|
|
|
|
class CFunctor;
|
|
class PLATFORM_CLASS CWorkerThread : public CThread {
|
|
public:
|
|
CWorkerThread();
|
|
|
|
//-----------------------------------------------------
|
|
//
|
|
// Inter-thread communication
|
|
//
|
|
// Calls in either direction take place on the same "channel."
|
|
// Seperate functions are specified to make identities obvious
|
|
//
|
|
//-----------------------------------------------------
|
|
|
|
// Master: Signal the thread, and block for a response
|
|
int CallWorker(unsigned, unsigned timeout = TT_INFINITE,
|
|
bool fBoostWorkerPriorityToMaster = true,
|
|
CFunctor *pParamFunctor = NULL);
|
|
|
|
// Worker: Signal the thread, and block for a response
|
|
int CallMaster(unsigned, unsigned timeout = TT_INFINITE);
|
|
|
|
// Wait for the next request
|
|
bool WaitForCall(unsigned dwTimeout, unsigned *pResult = NULL);
|
|
bool WaitForCall(unsigned *pResult = NULL);
|
|
|
|
// Is there a request?
|
|
bool PeekCall(unsigned *pParam = NULL, CFunctor **ppParamFunctor = NULL);
|
|
|
|
// Reply to the request
|
|
void Reply(unsigned);
|
|
|
|
// Wait for a reply in the case when CallWorker() with timeout !=
|
|
// TT_INFINITE
|
|
int WaitForReply(unsigned timeout = TT_INFINITE);
|
|
|
|
// If you want to do WaitForMultipleObjects you'll need to include
|
|
// this handle in your wait list or you won't be responsive
|
|
CThreadEvent &GetCallHandle();
|
|
// Find out what the request was
|
|
unsigned GetCallParam(CFunctor **ppParamFunctor = NULL) const;
|
|
|
|
// Boost the worker thread to the master thread, if worker thread is lesser,
|
|
// return old priority
|
|
int BoostPriority();
|
|
|
|
protected:
|
|
#ifndef _WIN32
|
|
#define __stdcall
|
|
#endif
|
|
typedef uint32(__stdcall *WaitFunc_t)(int nEvents,
|
|
CThreadEvent *const *pEvents,
|
|
int bWaitAll, uint32 timeout);
|
|
|
|
int Call(unsigned, unsigned timeout, bool fBoost, WaitFunc_t = NULL,
|
|
CFunctor *pParamFunctor = NULL);
|
|
int WaitForReply(unsigned timeout, WaitFunc_t);
|
|
|
|
private:
|
|
CWorkerThread(const CWorkerThread &);
|
|
CWorkerThread &operator=(const CWorkerThread &);
|
|
|
|
CThreadEvent m_EventSend;
|
|
CThreadEvent m_EventComplete;
|
|
|
|
unsigned m_Param;
|
|
CFunctor *m_pParamFunctor;
|
|
int m_ReturnVal;
|
|
};
|
|
|
|
// a unidirectional message queue. A queue of type T. Not especially high speed
|
|
// since each message is malloced/freed. Note that if your message class has
|
|
// destructors/constructors, they MUST be thread safe!
|
|
template <class T>
|
|
class CMessageQueue {
|
|
CThreadEvent SignalEvent; // signals presence of data
|
|
CThreadMutex QueueAccessMutex;
|
|
|
|
// the parts protected by the mutex
|
|
struct MsgNode {
|
|
MsgNode *Next;
|
|
T Data;
|
|
};
|
|
|
|
MsgNode *Head;
|
|
MsgNode *Tail;
|
|
|
|
public:
|
|
CMessageQueue(void) { Head = Tail = NULL; }
|
|
|
|
// check for a message. not 100% reliable - someone could grab the message
|
|
// first
|
|
bool MessageWaiting(void) { return (Head != NULL); }
|
|
|
|
void WaitMessage(T *pMsg) {
|
|
for (;;) {
|
|
while (!MessageWaiting()) SignalEvent.Wait();
|
|
QueueAccessMutex.Lock();
|
|
if (!Head) {
|
|
// multiple readers could make this null
|
|
QueueAccessMutex.Unlock();
|
|
continue;
|
|
}
|
|
*(pMsg) = Head->Data;
|
|
MsgNode *remove_this = Head;
|
|
Head = Head->Next;
|
|
if (!Head) // if empty, fix tail ptr
|
|
Tail = NULL;
|
|
QueueAccessMutex.Unlock();
|
|
delete remove_this;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void QueueMessage(T const &Msg) {
|
|
MsgNode *new1 = new MsgNode;
|
|
new1->Data = Msg;
|
|
new1->Next = NULL;
|
|
QueueAccessMutex.Lock();
|
|
if (Tail) {
|
|
Tail->Next = new1;
|
|
Tail = new1;
|
|
} else {
|
|
Head = new1;
|
|
Tail = new1;
|
|
}
|
|
SignalEvent.Set();
|
|
QueueAccessMutex.Unlock();
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadMutex. Inlining to reduce overhead and to allow client code
|
|
// to decide debug status (tracing)
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef _WIN32
|
|
typedef struct _RTL_CRITICAL_SECTION RTL_CRITICAL_SECTION;
|
|
typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
|
|
|
|
#ifndef _X360
|
|
extern "C" {
|
|
void __declspec(dllimport) __stdcall InitializeCriticalSection(
|
|
CRITICAL_SECTION *);
|
|
void __declspec(dllimport) __stdcall EnterCriticalSection(CRITICAL_SECTION *);
|
|
void __declspec(dllimport) __stdcall LeaveCriticalSection(CRITICAL_SECTION *);
|
|
void __declspec(dllimport) __stdcall DeleteCriticalSection(CRITICAL_SECTION *);
|
|
};
|
|
#endif
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::Lock() {
|
|
#ifdef THREAD_MUTEX_TRACING_ENABLED
|
|
uint thisThreadID = ThreadGetCurrentId();
|
|
if (m_bTrace && m_currentOwnerID && (m_currentOwnerID != thisThreadID))
|
|
Msg("Thread %u about to wait for lock %p owned by %u\n",
|
|
ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection,
|
|
m_currentOwnerID);
|
|
#endif
|
|
|
|
VCRHook_EnterCriticalSection((CRITICAL_SECTION *)&m_CriticalSection);
|
|
|
|
#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
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::Unlock() {
|
|
#ifdef THREAD_MUTEX_TRACING_ENABLED
|
|
AssertMsg(m_lockCount >= 1, "Invalid unlock of thread lock");
|
|
m_lockCount--;
|
|
if (m_lockCount == 0) {
|
|
if (m_bTrace)
|
|
Msg("Thread %u releasing lock %p\n", m_currentOwnerID,
|
|
(CRITICAL_SECTION *)&m_CriticalSection);
|
|
m_currentOwnerID = 0;
|
|
}
|
|
#endif
|
|
LeaveCriticalSection((CRITICAL_SECTION *)&m_CriticalSection);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline bool CThreadMutex::AssertOwnedByCurrentThread() {
|
|
#ifdef THREAD_MUTEX_TRACING_ENABLED
|
|
if (ThreadGetCurrentId() == m_currentOwnerID) return true;
|
|
AssertMsg3(0, "Expected thread %u as owner of lock %p, but %u owns",
|
|
ThreadGetCurrentId(), (CRITICAL_SECTION *)&m_CriticalSection,
|
|
m_currentOwnerID);
|
|
return false;
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::SetTrace(bool bTrace) {
|
|
#ifdef THREAD_MUTEX_TRACING_ENABLED
|
|
m_bTrace = bTrace;
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
#elif defined(POSIX)
|
|
|
|
inline CThreadMutex::CThreadMutex() {
|
|
// enable recursive locks as we need them
|
|
pthread_mutexattr_init(&m_Attr);
|
|
pthread_mutexattr_settype(&m_Attr, PTHREAD_MUTEX_RECURSIVE);
|
|
pthread_mutex_init(&m_Mutex, &m_Attr);
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline CThreadMutex::~CThreadMutex() { pthread_mutex_destroy(&m_Mutex); }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::Lock() { pthread_mutex_lock(&m_Mutex); }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::Unlock() { pthread_mutex_unlock(&m_Mutex); }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline bool CThreadMutex::AssertOwnedByCurrentThread() { return true; }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
inline void CThreadMutex::SetTrace(bool fTrace) {}
|
|
|
|
#endif // POSIX
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadRWLock inline functions
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline CThreadRWLock::CThreadRWLock()
|
|
: m_CanRead(true),
|
|
m_nWriters(0),
|
|
m_nActiveReaders(0),
|
|
m_nPendingReaders(0) {}
|
|
|
|
inline void CThreadRWLock::LockForRead() {
|
|
m_mutex.Lock();
|
|
if (m_nWriters) {
|
|
WaitForRead();
|
|
}
|
|
m_nActiveReaders++;
|
|
m_mutex.Unlock();
|
|
}
|
|
|
|
inline void CThreadRWLock::UnlockRead() {
|
|
m_mutex.Lock();
|
|
m_nActiveReaders--;
|
|
if (m_nActiveReaders == 0 && m_nWriters != 0) {
|
|
m_CanWrite.Set();
|
|
}
|
|
m_mutex.Unlock();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CThreadSpinRWLock inline functions
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline bool CThreadSpinRWLock::AssignIf(const LockInfo_t &newValue,
|
|
const LockInfo_t &comperand) {
|
|
return ThreadInterlockedAssignIf64(
|
|
(int64 *)&m_lockInfo, *((int64 *)&newValue), *((int64 *)&comperand));
|
|
}
|
|
|
|
inline bool CThreadSpinRWLock::TryLockForWrite(const uint32 threadId) {
|
|
// In order to grab a write lock, there can be no readers and no owners of
|
|
// the write lock
|
|
if (m_lockInfo.m_nReaders > 0 ||
|
|
(m_lockInfo.m_writerId && m_lockInfo.m_writerId != threadId)) {
|
|
return false;
|
|
}
|
|
|
|
static const LockInfo_t oldValue = {0, 0};
|
|
LockInfo_t newValue = {threadId, 0};
|
|
const bool bSuccess = AssignIf(newValue, oldValue);
|
|
#if defined(_X360)
|
|
if (bSuccess) {
|
|
// X360TBD: Serious perf implications. Not Yet. __sync();
|
|
}
|
|
#endif
|
|
return bSuccess;
|
|
}
|
|
|
|
inline bool CThreadSpinRWLock::TryLockForWrite() {
|
|
m_nWriters++;
|
|
if (!TryLockForWrite(ThreadGetCurrentId())) {
|
|
m_nWriters--;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline bool CThreadSpinRWLock::TryLockForRead() {
|
|
if (m_nWriters != 0) {
|
|
return false;
|
|
}
|
|
// In order to grab a write lock, the number of readers must not change and
|
|
// no thread can own the write
|
|
LockInfo_t oldValue;
|
|
LockInfo_t newValue;
|
|
|
|
oldValue.m_nReaders = m_lockInfo.m_nReaders;
|
|
oldValue.m_writerId = 0;
|
|
newValue.m_nReaders = oldValue.m_nReaders + 1;
|
|
newValue.m_writerId = 0;
|
|
|
|
const bool bSuccess = AssignIf(newValue, oldValue);
|
|
#if defined(_X360)
|
|
if (bSuccess) {
|
|
// X360TBD: Serious perf implications. Not Yet. __sync();
|
|
}
|
|
#endif
|
|
return bSuccess;
|
|
}
|
|
|
|
inline void CThreadSpinRWLock::LockForWrite() {
|
|
const uint32 threadId = ThreadGetCurrentId();
|
|
|
|
m_nWriters++;
|
|
|
|
if (!TryLockForWrite(threadId)) {
|
|
ThreadPause();
|
|
SpinLockForWrite(threadId);
|
|
}
|
|
}
|
|
|
|
// read data from a memory address
|
|
template <class T>
|
|
FORCEINLINE T ReadVolatileMemory(T const *pPtr) {
|
|
volatile const T *pVolatilePtr = (volatile const T *)pPtr;
|
|
return *pVolatilePtr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if defined(_WIN32)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // THREADTOOLS_H
|