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 : public 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 {
DataData81 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>
ThreadSpecific()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>
~ThreadSpecific()110 inline ThreadSpecific<T>::~ThreadSpecific()
111 {
112 pthread_key_delete(m_key); // Does not invoke destructor functions.
113 }
114
115 template<typename T>
get()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>
set(T * ptr)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>
ThreadSpecific()132 inline ThreadSpecific<T>::ThreadSpecific()
133 {
134 }
135
136 template<typename T>
~ThreadSpecific()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>
get()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>
set(T * ptr)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>
ThreadSpecific()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>
~ThreadSpecific()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>
get()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>
set(T * ptr)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>
destroy(void * ptr)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
267