#ifndef Threading_h
#define Threading_h
#if PLATFORM(WINCE)
#include <windows.h>
#endif
#include <wtf/Assertions.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
#if PLATFORM(WIN_OS) && !PLATFORM(WINCE)
#include <windows.h>
#elif PLATFORM(DARWIN)
#include <libkern/OSAtomic.h>
#elif COMPILER(GCC)
#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2))
#include <ext/atomicity.h>
#else
#include <bits/atomicity.h>
#endif
#endif
#if USE(PTHREADS)
#include <pthread.h>
#elif PLATFORM(GTK)
#include <wtf/GOwnPtr.h>
typedef struct _GMutex GMutex;
typedef struct _GCond GCond;
#endif
#if PLATFORM(QT)
#include <qglobal.h>
QT_BEGIN_NAMESPACE
class QMutex;
class QWaitCondition;
QT_END_NAMESPACE
#endif
#include <stdint.h>
#define AtomicallyInitializedStatic(T, name) \
WTF::lockAtomicallyInitializedStaticMutex(); \
static T name; \
WTF::unlockAtomicallyInitializedStaticMutex();
namespace WTF {
typedef uint32_t ThreadIdentifier;
typedef void* (*ThreadFunction)(void* argument);
ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
void setThreadNameInternal(const char* threadName);
ThreadIdentifier currentThread();
bool isMainThread();
int waitForThreadCompletion(ThreadIdentifier, void**);
void detachThread(ThreadIdentifier);
#if USE(PTHREADS)
typedef pthread_mutex_t PlatformMutex;
typedef pthread_rwlock_t PlatformReadWriteLock;
typedef pthread_cond_t PlatformCondition;
#elif PLATFORM(GTK)
typedef GOwnPtr<GMutex> PlatformMutex;
typedef void* PlatformReadWriteLock; typedef GOwnPtr<GCond> PlatformCondition;
#elif PLATFORM(QT)
typedef QT_PREPEND_NAMESPACE(QMutex)* PlatformMutex;
typedef void* PlatformReadWriteLock; typedef QT_PREPEND_NAMESPACE(QWaitCondition)* PlatformCondition;
#elif PLATFORM(WIN_OS)
struct PlatformMutex {
CRITICAL_SECTION m_internalMutex;
size_t m_recursionCount;
};
typedef void* PlatformReadWriteLock; struct PlatformCondition {
size_t m_waitersGone;
size_t m_waitersBlocked;
size_t m_waitersToUnblock;
HANDLE m_blockLock;
HANDLE m_blockQueue;
HANDLE m_unblockLock;
bool timedWait(PlatformMutex&, DWORD durationMilliseconds);
void signal(bool unblockAll);
};
#else
typedef void* PlatformMutex;
typedef void* PlatformReadWriteLock;
typedef void* PlatformCondition;
#endif
class Mutex : Noncopyable {
public:
Mutex();
~Mutex();
void lock();
bool tryLock();
void unlock();
public:
PlatformMutex& impl() { return m_mutex; }
private:
PlatformMutex m_mutex;
};
typedef Locker<Mutex> MutexLocker;
class ReadWriteLock : Noncopyable {
public:
ReadWriteLock();
~ReadWriteLock();
void readLock();
bool tryReadLock();
void writeLock();
bool tryWriteLock();
void unlock();
private:
PlatformReadWriteLock m_readWriteLock;
};
class ThreadCondition : Noncopyable {
public:
ThreadCondition();
~ThreadCondition();
void wait(Mutex& mutex);
bool timedWait(Mutex&, double absoluteTime);
void signal();
void broadcast();
private:
PlatformCondition m_condition;
};
#if PLATFORM(WIN_OS)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
#if COMPILER(MINGW) || COMPILER(MSVC7) || PLATFORM(WINCE)
inline void atomicIncrement(int* addend) { InterlockedIncrement(reinterpret_cast<long*>(addend)); }
inline int atomicDecrement(int* addend) { return InterlockedDecrement(reinterpret_cast<long*>(addend)); }
#else
inline void atomicIncrement(int volatile* addend) { InterlockedIncrement(reinterpret_cast<long volatile*>(addend)); }
inline int atomicDecrement(int volatile* addend) { return InterlockedDecrement(reinterpret_cast<long volatile*>(addend)); }
#endif
#elif PLATFORM(DARWIN)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
inline void atomicIncrement(int volatile* addend) { OSAtomicIncrement32Barrier(const_cast<int*>(addend)); }
inline int atomicDecrement(int volatile* addend) { return OSAtomicDecrement32Barrier(const_cast<int*>(addend)); }
#elif COMPILER(GCC)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
inline void atomicIncrement(int volatile* addend) { __gnu_cxx::__atomic_add(addend, 1); }
inline int atomicDecrement(int volatile* addend) { return __gnu_cxx::__exchange_and_add(addend, -1) - 1; }
#endif
class ThreadSafeSharedBase : Noncopyable {
public:
ThreadSafeSharedBase(int initialRefCount = 1)
: m_refCount(initialRefCount)
{
}
void ref()
{
#if USE(LOCKFREE_THREADSAFESHARED)
atomicIncrement(&m_refCount);
#else
MutexLocker locker(m_mutex);
++m_refCount;
#endif
}
bool hasOneRef()
{
return refCount() == 1;
}
int refCount() const
{
#if !USE(LOCKFREE_THREADSAFESHARED)
MutexLocker locker(m_mutex);
#endif
return static_cast<int const volatile &>(m_refCount);
}
protected:
bool derefBase()
{
#if USE(LOCKFREE_THREADSAFESHARED)
if (atomicDecrement(&m_refCount) <= 0)
return true;
#else
int refCount;
{
MutexLocker locker(m_mutex);
--m_refCount;
refCount = m_refCount;
}
if (refCount <= 0)
return true;
#endif
return false;
}
private:
template<class T>
friend class CrossThreadRefCounted;
int m_refCount;
#if !USE(LOCKFREE_THREADSAFESHARED)
mutable Mutex m_mutex;
#endif
};
template<class T> class ThreadSafeShared : public ThreadSafeSharedBase {
public:
ThreadSafeShared(int initialRefCount = 1)
: ThreadSafeSharedBase(initialRefCount)
{
}
void deref()
{
if (derefBase())
delete static_cast<T*>(this);
}
};
void initializeThreading();
void lockAtomicallyInitializedStaticMutex();
void unlockAtomicallyInitializedStaticMutex();
}
using WTF::Mutex;
using WTF::MutexLocker;
using WTF::ThreadCondition;
using WTF::ThreadIdentifier;
using WTF::ThreadSafeShared;
using WTF::createThread;
using WTF::currentThread;
using WTF::isMainThread;
using WTF::detachThread;
using WTF::waitForThreadCompletion;
#endif // Threading_h