wtf/ThreadSpecific.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /* Thread local storage is implemented by using either pthread API or Windows
  31  * native API. There is subtle semantic discrepancy for the cleanup function
  32  * implementation as noted below:
  33  *   @ In pthread implementation, the destructor function will be called
  34  *     repeatedly if there is still non-NULL value associated with the function.
  35  *   @ In Windows native implementation, the destructor function will be called
  36  *     only once.
  37  * This semantic discrepancy does not impose any problem because nowhere in
  38  * WebKit the repeated call bahavior is utilized.
  39  */
  40
  41 #ifndef WTF_ThreadSpecific_h
  42 #define WTF_ThreadSpecific_h
  43
  44 #include <wtf/Noncopyable.h>
  45
  46 #if USE(PTHREADS)
  47 #include <pthread.h>
  48 #elif PLATFORM(QT)
  49 #include <QThreadStorage>
  50 #elif PLATFORM(WIN_OS)
  51 #include <windows.h>
  52 #endif
  53
  54 namespace WTF {
  55
  56 #if !USE(PTHREADS) && !PLATFORM(QT) && PLATFORM(WIN_OS)
  57 // ThreadSpecificThreadExit should be called each time when a thread is detached.
  58 // This is done automatically for threads created with WTF::createThread.
  59 void ThreadSpecificThreadExit();
  60 #endif
  61
  62 template<typename T> class ThreadSpecific : Noncopyable {
  63 public:
  64     ThreadSpecific();
  65     T* operator->();
  66     operator T*();
  67     T& operator*();
  68     ~ThreadSpecific();
  69
  70 private:
  71 #if !USE(PTHREADS) && !PLATFORM(QT) && PLATFORM(WIN_OS)
  72     friend void ThreadSpecificThreadExit();
  73 #endif
  74
  75     T* get();
  76     void set(T*);
  77     void static destroy(void* ptr);
  78
  79 #if USE(PTHREADS) || PLATFORM(QT) || PLATFORM(WIN_OS)
  80     struct Data : Noncopyable {
  81         Data(T* value, ThreadSpecific<T>* owner) : value(value), owner(owner) {}
  82
  83         T* value;
  84         ThreadSpecific<T>* owner;
  85 #if !USE(PTHREADS)
  86         void (*destructor)(void*);
  87 #endif
  88     };
  89 #endif
  90
  91 #if USE(PTHREADS)
  92     pthread_key_t m_key;
  93 #elif PLATFORM(QT)
  94     QThreadStorage<Data*> m_key;
  95 #elif PLATFORM(WIN_OS)
  96     int m_index;
  97 #endif
  98 };
  99
 100 #if USE(PTHREADS)
 101 template<typename T>
 102 inline ThreadSpecific<T>::ThreadSpecific()
 103 {
 104     int error = pthread_key_create(&m_key, destroy);
 105     if (error)
 106         CRASH();
 107 }
 108
 109 template<typename T>
 110 inline ThreadSpecific<T>::~ThreadSpecific()
 111 {
 112     pthread_key_delete(m_key); // Does not invoke destructor functions.
 113 }
 114
 115 template<typename T>
 116 inline T* ThreadSpecific<T>::get()
 117 {
 118     Data* data = static_cast<Data*>(pthread_getspecific(m_key));
 119     return data ? data->value : 0;
 120 }
 121
 122 template<typename T>
 123 inline void ThreadSpecific<T>::set(T* ptr)
 124 {
 125     ASSERT(!get());
 126     pthread_setspecific(m_key, new Data(ptr, this));
 127 }
 128
 129 #elif PLATFORM(QT)
 130
 131 template<typename T>
 132 inline ThreadSpecific<T>::ThreadSpecific()
 133 {
 134 }
 135
 136 template<typename T>
 137 inline ThreadSpecific<T>::~ThreadSpecific()
 138 {
 139     Data* data = static_cast<Data*>(m_key.localData());
 140     if (data)
 141         data->destructor(data);
 142 }
 143
 144 template<typename T>
 145 inline T* ThreadSpecific<T>::get()
 146 {
 147     Data* data = static_cast<Data*>(m_key.localData());
 148     return data ? data->value : 0;
 149 }
 150
 151 template<typename T>
 152 inline void ThreadSpecific<T>::set(T* ptr)
 153 {
 154     ASSERT(!get());
 155     Data* data = new Data(ptr, this);
 156     data->destructor = &ThreadSpecific<T>::destroy;
 157     m_key.setLocalData(data);
 158 }
 159
 160 #elif PLATFORM(WIN_OS)
 161
 162 // The maximum number of TLS keys that can be created. For simplification, we assume that:
 163 // 1) Once the instance of ThreadSpecific<> is created, it will not be destructed until the program dies.
 164 // 2) We do not need to hold many instances of ThreadSpecific<> data. This fixed number should be far enough.
 165 const int kMaxTlsKeySize = 256;
 166
 167 long& tlsKeyCount();
 168 DWORD* tlsKeys();
 169
 170 template<typename T>
 171 inline ThreadSpecific<T>::ThreadSpecific()
 172     : m_index(-1)
 173 {
 174     DWORD tls_key = TlsAlloc();
 175     if (tls_key == TLS_OUT_OF_INDEXES)
 176         CRASH();
 177
 178     m_index = InterlockedIncrement(&tlsKeyCount()) - 1;
 179     if (m_index >= kMaxTlsKeySize)
 180         CRASH();
 181     tlsKeys()[m_index] = tls_key;
 182 }
 183
 184 template<typename T>
 185 inline ThreadSpecific<T>::~ThreadSpecific()
 186 {
 187     // Does not invoke destructor functions. They will be called from ThreadSpecificThreadExit when the thread is detached.
 188     TlsFree(tlsKeys()[m_index]);
 189 }
 190
 191 template<typename T>
 192 inline T* ThreadSpecific<T>::get()
 193 {
 194     Data* data = static_cast<Data*>(TlsGetValue(tlsKeys()[m_index]));
 195     return data ? data->value : 0;
 196 }
 197
 198 template<typename T>
 199 inline void ThreadSpecific<T>::set(T* ptr)
 200 {
 201     ASSERT(!get());
 202     Data* data = new Data(ptr, this);
 203     data->destructor = &ThreadSpecific<T>::destroy;
 204     TlsSetValue(tlsKeys()[m_index], data);
 205 }
 206
 207 #else
 208 #error ThreadSpecific is not implemented for this platform.
 209 #endif
 210
 211 template<typename T>
 212 inline void ThreadSpecific<T>::destroy(void* ptr)
 213 {
 214     Data* data = static_cast<Data*>(ptr);
 215
 216 #if USE(PTHREADS)
 217     // We want get() to keep working while data destructor works, because it can be called indirectly by the destructor.
 218     // Some pthreads implementations zero out the pointer before calling destroy(), so we temporarily reset it.
 219     pthread_setspecific(data->owner->m_key, ptr);
 220 #endif
 221
 222     data->value->~T();
 223     fastFree(data->value);
 224
 225 #if USE(PTHREADS)
 226     pthread_setspecific(data->owner->m_key, 0);
 227 #elif PLATFORM(QT)
 228     data->owner->m_key.setLocalData(0);
 229 #elif PLATFORM(WIN_OS)
 230     TlsSetValue(tlsKeys()[data->owner->m_index], 0);
 231 #else
 232 #error ThreadSpecific is not implemented for this platform.
 233 #endif
 234
 235     delete data;
 236 }
 237
 238 template<typename T>
 239 inline ThreadSpecific<T>::operator T*()
 240 {
 241     T* ptr = static_cast<T*>(get());
 242     if (!ptr) {
 243         // Set up thread-specific value's memory pointer before invoking constructor, in case any function it calls
 244         // needs to access the value, to avoid recursion.
 245         ptr = static_cast<T*>(fastMalloc(sizeof(T)));
 246         set(ptr);
 247         new (ptr) T;
 248     }
 249     return ptr;
 250 }
 251
 252 template<typename T>
 253 inline T* ThreadSpecific<T>::operator->()
 254 {
 255     return operator T*();
 256 }
 257
 258 template<typename T>
 259 inline T& ThreadSpecific<T>::operator*()
 260 {
 261     return *operator T*();
 262 }
 263
 264 }
 265
 266 #endif