ardour/livetrax
13
0
Fork 0
Code
cd60fd9dfe
livetrax/libs/backends/wavesaudio/wavesapi/Threads/WCThreadSafe.h

393 lines
12 KiB
C++
Raw Blame History

#ifndef __WCThreadSafe_h_
#define __WCThreadSafe_h_
/* Copy to include
#include "Threads/WCThreadSafe.h"
*/
//
// * WCThreadSafe.h (used to be called XPlatformOSServices.hpp)
// *
// * Consistent C++ interfaces to common Operating System services.
// *
// *
// *
// *
// * Created 2004-December-13 by Udi Barzilai as XPlatformOSServices.hpp
// * Moved to WCThreadSafe.h by Shai 26/10/2005
// * 26/10/2005: ThreadMutex now inhetites from ThreadMutexInited
// * namespace changed to wvThread
#include "WavesPublicAPI/wstdint.h"
#include <string>
#include "BasicTypes/WUDefines.h"
#if defined(__linux__) || defined(__APPLE__)
#define XPLATFORMOSSERVICES_UNIX 1
#endif
#if defined(_WIN32)
#define XPLATFORMOSSERVICES_WIN32 1
#endif
#if XPLATFORMOSSERVICES_WIN32
#define XPLATFORMTHREADS_WINDOWS 1
#elif XPLATFORMOSSERVICES_UNIX
#define XPLATFORMTHREADS_POSIX 1
#endif
namespace wvNS {
typedef uint32_t WTThreadSafetyType;
const WTThreadSafetyType kNoThreadSafetyNeeded = 0;
const WTThreadSafetyType kpthreadsmutexThreadSafety = 1;
namespace wvThread
{
//#include "BasicTypes/WavesAPISetAligment.h"
//Packing affects the layout of classes, and commonly, if packing changes across header files, there can be problems.
#ifdef PLATFORM_WINDOWS
#pragma pack(push)
#pragma pack(8)
#endif
#ifdef __APPLE__
#ifdef __GNUC__
#pragma pack(push, 8)
#endif
#endif
//--------------------------------------------------------
typedef int32_t timediff; // in microseconds
static const timediff ktdOneSecond = 1000*1000;
//--------------------------------------------------------
class timestamp
{
protected:
typedef uint32_t tickcount;
tickcount m_nMicroseconds; // may wrap around
static const tickcount ms_knWraparoundThreshold = ~tickcount(0) ^ (~tickcount(0)>>1); // half the range
public:
timestamp() : m_nMicroseconds(0) { /* uninitialized */ }
timestamp(const timestamp &_ts) : m_nMicroseconds(_ts.m_nMicroseconds) {}
timestamp &operator=(const timestamp &_rhs) { m_nMicroseconds = _rhs.m_nMicroseconds; return *this; }
explicit timestamp(tickcount _i) : m_nMicroseconds(_i) {}
uint32_t ticks() const { return m_nMicroseconds; }
timediff operator-(timestamp _rhs) const { return timediff(m_nMicroseconds-_rhs.m_nMicroseconds); }
timestamp & operator+=(timediff _t) { m_nMicroseconds+=_t; return *this; }
timestamp & operator-=(timediff _t) { m_nMicroseconds-=_t; return *this; }
timestamp operator+(timediff _t) const { return timestamp(m_nMicroseconds+_t); }
timestamp operator-(timediff _t) const { return timestamp(m_nMicroseconds-_t); }
bool operator==(timestamp _rhs) const { return m_nMicroseconds==_rhs.m_nMicroseconds; }
bool operator!=(timestamp _rhs) const { return m_nMicroseconds!=_rhs.m_nMicroseconds; }
bool operator< (timestamp _rhs) const { return m_nMicroseconds-_rhs.m_nMicroseconds >= ms_knWraparoundThreshold; }
static timestamp null() { return timestamp(0); }
bool is_null() const { return m_nMicroseconds==0; }
};
//--------------------------------------------------------
#ifdef __APPLE__
bool FindNetInterfaceByIPAddress(const char *sIP, char *sInterface);
#endif // MACOS
//--------------------------------------------------------
timestamp now();
//--------------------------------------------------------
DllExport void sleep(timediff);
DllExport void sleep_milliseconds(unsigned int nMillisecs);
//--------------------------------------------------------
void yield();
//--------------------------------------------------------
typedef uintptr_t os_dependent_handle_type;
//--------------------------------------------------------
typedef int ThreadFunctionReturnType;
typedef void * ThreadFunctionArgument;
//--------------------------------------------------------
typedef ThreadFunctionReturnType (ThreadFunction)(ThreadFunctionArgument);
//--------------------------------------------------------
class ThreadHandle
{
public:
class OSDependent;
protected:
uintptr_t m_oshandle; // hopefully this is good enough for all systems
public:
static const ThreadHandle Invalid;
protected:
ThreadHandle(uintptr_t n) : m_oshandle(n) {}
public:
ThreadHandle() : m_oshandle(Invalid.m_oshandle) {}
bool is_invalid() const { return !m_oshandle || m_oshandle==Invalid.m_oshandle; }
};
//--------------------------------------------------------
class ThreadPriority
{
public: enum value { BelowNormal=1, Normal=2, AboveNormal=3, TimeCritical=4 };
protected: value m_value;
public: ThreadPriority(value v) : m_value(v) {}
public: operator value() const { return m_value; }
};
//--------------------------------------------------------
void SetMyThreadPriority(ThreadPriority);
//--------------------------------------------------------
ThreadHandle StartThread(ThreadFunction, ThreadFunctionArgument, ThreadPriority=ThreadPriority::Normal);
bool JoinThread(ThreadHandle, ThreadFunctionReturnType * = 0);
bool KillThread(ThreadHandle); // use only for abnormal termination
void Close(ThreadHandle); // should be called once for every handle obtained from StartThread.
//--------------------------------------------------------
//--------------------------------------------------------
class DllExport noncopyableobject
{
protected:
noncopyableobject() {}
private:
noncopyableobject(const noncopyableobject &);
noncopyableobject & operator=(const noncopyableobject &);
};
//--------------------------------------------------------
//--------------------------------------------------------
// Thread Mutex class that needs to be explicitly initialized
class DllExport ThreadMutexInited : public noncopyableobject
{
protected:
class OSDependentMutex;
OSDependentMutex* m_osdmutex;
public:
ThreadMutexInited();
~ThreadMutexInited();
void init();
void uninit();
inline bool is_init() { return 0 != m_osdmutex; }
void obtain();
bool tryobtain();
void release();
private:
ThreadMutexInited(const ThreadMutexInited&); // cannot be copied
ThreadMutexInited& operator=(const ThreadMutexInited&); // cannot be copied
public:
class lock : public noncopyableobject
{
protected:
ThreadMutexInited &m_mutex;
public:
inline lock(ThreadMutexInited &mtx) : m_mutex(mtx) { m_mutex.obtain(); }
inline ~lock() { m_mutex.release(); }
};
class trylock : public noncopyableobject
{
protected:
ThreadMutexInited &m_mutex;
bool m_bObtained;
public:
inline trylock(ThreadMutexInited &mtx) : m_mutex(mtx), m_bObtained(false) { m_bObtained = m_mutex.tryobtain(); }
inline ~trylock() { if (m_bObtained) m_mutex.release(); }
inline operator bool() const { return m_bObtained; }
};
};
//--------------------------------------------------------
// Thread Mutex class that is automatically initialized
class ThreadMutex : public ThreadMutexInited
{
public:
ThreadMutex() {init();}
};
//--------------------------------------------------------
class DllExport ThreadConditionSignal : public noncopyableobject
{
protected:
class OSDependentObject;
OSDependentObject &m_osdepobj;
protected:
void obtain_mutex();
bool tryobtain_mutex();
void release_mutex();
public:
class lock : public noncopyableobject
{
protected:
ThreadConditionSignal &m_tcs;
public:
lock(ThreadConditionSignal &tcs) : m_tcs(tcs) { m_tcs.obtain_mutex(); }
~lock() { m_tcs.release_mutex(); }
};
class trylock : public noncopyableobject
{
protected:
ThreadConditionSignal &m_tcs;
bool m_bObtained;
public:
trylock(ThreadConditionSignal &tcs) : m_tcs(tcs), m_bObtained(false) { m_bObtained = m_tcs.tryobtain_mutex(); }
~trylock() { if (m_bObtained) m_tcs.release_mutex(); }
operator bool() const { return m_bObtained; }
};
public:
ThreadConditionSignal();
~ThreadConditionSignal();
// IMPORTANT: All of the functions below MUST be called ONLY while holding a lock for this object !!!
void await_condition();
bool await_condition(timediff tdTimeout);
void signal_condition_single();
void signal_condition_broadcast();
};
//--------------------------------------------------------
//--------------------------------------------------------
// A doorbell is a simple communication mechanism that allows
// one thread two wake another when there is some work to be done.
// The signal is 'clear on read'. This class is not intended for
// multi-way communication (i.e. more than two threads).
//#define XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR (!XPLATFORMTHREADS_WINDOWS && !XPLATFORMOSSERVICES_MACOS)
#ifdef XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR
#undef XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR
#endif
#define XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR 1
#if XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR
class doorbell_type
{
protected:
ThreadConditionSignal m_signal;
bool m_rang;
protected:
template<bool wait_forever> bool wait_for_ring_internal(timediff timeout)
{// mutex
ThreadConditionSignal::lock guard(m_signal);
if (!m_rang)
{
if (wait_forever)
{
m_signal.await_condition();
}
else
{
m_signal.await_condition(timeout);
}
}
const bool rang = m_rang;
m_rang = false;
return rang;
}// mutex
public:
doorbell_type() : m_rang(false) {}
inline ~doorbell_type() {}
inline void ring()
{// mutex
ThreadConditionSignal::lock guard(m_signal);
m_rang = true;
m_signal.signal_condition_single();
}// mutex
inline bool wait_for_ring() { return wait_for_ring_internal<true>(0); }
inline bool wait_for_ring(timediff timeout) { return wait_for_ring_internal<false>(timeout); }
};
#else
class doorbell_type : public noncopyableobject
{
protected:
os_dependent_handle_type m_os_dependent_handle;
protected:
template<bool wait_forever> bool wait_for_ring_internal(timediff);
public:
doorbell_type();
~doorbell_type();
void ring();
bool wait_for_ring();
bool wait_for_ring(timediff timeout);
};
#endif // XPLATFORMTHREADS_DOORBELL_INLINE_USING_COND_VAR
//--------------------------------------------------------
//---------------------------------------------------------------
class DllExport WCThreadRef // Class which holds the threadRef, DWORD in Windows and pthread_t in POSIX (Mac, Unix)
{
public:
class OSDependent; // the class which contains the OS Dependent implementation
WCThreadRef() : m_osThreadRef(0) {}
bool is_invalid() const { return m_osThreadRef == 0;}
operator uintptr_t() const {return m_osThreadRef;}
protected:
uintptr_t m_osThreadRef;
WCThreadRef(uintptr_t n) : m_osThreadRef(n) {}
friend DllExport bool operator==(const WCThreadRef& first, const WCThreadRef& second);
friend DllExport bool operator!=(const WCThreadRef& first, const WCThreadRef& second);
friend DllExport bool operator<(const WCThreadRef& first, const WCThreadRef& second);
friend DllExport bool operator>(const WCThreadRef& first, const WCThreadRef& second);
};
DllExport WCThreadRef GetCurrentThreadRef(); // getting the current thread reference - cross-platform implemented
bool IsThreadExists(const WCThreadRef& threadRef); // correct to the very snapshot of time of execution
//---------------------------------------------------------------
class DllExport WCAtomicLock
{
public:
WCAtomicLock() : m_the_lock(0) {}
bool obtain(const uint32_t in_num_trys = 1);
void release();
private:
int32_t m_the_lock;
};
//#include "BasicTypes/WavesAPIResetAligment.h"
#ifdef PLATFORM_WINDOWS
#pragma pack(pop)
#endif
#ifdef __APPLE__
#ifdef __GNUC__
#pragma pack(pop)
#endif
#endif
class WCStThreadMutexLocker
{
public:
WCStThreadMutexLocker(wvNS::wvThread::ThreadMutexInited& in_mutex) :
m_mutex(in_mutex)
{
m_mutex.obtain();
}
~WCStThreadMutexLocker()
{
m_mutex.release();
}
protected:
wvNS::wvThread::ThreadMutexInited& m_mutex;
WCStThreadMutexLocker(const WCStThreadMutexLocker&);
WCStThreadMutexLocker& operator=(const WCStThreadMutexLocker&);
};
} // namespace wvThread
} //namespace wvNS {
#endif // #ifndef __WCThreadSafe_h_
View Git Blame Copy Permalink