#ifndef Threading_h
#define Threading_h
#include "Locker.h"
#include <wtf/Assertions.h>
#include <wtf/Noncopyable.h>
#if PLATFORM(WIN_OS)
#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>
#endif
#if PLATFORM(GTK)
typedef struct _GMutex GMutex;
typedef struct _GCond GCond;
#endif
#if PLATFORM(QT)
class QMutex;
class QWaitCondition;
#endif
#include <stdint.h>
namespace WebCore {
typedef uint32_t ThreadIdentifier;
typedef void* (*ThreadFunction)(void* argument);
ThreadIdentifier createThread(ThreadFunction, void*);
ThreadIdentifier currentThread();
int waitForThreadCompletion(ThreadIdentifier, void**);
void detachThread(ThreadIdentifier);
#if USE(PTHREADS)
typedef pthread_mutex_t PlatformMutex;
typedef pthread_cond_t PlatformCondition;
#elif PLATFORM(GTK)
typedef GMutex* PlatformMutex;
typedef GCond* PlatformCondition;
#elif PLATFORM(QT)
typedef QMutex* PlatformMutex;
typedef QWaitCondition* PlatformCondition;
#elif PLATFORM(WIN_OS)
struct PlatformMutex {
CRITICAL_SECTION m_internalMutex;
size_t m_recursionCount;
};
struct PlatformCondition {
size_t m_timedOut;
size_t m_blocked;
size_t m_waitingForRemoval;
HANDLE m_gate;
HANDLE m_queue;
HANDLE m_mutex;
};
#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);
void signal();
void broadcast();
private:
PlatformCondition m_condition;
};
#if PLATFORM(WIN_OS)
#define WTF_USE_LOCKFREE_THREADSAFESHARED 1
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)); }
#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()
: m_refCount(0)
{
}
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
};
typedef void MainThreadFunction(void*);
void callOnMainThread(MainThreadFunction*, void* context);
void initializeThreading();
#if !PLATFORM(WIN) && !PLATFORM(GTK)
inline void initializeThreading()
{
}
#endif
}
#endif // Threading_h