#ifndef WTF_ThreadSpecific_h
#define WTF_ThreadSpecific_h
#include <wtf/Noncopyable.h>
#include <wtf/StdLibExtras.h>
#if USE(PTHREADS)
#include <pthread.h>
#elif OS(WINDOWS)
#include <windows.h>
#endif
namespace WTF {
#if OS(WINDOWS) && CPU(X86)
#define THREAD_SPECIFIC_CALL __stdcall
#else
#define THREAD_SPECIFIC_CALL
#endif
template<typename T> class ThreadSpecific {
WTF_MAKE_NONCOPYABLE(ThreadSpecific);
public:
ThreadSpecific();
bool isSet(); T* operator->();
operator T*();
T& operator*();
#if USE(WEB_THREAD)
void replace(T*);
#endif
private:
~ThreadSpecific();
T* get();
void set(T*);
void static THREAD_SPECIFIC_CALL destroy(void* ptr);
struct Data {
WTF_MAKE_NONCOPYABLE(Data);
public:
Data(T* value, ThreadSpecific<T>* owner) : value(value), owner(owner) {}
T* value;
ThreadSpecific<T>* owner;
};
#if USE(PTHREADS)
pthread_key_t m_key;
#elif OS(WINDOWS)
int m_index;
#endif
};
#if USE(PTHREADS)
typedef pthread_key_t ThreadSpecificKey;
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);
}
template<typename T>
inline ThreadSpecific<T>::ThreadSpecific()
{
int error = pthread_key_create(&m_key, destroy);
if (error)
CRASH();
}
template<typename T>
inline T* ThreadSpecific<T>::get()
{
Data* data = static_cast<Data*>(pthread_getspecific(m_key));
return data ? data->value : 0;
}
template<typename T>
inline void ThreadSpecific<T>::set(T* ptr)
{
ASSERT(!get());
pthread_setspecific(m_key, new Data(ptr, this));
}
#elif OS(WINDOWS)
const int kMaxFlsKeySize = 128;
WTF_EXPORT_PRIVATE long& flsKeyCount();
WTF_EXPORT_PRIVATE DWORD* flsKeys();
typedef DWORD ThreadSpecificKey;
inline void threadSpecificKeyCreate(ThreadSpecificKey* key, void (THREAD_SPECIFIC_CALL *destructor)(void *))
{
DWORD flsKey = FlsAlloc(destructor);
if (flsKey == FLS_OUT_OF_INDEXES)
CRASH();
*key = flsKey;
}
inline void threadSpecificKeyDelete(ThreadSpecificKey key)
{
FlsFree(key);
}
inline void threadSpecificSet(ThreadSpecificKey key, void* data)
{
FlsSetValue(key, data);
}
inline void* threadSpecificGet(ThreadSpecificKey key)
{
return FlsGetValue(key);
}
template<typename T>
inline ThreadSpecific<T>::ThreadSpecific()
: m_index(-1)
{
DWORD flsKey = FlsAlloc(destroy);
if (flsKey == FLS_OUT_OF_INDEXES)
CRASH();
m_index = InterlockedIncrement(&flsKeyCount()) - 1;
if (m_index >= kMaxFlsKeySize)
CRASH();
flsKeys()[m_index] = flsKey;
}
template<typename T>
inline ThreadSpecific<T>::~ThreadSpecific()
{
FlsFree(flsKeys()[m_index]);
}
template<typename T>
inline T* ThreadSpecific<T>::get()
{
Data* data = static_cast<Data*>(FlsGetValue(flsKeys()[m_index]));
return data ? data->value : 0;
}
template<typename T>
inline void ThreadSpecific<T>::set(T* ptr)
{
ASSERT(!get());
Data* data = new Data(ptr, this);
FlsSetValue(flsKeys()[m_index], data);
}
#else
#error ThreadSpecific is not implemented for this platform.
#endif
template<typename T>
inline void THREAD_SPECIFIC_CALL ThreadSpecific<T>::destroy(void* ptr)
{
Data* data = static_cast<Data*>(ptr);
#if USE(PTHREADS)
pthread_setspecific(data->owner->m_key, ptr);
#endif
data->value->~T();
fastFree(data->value);
#if USE(PTHREADS)
pthread_setspecific(data->owner->m_key, 0);
#elif OS(WINDOWS)
FlsSetValue(flsKeys()[data->owner->m_index], 0);
#else
#error ThreadSpecific is not implemented for this platform.
#endif
delete data;
}
template<typename T>
inline bool ThreadSpecific<T>::isSet()
{
return !!get();
}
template<typename T>
inline ThreadSpecific<T>::operator T*()
{
T* ptr = static_cast<T*>(get());
if (!ptr) {
ptr = static_cast<T*>(fastZeroedMalloc(sizeof(T)));
set(ptr);
new (NotNull, ptr) T;
}
return ptr;
}
template<typename T>
inline T* ThreadSpecific<T>::operator->()
{
return operator T*();
}
template<typename T>
inline T& ThreadSpecific<T>::operator*()
{
return *operator T*();
}
#if USE(WEB_THREAD)
template<typename T>
inline void ThreadSpecific<T>::replace(T* newPtr)
{
ASSERT(newPtr);
Data* data = static_cast<Data*>(pthread_getspecific(m_key));
ASSERT(data);
data->value->~T();
fastFree(data->value);
data->value = newPtr;
}
#endif
}
#endif // WTF_ThreadSpecific_h