King_DuckZ/Loki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

adding support for POSIX threads (pthreads.h), Thanks to Ilya Volvovski

Browse source 
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@319 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
syntheticpp 2005-10-24 15:05:24 +00:00
parent 7d66b82b9a
commit b73fe0bbcf
1 changed files with 121 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

174
include/loki/Threads.h
View file

@ -12,18 +12,27 @@
// $Header$ // $Header$
#if defined(_WIN32) && (defined(LOKI_CLASS_LEVEL_THREADING) || defined(LOKI_OBJECT_LEVEL_THREADING)) #if defined(LOKI_CLASS_LEVEL_THREADING) || defined(LOKI_OBJECT_LEVEL_THREADING)
// threads only on windows
#include <windows.h>
#define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::ClassLevelLockable #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::ClassLevelLockable
#if defined(LOKI_CLASS_LEVEL_THREADING)
#if defined(LOKI_CLASS_LEVEL_THREADING) && !defined(LOKI_OBJECT_LEVEL_THREADING)
#define LOKI_DEFAULT_THREADING ::Loki::ClassLevelLockable #define LOKI_DEFAULT_THREADING ::Loki::ClassLevelLockable
#else #else
#define LOKI_DEFAULT_THREADING ::Loki::ObjectLevelLockable #define LOKI_DEFAULT_THREADING ::Loki::ObjectLevelLockable
#endif #endif
#if defined(_WIN32)
#include <windows.h>
#else
#include <pthread.h>
#endif
#else #else
#define LOKI_DEFAULT_THREADING ::Loki::SingleThreaded #define LOKI_DEFAULT_THREADING ::Loki::SingleThreaded
#define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::SingleThreaded #define LOKI_DEFAULT_THREADING_NO_OBJ_LEVEL ::Loki::SingleThreaded
#endif #endif
#include <cassert> #include <cassert>
@ -77,6 +86,63 @@ namespace Loki
#if defined(_WINDOWS_) || defined(_WINDOWS_H) #if defined(_WINDOWS_) || defined(_WINDOWS_H)
#define LOKI_THREADS_MUTEX_DECLARATION(x) CRITICAL_SECTION x
#define LOKI_THREADS_MUTEX_INIT(x) ::InitializeCriticalSection(x)
#define LOKI_THREADS_MUTEX_DELETE(x) ::DeleteCriticalSection(x)
#define LOKI_THREADS_MUTEX_LOCK(x) ::EnterCriticalSection(x)
#define LOKI_THREADS_MUTEX_UNLOCK(x) ::LeaveCriticalSection(x)
#define LOKI_THREADS_LONG LONG
#define LOKI_THREADS_ATOMIC_FUNCTIONS \
static IntType AtomicIncrement(volatile IntType& lval) \
{ return InterlockedIncrement(&const_cast<IntType&>(lval)); } \
\
static IntType AtomicDecrement(volatile IntType& lval) \
{ return InterlockedDecrement(&const_cast<IntType&>(lval)); } \
\
static void AtomicAssign(volatile IntType& lval, IntType val) \
{ InterlockedExchange(&const_cast<IntType&>(lval), val); } \
\
static void AtomicAssign(IntType& lval, volatile IntType& val) \
{ InterlockedExchange(&lval, val); }
#elif defined(_PTHREAD_H) //POSIX threads (pthread.h)
#define LOKI_THREADS_MUTEX_DECLARATION(x) pthread_mutex_t x
#define LOKI_THREADS_MUTEX_INIT(x) ::pthread_mutex_init(x,0)
#define LOKI_THREADS_MUTEX_DELETE(x) ::pthread_mutex_destroy(x)
#define LOKI_THREADS_MUTEX_LOCK(x) ::pthread_mutex_lock(x)
#define LOKI_THREADS_MUTEX_UNLOCK(x) ::pthread_mutex_unlock(x)
#define LOKI_THREADS_LONG long
#define LOKI_THREADS_ATOMIC(x) \
pthread_mutex_lock(&atomic_mutex_); \
x; \
pthread_mutex_unlock(&atomic_mutex_)
#define LOKI_THREADS_ATOMIC_FUNCTIONS \
static IntType AtomicIncrement(volatile IntType& lval) \
{ LOKI_THREADS_ATOMIC( lval++ ); return lval; } \
\
static IntType AtomicDecrement(volatile IntType& lval) \
{ LOKI_THREADS_ATOMIC(lval-- ); return lval; } \
\
static void AtomicAssign(volatile IntType& lval, IntType val) \
{ LOKI_THREADS_ATOMIC( lval = val ); } \
\
static void AtomicAssign(IntType& lval, volatile IntType& val) \
{ LOKI_THREADS_ATOMIC( lval = val ); }
static pthread_mutex_t atomic_mutex_ = PTHREAD_MUTEX_INITIALIZER;
#endif
#if defined(_WINDOWS_) || defined(_WINDOWS_H) || defined(_PTHREAD_H)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// class template ObjectLevelLockable // class template ObjectLevelLockable
@ -87,134 +153,133 @@ namespace Loki
template <class Host> template <class Host>
class ObjectLevelLockable class ObjectLevelLockable
{ {
mutable CRITICAL_SECTION mtx_; LOKI_THREADS_MUTEX_DECLARATION(mtx_);
public: public:
ObjectLevelLockable() ObjectLevelLockable()
{ {
::InitializeCriticalSection(&mtx_); LOKI_THREADS_MUTEX_INIT(&mtx_);
} }
ObjectLevelLockable(const ObjectLevelLockable&) ObjectLevelLockable(const ObjectLevelLockable&)
{ {
::InitializeCriticalSection(&mtx_); LOKI_THREADS_MUTEX_INIT(&mtx_);
} }
~ObjectLevelLockable() ~ObjectLevelLockable()
{ {
::DeleteCriticalSection(&mtx_); LOKI_THREADS_MUTEX_DELETE(&mtx_);
} }
class Lock; class Lock;
friend class Lock; friend class Lock;
class Lock class Lock
{ {
ObjectLevelLockable const& host_;
Lock(const Lock&);
Lock& operator=(const Lock&);
public: public:
explicit Lock(const ObjectLevelLockable& host) : host_(host) explicit Lock(const ObjectLevelLockable& host) : host_(host)
{ {
::EnterCriticalSection(&host_.mtx_); LOKI_THREADS_MUTEX_LOCK(&host_.mtx_);
} }
~Lock() ~Lock()
{ {
::LeaveCriticalSection(&host_.mtx_); LOKI_THREADS_MUTEX_UNLOCK(&host_.mtx_);
} }
private:
Lock(const Lock&);
Lock& operator=(const Lock&);
ObjectLevelLockable const& host_;
}; };
typedef volatile Host VolatileType; typedef volatile Host VolatileType;
typedef LONG IntType; typedef LOKI_THREADS_LONG IntType;
static IntType AtomicIncrement(volatile IntType& lval)
{ return InterlockedIncrement(&const_cast<IntType&>(lval)); }
static IntType AtomicDecrement(volatile IntType& lval) LOKI_THREADS_ATOMIC_FUNCTIONS
{ return InterlockedDecrement(&const_cast<IntType&>(lval)); }
static void AtomicAssign(volatile IntType& lval, IntType val)
{ InterlockedExchange(&const_cast<IntType&>(lval), val); }
static void AtomicAssign(IntType& lval, volatile IntType& val)
{ InterlockedExchange(&lval, val); }
}; };
////////////////////////////////////////////////////////////////////////////////
// class template ClassLevelLockable
// Implementation of the ThreadingModel policy used by various classes
// Implements a class-level locking scheme
////////////////////////////////////////////////////////////////////////////////
template <class Host> template <class Host>
class ClassLevelLockable class ClassLevelLockable
{ {
struct Initializer struct Initializer
{ {
CRITICAL_SECTION mtx_; LOKI_THREADS_MUTEX_DECLARATION(mtx_);
bool init_; bool init_;
Initializer():init_(false) Initializer() : init_(false)
{ {
::InitializeCriticalSection(&mtx_); LOKI_THREADS_MUTEX_INIT(&mtx_);
init_=true; init_ = true;
} }
~Initializer() ~Initializer()
{ {
assert(init_); assert(init_);
::DeleteCriticalSection(&mtx_); LOKI_THREADS_MUTEX_DELETE(&mtx_);
} }
}; };
static Initializer initializer_; static Initializer initializer_;
public: public:
class Lock; class Lock;
friend class Lock; friend class Lock;
class Lock class Lock
{ {
Lock(const Lock&);
Lock& operator=(const Lock&);
public: public:
Lock() Lock()
{ {
assert(initializer_.init_); assert(initializer_.init_);
::EnterCriticalSection(&initializer_.mtx_); LOKI_THREADS_MUTEX_LOCK(&initializer_.mtx_);
} }
explicit Lock(const ClassLevelLockable&) explicit Lock(const ClassLevelLockable&)
{ {
assert(initializer_.init_); assert(initializer_.init_);
::EnterCriticalSection(&initializer_.mtx_); LOKI_THREADS_MUTEX_LOCK(&initializer_.mtx_);
} }
~Lock() ~Lock()
{ {
assert(initializer_.init_); assert(initializer_.init_);
::LeaveCriticalSection(&initializer_.mtx_); LOKI_THREADS_MUTEX_UNLOCK(&initializer_.mtx_);
} }
private:
Lock(const Lock&);
Lock& operator=(const Lock&);
}; };
typedef volatile Host VolatileType; typedef volatile Host VolatileType;
typedef LONG IntType; typedef LOKI_THREADS_LONG IntType;
static IntType AtomicIncrement(volatile IntType& lval) LOKI_THREADS_ATOMIC_FUNCTIONS
{ return InterlockedIncrement(&const_cast<IntType&>(lval)); }
static IntType AtomicDecrement(volatile IntType& lval)
{ return InterlockedDecrement(&const_cast<IntType&>(lval)); }
static void AtomicAssign(volatile IntType& lval, IntType val)
{ InterlockedExchange(&const_cast<IntType&>(lval), val); }
static void AtomicAssign(IntType& lval, volatile IntType& val)
{ InterlockedExchange(&lval, val); }
}; };
template <class Host> template <class Host>
typename ClassLevelLockable<Host>::Initializer typename ClassLevelLockable<Host>::Initializer
ClassLevelLockable<Host>::initializer_; ClassLevelLockable<Host>::initializer_;
#endif #endif // defined(_WINDOWS_) || defined(_WINDOWS_H) || defined(_PTHREAD_H)
}
} // namespace Loki
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Change log: // Change log:
@ -226,6 +291,9 @@ namespace Loki
#endif #endif
// $Log$ // $Log$
// Revision 1.14 2005/10/24 15:05:24 syntheticpp
// adding support for POSIX threads (pthreads.h), Thanks to Ilya Volvovski
//
// Revision 1.13 2005/09/26 07:33:04 syntheticpp // Revision 1.13 2005/09/26 07:33:04 syntheticpp
// move macros into LOKI_ namespace // move macros into LOKI_ namespace
// //