#ifndef Threading_h
#define Threading_h
#include <wtf/Platform.h>
#if PLATFORM(WIN_CE)
#include <windows.h>
#endif
#include <wtf/Assertions.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
#if PLATFORM(WIN_OS) && !PLATFORM(WIN_CE)
#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 USE(PTHREADS) && (PLATFORM(MAC) || PLATFORM(IPHONE))
#ifdef __OBJC__
@class NSThread;
#else
class NSThread;
#endif
#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);
ThreadIdentifier currentThread();
bool isMainThread();
int waitForThreadCompletion(ThreadIdentifier, void**);
void detachThread(ThreadIdentifier);
#if USE(PTHREADS)
typedef pthread_mutex_t PlatformMutex;
typedef pthread_cond_t PlatformCondition;
#elif PLATFORM(GTK)
typedef GOwnPtr<GMutex> PlatformMutex;
typedef GOwnPtr<GCond> PlatformCondition;
#elif PLATFORM(QT)
typedef QT_PREPEND_NAMESPACE(QMutex)* PlatformMutex;
typedef QT_PREPEND_NAMESPACE(QWaitCondition)* PlatformCondition;
#elif PLATFORM(WIN_OS)
struct PlatformMutex {
CRITICAL_SECTION m_internalMutex;
size_t m_recursionCount;
};
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* 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 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(WIN_CE)
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
template<class T> class ThreadSafeShared : Noncopyable {
public:
ThreadSafeShared(int initialRefCount = 1)
: m_refCount(initialRefCount)
{
}
void ref()
{
#if USE(LOCKFREE_THREADSAFESHARED)
atomicIncrement(&m_refCount);
#else
MutexLocker locker(m_mutex);
++m_refCount;
#endif
}
void deref()
{
#if USE(LOCKFREE_THREADSAFESHARED)
if (atomicDecrement(&m_refCount) <= 0)
#else
{
MutexLocker locker(m_mutex);
--m_refCount;
}
if (m_refCount <= 0)
#endif
delete static_cast<T*>(this);
}
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);
}
private:
int m_refCount;
#if !USE(LOCKFREE_THREADSAFESHARED)
mutable Mutex m_mutex;
#endif
};
void initializeThreading();
#if USE(PTHREADS) && (PLATFORM(MAC) || PLATFORM(IPHONE))
void initializeMainNSThread();
NSThread *mainNSThread();
#endif
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