#ifndef Threading_h
#define Threading_h
#include "Platform.h"
#if OS(WINCE)
#include <windows.h>
#endif
#include <wtf/Assertions.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
#if OS(WINDOWS) && !OS(WINCE)
#include <windows.h>
#elif OS(DARWIN)
#include <libkern/OSAtomic.h>
#elif OS(ANDROID)
#include <cutils/atomic.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/gtk/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 initializeCurrentThreadInternal(const char* threadName);
ThreadIdentifier currentThread();
bool isMainThread();
int waitForThreadCompletion(ThreadIdentifier, void**);
void detachThread(ThreadIdentifier);
#if USE(PTHREADS)
typedef pthread_mutex_t PlatformMutex;
#if HAVE(PTHREAD_RWLOCK)
typedef pthread_rwlock_t PlatformReadWriteLock;
#else
typedef void* PlatformReadWriteLock;
#endif
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 OS(WINDOWS)
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 : public 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 : public Noncopyable {
public:
ReadWriteLock();
~ReadWriteLock();
void readLock();
bool tryReadLock();
void writeLock();
bool tryWriteLock();
void unlock();
private:
PlatformReadWriteLock m_readWriteLock;
};
class ThreadCondition : public Noncopyable {
public:
ThreadCondition();
~ThreadCondition();
void wait(Mutex& mutex);
bool timedWait(Mutex&, double absoluteTime);
void signal();
void broadcast();
private:
PlatformCondition m_condition;
};
#if OS(WINDOWS)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
#if COMPILER(MINGW) || COMPILER(MSVC7) || OS(WINCE)
inline int atomicIncrement(int* addend) { return InterlockedIncrement(reinterpret_cast<long*>(addend)); }
inline int atomicDecrement(int* addend) { return InterlockedDecrement(reinterpret_cast<long*>(addend)); }
#else
inline int atomicIncrement(int volatile* addend) { return InterlockedIncrement(reinterpret_cast<long volatile*>(addend)); }
inline int atomicDecrement(int volatile* addend) { return InterlockedDecrement(reinterpret_cast<long volatile*>(addend)); }
#endif
#elif OS(DARWIN)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
inline int atomicIncrement(int volatile* addend) { return OSAtomicIncrement32Barrier(const_cast<int*>(addend)); }
inline int atomicDecrement(int volatile* addend) { return OSAtomicDecrement32Barrier(const_cast<int*>(addend)); }
#elif OS(ANDROID)
inline int atomicIncrement(int volatile* addend) { return android_atomic_inc(addend); }
inline int atomicDecrement(int volatile* addend) { return android_atomic_dec(addend); }
#elif COMPILER(GCC) && !CPU(SPARC64) // sizeof(_Atomic_word) != sizeof(int) on sparc64 gcc
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
inline int atomicIncrement(int volatile* addend) { return __gnu_cxx::__exchange_and_add(addend, 1) + 1; }
inline int atomicDecrement(int volatile* addend) { return __gnu_cxx::__exchange_and_add(addend, -1) - 1; }
#endif
class ThreadSafeSharedBase : public 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;
#if USE(LOCKFREE_THREADSAFESHARED)
using WTF::atomicDecrement;
using WTF::atomicIncrement;
#endif
using WTF::createThread;
using WTF::currentThread;
using WTF::isMainThread;
using WTF::detachThread;
using WTF::waitForThreadCompletion;
#endif // Threading_h