ThreadingPrimitives.h [plain text]
#pragma once
#include <limits.h>
#include <wtf/FastMalloc.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
#include <wtf/WallTime.h>
#if OS(WINDOWS)
#include <windows.h>
#endif
#if USE(PTHREADS)
#include <pthread.h>
#if !defined(PTHREAD_KEYS_MAX)
#define PTHREAD_KEYS_MAX 1024
#endif
#endif
namespace WTF {
using ThreadFunction = void (*)(void* argument);
#if USE(PTHREADS)
using PlatformThreadHandle = pthread_t;
using PlatformMutex = pthread_mutex_t;
using PlatformCondition = pthread_cond_t;
using ThreadSpecificKey = pthread_key_t;
#if OS(LINUX)
using ThreadIdentifier = pid_t;
#endif
#elif OS(WINDOWS)
using ThreadIdentifier = uint32_t;
using PlatformThreadHandle = HANDLE;
using PlatformMutex = SRWLOCK;
using PlatformCondition = CONDITION_VARIABLE;
using ThreadSpecificKey = DWORD;
#else
#error "Not supported platform"
#endif
class Mutex final {
WTF_MAKE_NONCOPYABLE(Mutex);
WTF_MAKE_FAST_ALLOCATED;
public:
constexpr Mutex() = default;
WTF_EXPORT_PRIVATE ~Mutex();
WTF_EXPORT_PRIVATE void lock();
WTF_EXPORT_PRIVATE bool tryLock();
WTF_EXPORT_PRIVATE void unlock();
PlatformMutex& impl() { return m_mutex; }
private:
#if USE(PTHREADS)
PlatformMutex m_mutex = PTHREAD_MUTEX_INITIALIZER;
#elif OS(WINDOWS)
PlatformMutex m_mutex = SRWLOCK_INIT;
#endif
};
typedef Locker<Mutex> MutexLocker;
class ThreadCondition final {
WTF_MAKE_NONCOPYABLE(ThreadCondition);
WTF_MAKE_FAST_ALLOCATED;
public:
constexpr ThreadCondition() = default;
WTF_EXPORT_PRIVATE ~ThreadCondition();
WTF_EXPORT_PRIVATE void wait(Mutex& mutex);
WTF_EXPORT_PRIVATE bool timedWait(Mutex&, WallTime absoluteTime);
WTF_EXPORT_PRIVATE void signal();
WTF_EXPORT_PRIVATE void broadcast();
private:
#if USE(PTHREADS)
PlatformCondition m_condition = PTHREAD_COND_INITIALIZER;
#elif OS(WINDOWS)
PlatformCondition m_condition = CONDITION_VARIABLE_INIT;
#endif
};
#if USE(PTHREADS)
static constexpr ThreadSpecificKey InvalidThreadSpecificKey = PTHREAD_KEYS_MAX;
inline void threadSpecificKeyCreate(ThreadSpecificKey* key, void (*destructor)(void *))
{
int error = pthread_key_create(key, destructor);
if (error)
CRASH();
}
inline void threadSpecificKeyDelete(ThreadSpecificKey key)
{
int error = pthread_key_delete(key);
if (error)
CRASH();
}
inline void threadSpecificSet(ThreadSpecificKey key, void* value)
{
pthread_setspecific(key, value);
}
inline void* threadSpecificGet(ThreadSpecificKey key)
{
return pthread_getspecific(key);
}
#endif
}
using WTF::Mutex;
using WTF::MutexLocker;
using WTF::ThreadCondition;