birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[redcode/crythread-2nd-pass] removed more unused code from CryThread

Browse Source 
Signed-off-by: AMZN-ScottR <24445312+AMZN-ScottR@users.noreply.github.com>
This commit is contained in:
AMZN-ScottR
2021-08-09 14:49:29 -07:00
parent f47b8b534b
commit 2408f7dc37
3 changed files with 0 additions and 656 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Legacy/CryCommon/CryThreadImpl_windows.h
-177
View File
@@ -76,180 +76,3 @@ bool CryLock_CritSection::TryLock()
{
return TryEnterCriticalSection((CRITICAL_SECTION*)&m_cs) != FALSE;
}
//////////////////////////////////////////////////////////////////////////
// most of this is taken from http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
//////////////////////////////////////////////////////////////////////////
CryConditionVariable::CryConditionVariable()
{
m_waitersCount = 0;
m_wasBroadcast = 0;
m_sema = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
InitializeCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
m_waitersDone = CreateEvent(NULL, FALSE, FALSE, NULL);
}
//////////////////////////////////////////////////////////////////////////
CryConditionVariable::~CryConditionVariable()
{
CloseHandle(m_sema);
DeleteCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
CloseHandle(m_waitersDone);
}
//////////////////////////////////////////////////////////////////////////
void CryConditionVariable::Wait(LockType& lock)
{
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
m_waitersCount++;
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
SignalObjectAndWait(lock._get_win32_handle(), m_sema, INFINITE, FALSE);
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
m_waitersCount--;
bool lastWaiter = m_wasBroadcast && m_waitersCount == 0;
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
if (lastWaiter)
{
SignalObjectAndWait(m_waitersDone, lock._get_win32_handle(), INFINITE, FALSE);
}
else
{
WaitForSingleObject(lock._get_win32_handle(), INFINITE);
}
}
//////////////////////////////////////////////////////////////////////////
bool CryConditionVariable::TimedWait(LockType& lock, uint32 millis)
{
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
m_waitersCount++;
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
bool ok = true;
if (WAIT_TIMEOUT == SignalObjectAndWait(lock._get_win32_handle(), m_sema, millis, FALSE))
{
ok = false;
}
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
m_waitersCount--;
bool lastWaiter = m_wasBroadcast && m_waitersCount == 0;
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
if (lastWaiter)
{
SignalObjectAndWait(m_waitersDone, lock._get_win32_handle(), INFINITE, FALSE);
}
else
{
WaitForSingleObject(lock._get_win32_handle(), INFINITE);
}
return ok;
}
//////////////////////////////////////////////////////////////////////////
void CryConditionVariable::NotifySingle()
{
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
bool haveWaiters = m_waitersCount > 0;
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
if (haveWaiters)
{
ReleaseSemaphore(m_sema, 1, 0);
}
}
//////////////////////////////////////////////////////////////////////////
void CryConditionVariable::Notify()
{
EnterCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
bool haveWaiters = false;
if (m_waitersCount > 0)
{
m_wasBroadcast = 1;
haveWaiters = true;
}
if (haveWaiters)
{
ReleaseSemaphore(m_sema, m_waitersCount, 0);
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
WaitForSingleObject(m_waitersDone, INFINITE);
m_wasBroadcast = 0;
}
else
{
LeaveCriticalSection((CRITICAL_SECTION*)&m_waitersCountLock);
}
}
//////////////////////////////////////////////////////////////////////////
CrySemaphore::CrySemaphore(int nMaximumCount, int nInitialCount)
{
m_Semaphore = (void*)CreateSemaphore(NULL, nInitialCount, nMaximumCount, NULL);
}
//////////////////////////////////////////////////////////////////////////
CrySemaphore::~CrySemaphore()
{
CloseHandle((HANDLE)m_Semaphore);
}
//////////////////////////////////////////////////////////////////////////
void CrySemaphore::Acquire()
{
WaitForSingleObject((HANDLE)m_Semaphore, INFINITE);
}
//////////////////////////////////////////////////////////////////////////
void CrySemaphore::Release()
{
ReleaseSemaphore((HANDLE)m_Semaphore, 1, NULL);
}
//////////////////////////////////////////////////////////////////////////
CryFastSemaphore::CryFastSemaphore(int nMaximumCount, int nInitialCount)
: m_Semaphore(nMaximumCount)
, m_nCounter(nInitialCount)
{
}
//////////////////////////////////////////////////////////////////////////
CryFastSemaphore::~CryFastSemaphore()
{
}
//////////////////////////////////////////////////////////////////////////
void CryFastSemaphore::Acquire()
{
int nCount = ~0;
do
{
nCount = *const_cast<volatile int*>(&m_nCounter);
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nCounter), nCount - 1, nCount) != nCount);
// if the count would have been 0 or below, go to kernel semaphore
if ((nCount - 1) < 0)
{
m_Semaphore.Acquire();
}
}
//////////////////////////////////////////////////////////////////////////
void CryFastSemaphore::Release()
{
int nCount = ~0;
do
{
nCount = *const_cast<volatile int*>(&m_nCounter);
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nCounter), nCount + 1, nCount) != nCount);
// wake up kernel semaphore if we have waiter
if (nCount < 0)
{
m_Semaphore.Release();
}
}
Code/Legacy/CryCommon/CryThread_pthreads.h
-423
View File
@@ -48,52 +48,12 @@
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#endif
#if !defined(RegisterThreadName)
#define RegisterThreadName(id, name)
#define UnRegisterThreadName(id)
#endif
#if defined(APPLE) || defined(ANDROID)
// PTHREAD_MUTEX_FAST_NP is only defined by Pthreads-w32, thus not on MAC
#define PTHREAD_MUTEX_FAST_NP PTHREAD_MUTEX_NORMAL
#endif
// Define LARGE_THREAD_STACK to use larger than normal per-thread stack
#if defined(_DEBUG) && (defined(MAC) || defined(LINUX) || defined(AZ_PLATFORM_IOS))
#define LARGE_THREAD_STACK
#endif
#if defined(LINUX)
#undef RegisterThreadName
ILINE void RegisterThreadName(pthread_t id, const char* name)
{
if ((!name) || (!id))
{
return;
}
int ret;
// pthread names on linux are limited to 16 char
if (strlen(name) >= 16)
{
char thread_name[16];
memcpy(thread_name, name, 15);
thread_name[15] = 0;
ret = pthread_setname_np(id, thread_name);
}
else
{
ret = pthread_setname_np(id, name);
}
if (ret != 0)
{
CryLog("Failed to set thread name for %" PRI_THREADID ", name: %s", id, name);
}
}
#endif
#if !defined _CRYTHREAD_HAVE_LOCK
template<class LockClass>
class _PthreadCond;
template<int PthreadMutexType>
class _PthreadLockBase;
@@ -130,8 +90,6 @@ template<class LockClass, int PthreadMutexType>
class _PthreadLock
: public _PthreadLockBase<PthreadMutexType>
{
friend class _PthreadCond<LockClass>;
//#if defined(_DEBUG)
public:
//#endif
@@ -218,9 +176,6 @@ public:
#if !defined(LINUX) && !defined(APPLE)
#define CRYTHREAD_PTHREADS_H_TRAIT_DEFINE_CRYMUTEX 1
#endif
#if !defined(LINUX) && !defined(APPLE)
#define CRYTHREAD_PTHREADS_H_TRAIT_SET_THREAD_NAME 1
#endif
#endif
#if CRYTHREAD_PTHREADS_H_TRAIT_DEFINE_CRYMUTEX
@@ -237,386 +192,8 @@ class CryMutex
#endif
#endif // CRYTHREAD_PTHREADS_TRAIT_DEFINE_CRYMUTEX
template<class LockClass>
class _PthreadCond
{
pthread_cond_t m_Cond;
public:
_PthreadCond() { pthread_cond_init(&m_Cond, NULL); }
~_PthreadCond() { pthread_cond_destroy(&m_Cond); }
void Notify() { pthread_cond_broadcast(&m_Cond); }
void NotifySingle() { pthread_cond_signal(&m_Cond); }
void Wait(LockClass& Lock) { pthread_cond_wait(&m_Cond, &Lock.m_Lock); }
bool TimedWait(LockClass& Lock, uint32 milliseconds)
{
struct timeval now;
struct timespec timeout;
int err;
gettimeofday(&now, NULL);
while (true)
{
timeout.tv_sec = now.tv_sec + milliseconds / 1000;
uint64 nsec = (uint64)now.tv_usec * 1000 + (uint64)milliseconds * 1000000;
if (nsec >= 1000000000)
{
timeout.tv_sec += (long)(nsec / 1000000000);
nsec %= 1000000000;
}
timeout.tv_nsec = (long)nsec;
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYTHREAD_PTHREADS_H_SECTION_PTHREADCOND
#include AZ_RESTRICTED_FILE(CryThread_pthreads_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#else
err = pthread_cond_timedwait(&m_Cond, &Lock.m_Lock, &timeout);
if (err == EINTR)
{
// Interrupted by a signal.
continue;
}
else if (err == ETIMEDOUT)
{
return false;
}
#endif
else
{
assert(err == 0);
}
break;
}
return true;
}
// Get the POSIX pthread_cont_t.
// Warning:
// This method will not be available in the Win32 port of CryThread.
pthread_cond_t& Get_pthread_cond_t() { return m_Cond; }
};
#if AZ_LEGACY_CRYCOMMON_TRAIT_USE_PTHREADS
template <class LockClass>
class CryConditionVariableT
: public _PthreadCond<LockClass>
{
};
#if defined CRYLOCK_HAVE_FASTTLOCK
template<>
class CryConditionVariableT< CryLockT<CRYLOCK_FAST> >
: public _PthreadCond< CryLockT<CRYLOCK_FAST> >
{
typedef CryLockT<CRYLOCK_FAST> LockClass;
CryConditionVariableT(const CryConditionVariableT<LockClass>&);
CryConditionVariableT<LockClass>& operator = (const CryConditionVariableT<LockClass>&);
public:
CryConditionVariableT() { }
};
#endif // CRYLOCK_HAVE_FASTLOCK
template<>
class CryConditionVariableT< CryLockT<CRYLOCK_RECURSIVE> >
: public _PthreadCond< CryLockT<CRYLOCK_RECURSIVE> >
{
typedef CryLockT<CRYLOCK_RECURSIVE> LockClass;
CryConditionVariableT(const CryConditionVariableT<LockClass>&);
CryConditionVariableT<LockClass>& operator = (const CryConditionVariableT<LockClass>&);
public:
CryConditionVariableT() { }
};
#if !defined(_CRYTHREAD_CONDLOCK_GLITCH)
typedef CryConditionVariableT< CryLockT<CRYLOCK_RECURSIVE> > CryConditionVariable;
#else
typedef CryConditionVariableT< CryLockT<CRYLOCK_FAST> > CryConditionVariable;
#endif
#define _CRYTHREAD_HAVE_LOCK 1
#else // LINUX MAC
#if defined CRYLOCK_HAVE_FASTLOCK
template<>
class CryConditionVariable
: public _PthreadCond< CryLockT<CRYLOCK_FAST> >
{
typedef CryLockT<CRYLOCK_FAST> LockClass;
CryConditionVariable(const CryConditionVariable&);
CryConditionVariable& operator = (const CryConditionVariable&);
public:
CryConditionVariable() { }
};
#endif // CRYLOCK_HAVE_FASTLOCK
template<>
class CryConditionVariable
: public _PthreadCond< CryLockT<CRYLOCK_RECURSIVE> >
{
typedef CryLockT<CRYLOCK_RECURSIVE> LockClass;
CryConditionVariable(const CryConditionVariable&);
CryConditionVariable& operator = (const CryConditionVariable&);
public:
CryConditionVariable() { }
};
#define _CRYTHREAD_HAVE_LOCK 1
#endif // LINUX MAC
#endif // !defined _CRYTHREAD_HAVE_LOCK
//////////////////////////////////////////////////////////////////////////
// Platform independet wrapper for a counting semaphore
class CrySemaphore
{
public:
CrySemaphore(int nMaximumCount, int nInitialCount = 0);
~CrySemaphore();
void Acquire();
void Release();
private:
#if defined(APPLE)
// Apple only supports named semaphores so have to use sem_open/unlink/sem_close instead
// of sem_open/sem_destroy, passing in this array for the name.
char m_semaphoreName[L_tmpnam];
#endif
sem_t* m_Semaphore;
};
//////////////////////////////////////////////////////////////////////////
inline CrySemaphore::CrySemaphore(int nMaximumCount, int nInitialCount)
{
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYTHREAD_PTHREADS_H_SECTION_SEMAPHORE_CONSTRUCT
#include AZ_RESTRICTED_FILE(CryThread_pthreads_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#elif defined(APPLE)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
tmpnam(m_semaphoreName);
# pragma clang diagnostic pop
m_Semaphore = sem_open(m_semaphoreName, O_CREAT | O_EXCL, 0644, nInitialCount);
#else
m_Semaphore = new sem_t;
sem_init(m_Semaphore, 0, nInitialCount);
#endif
}
//////////////////////////////////////////////////////////////////////////
inline CrySemaphore::~CrySemaphore()
{
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYTHREAD_PTHREADS_H_SECTION_SEMAPHORE_DESTROY
#include AZ_RESTRICTED_FILE(CryThread_pthreads_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#elif defined(APPLE)
sem_close(m_Semaphore);
sem_unlink(m_semaphoreName);
#else
sem_destroy(m_Semaphore);
delete m_Semaphore;
#endif
}
//////////////////////////////////////////////////////////////////////////
inline void CrySemaphore::Acquire()
{
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYTHREAD_PTHREADS_H_SECTION_SEMAPHORE_ACQUIRE
#include AZ_RESTRICTED_FILE(CryThread_pthreads_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#else
while (sem_wait(m_Semaphore) != 0 && errno == EINTR)
{
;
}
#endif
}
//////////////////////////////////////////////////////////////////////////
inline void CrySemaphore::Release()
{
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYTHREAD_PTHREADS_H_SECTION_SEMAPHORE_RELEASE
#include AZ_RESTRICTED_FILE(CryThread_pthreads_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#else
sem_post(m_Semaphore);
#endif
}
//////////////////////////////////////////////////////////////////////////
// Platform independet wrapper for a counting semaphore
// except that this version uses C-A-S only until a blocking call is needed
// -> No kernel call if there are object in the semaphore
class CryFastSemaphore
{
public:
CryFastSemaphore(int nMaximumCount, int nInitialCount = 0);
~CryFastSemaphore();
void Acquire();
void Release();
private:
CrySemaphore m_Semaphore;
volatile int32 m_nCounter;
};
//////////////////////////////////////////////////////////////////////////
inline CryFastSemaphore::CryFastSemaphore(int nMaximumCount, int nInitialCount)
: m_Semaphore(nMaximumCount)
, m_nCounter(nInitialCount)
{
}
//////////////////////////////////////////////////////////////////////////
inline CryFastSemaphore::~CryFastSemaphore()
{
}
/////////////////////////////////////////////////////////////////////////
inline void CryFastSemaphore::Acquire()
{
int nCount = ~0;
do
{
nCount = *const_cast<volatile int*>(&m_nCounter);
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nCounter), nCount - 1, nCount) != nCount);
// if the count would have been 0 or below, go to kernel semaphore
if ((nCount - 1) < 0)
{
m_Semaphore.Acquire();
}
}
//////////////////////////////////////////////////////////////////////////
inline void CryFastSemaphore::Release()
{
int nCount = ~0;
do
{
nCount = *const_cast<volatile int*>(&m_nCounter);
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nCounter), nCount + 1, nCount) != nCount);
// wake up kernel semaphore if we have waiter
if (nCount < 0)
{
m_Semaphore.Release();
}
}
////////////////////////////////////////////////////////////////////////////////
// Provide TLS implementation using pthreads for those platforms without __thread
////////////////////////////////////////////////////////////////////////////////
struct SCryPthreadTLSBase
{
SCryPthreadTLSBase(void (*pDestructor)(void*))
{
pthread_key_create(&m_kKey, pDestructor);
}
~SCryPthreadTLSBase()
{
pthread_key_delete(m_kKey);
}
void* GetSpecific()
{
return pthread_getspecific(m_kKey);
}
void SetSpecific(const void* pValue)
{
pthread_setspecific(m_kKey, pValue);
}
pthread_key_t m_kKey;
};
template <typename T, bool bDirect>
struct SCryPthreadTLSImpl{};
template <typename T>
struct SCryPthreadTLSImpl<T, true>
: private SCryPthreadTLSBase
{
SCryPthreadTLSImpl()
: SCryPthreadTLSBase(NULL)
{
}
T Get()
{
void* pSpecific(GetSpecific());
return *reinterpret_cast<const T*>(&pSpecific);
}
void Set(const T& kValue)
{
SetSpecific(*reinterpret_cast<const void* const*>(&kValue));
}
};
template <typename T>
struct SCryPthreadTLSImpl<T, false>
: private SCryPthreadTLSBase
{
SCryPthreadTLSImpl()
: SCryPthreadTLSBase(&Destroy)
{
}
T* GetPtr()
{
T* pPtr(static_cast<T*>(GetSpecific()));
if (pPtr == NULL)
{
pPtr = new T();
SetSpecific(pPtr);
}
return pPtr;
}
static void Destroy(void* pPointer)
{
delete static_cast<T*>(pPointer);
}
const T& Get()
{
return *GetPtr();
}
void Set(const T& kValue)
{
*GetPtr() = kValue;
}
};
template <typename T>
struct SCryPthreadTLS
: SCryPthreadTLSImpl<T, sizeof(T) <= sizeof(void*)>
{
};
#include "MemoryAccess.h"
Code/Legacy/CryCommon/CryThread_windows.h
-56
View File
@@ -93,59 +93,3 @@ class CryMutex
{
};
#define _CRYTHREAD_CONDLOCK_GLITCH 1
//////////////////////////////////////////////////////////////////////////
class CryConditionVariable
{
public:
typedef CryMutex LockType;
CryConditionVariable();
~CryConditionVariable();
void Wait(LockType& lock);
bool TimedWait(LockType& lock, uint32 millis);
void NotifySingle();
void Notify();
private:
CryConditionVariable(const CryConditionVariable&);
CryConditionVariable& operator = (const CryConditionVariable&);
private:
int m_waitersCount;
CRY_CRITICAL_SECTION m_waitersCountLock;
void* m_sema;
void* m_waitersDone;
size_t m_wasBroadcast;
};
//////////////////////////////////////////////////////////////////////////
// Platform independet wrapper for a counting semaphore
class CrySemaphore
{
public:
CrySemaphore(int nMaximumCount, int nInitialCount = 0);
~CrySemaphore();
void Acquire();
void Release();
private:
void* m_Semaphore;
};
//////////////////////////////////////////////////////////////////////////
// Platform independet wrapper for a counting semaphore
// except that this version uses C-A-S only until a blocking call is needed
// -> No kernel call if there are object in the semaphore
class CryFastSemaphore
{
public:
CryFastSemaphore(int nMaximumCount, int nInitialCount = 0);
~CryFastSemaphore();
void Acquire();
void Release();
private:
CrySemaphore m_Semaphore;
volatile int32 m_nCounter;
};