Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1283)

Side by Side Diff: base/threading/thread_local_storage_win.cc

Issue 8702014: Make ThreadLocalStorage more posix pthread compliant (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "base/threading/thread_local_storage.h" 5 #include "base/threading/thread_local_storage.h"
6 6
7 #include <windows.h> 7 #include <windows.h>
8 8
9 #include "base/logging.h" 9 #include "base/logging.h"
10 10
(...skipping 11 matching lines...) Expand all
22 long ThreadLocalStorage::tls_key_ = TLS_OUT_OF_INDEXES; 22 long ThreadLocalStorage::tls_key_ = TLS_OUT_OF_INDEXES;
23 23
24 // tls_max_ is the high-water-mark of allocated thread local storage. 24 // tls_max_ is the high-water-mark of allocated thread local storage.
25 // We intentionally skip 0 so that it is not confused with an 25 // We intentionally skip 0 so that it is not confused with an
26 // unallocated TLS slot. 26 // unallocated TLS slot.
27 long ThreadLocalStorage::tls_max_ = 1; 27 long ThreadLocalStorage::tls_max_ = 1;
28 28
29 // An array of destructor function pointers for the slots. If 29 // An array of destructor function pointers for the slots. If
30 // a slot has a destructor, it will be stored in its corresponding 30 // a slot has a destructor, it will be stored in its corresponding
31 // entry in this array. 31 // entry in this array.
32 ThreadLocalStorage::TLSDestructorFunc 32 subtle::AtomicWord
33 ThreadLocalStorage::tls_destructors_[kThreadLocalStorageSize]; 33 ThreadLocalStorage::tls_destructors_[kThreadLocalStorageSize];
34 34
35 void** ThreadLocalStorage::Initialize() { 35 void** ThreadLocalStorage::Initialize() {
36 if (tls_key_ == TLS_OUT_OF_INDEXES) { 36 if (tls_key_ == TLS_OUT_OF_INDEXES) {
37 long value = TlsAlloc(); 37 long value = TlsAlloc();
38 DCHECK(value != TLS_OUT_OF_INDEXES); 38 DCHECK(value != TLS_OUT_OF_INDEXES);
39 39
40 // Atomically test-and-set the tls_key. If the key is TLS_OUT_OF_INDEXES, 40 // Atomically test-and-set the tls_key. If the key is TLS_OUT_OF_INDEXES,
41 // go ahead and set it. Otherwise, do nothing, as another 41 // go ahead and set it. Otherwise, do nothing, as another
42 // thread already did our dirty work. 42 // thread already did our dirty work.
43 if (InterlockedCompareExchange(&tls_key_, value, TLS_OUT_OF_INDEXES) != 43 if (InterlockedCompareExchange(&tls_key_, value, TLS_OUT_OF_INDEXES) !=
44 TLS_OUT_OF_INDEXES) { 44 TLS_OUT_OF_INDEXES) {
45 // We've been shortcut. Another thread replaced tls_key_ first so we need 45 // We've been shortcut. Another thread replaced tls_key_ first so we need
46 // to destroy our index and use the one the other thread got first. 46 // to destroy our index and use the one the other thread got first.
47 TlsFree(value); 47 TlsFree(value);
48 } 48 }
49 } 49 }
50 DCHECK(!TlsGetValue(tls_key_)); 50 DCHECK(!TlsGetValue(tls_key_));
51 51
52 // Create an array to store our data. 52 // Some allocators, such as TCMalloc, make use of thread local storage.
53 // As a result, any attempt to call new (or malloc) will lazilly cause such a
willchan no longer on Chromium 2011/11/29 01:46:49 s/lazilly/lazily/g
jar (doing other things) 2011/11/29 02:32:45 Done.
54 // system to initialize, which will include registering for a TLS key. If we
55 // are not careful here, then that request to create a key will call new back,
56 // and we'll have an infinite loop. We avoid that as follows:
57 // Use use a stack allocated vector, so that we don't have dependence
willchan no longer on Chromium 2011/11/29 01:46:49 s/Use use/Use/g
jar (doing other things) 2011/11/29 02:32:45 Done.
58 // on our allocator until our service is in place. (i.e., don't
59 // even call new until after we're setup)
60 void* stack_allocated_tls_data[kThreadLocalStorageSize];
61 memset(stack_allocated_tls_data, 0, sizeof(stack_allocated_tls_data));
willchan no longer on Chromium 2011/11/29 01:46:49 s/sizeof/arraysize/
jar (doing other things) 2011/11/29 02:32:45 I think I want the size of the array. Array size
62 // Ensure that any rentrant calls change the temp version.
willchan no longer on Chromium 2011/11/29 01:46:49 re-entrant
jar (doing other things) 2011/11/29 02:32:45 Done.
63 TlsSetValue(tls_key_, stack_allocated_tls_data);
64
65 // Allocate an array to store our data.
53 void** tls_data = new void*[kThreadLocalStorageSize]; 66 void** tls_data = new void*[kThreadLocalStorageSize];
54 memset(tls_data, 0, sizeof(void*[kThreadLocalStorageSize])); 67 memcpy(tls_data, stack_allocated_tls_data, sizeof(stack_allocated_tls_data));
willchan no longer on Chromium 2011/11/29 01:46:49 s/sizeof/arraysize/
jar (doing other things) 2011/11/29 02:32:45 Again... I think I have the right form.
willchan no longer on Chromium 2011/11/29 02:47:04 Oops, you're right. Ignore me.
55 TlsSetValue(tls_key_, tls_data); 68 TlsSetValue(tls_key_, tls_data);
56 return tls_data; 69 return tls_data;
57 } 70 }
58 71
59 ThreadLocalStorage::Slot::Slot(TLSDestructorFunc destructor) 72 ThreadLocalStorage::Slot::Slot(TLSDestructorFunc destructor)
60 : initialized_(false), 73 : initialized_(false),
61 slot_(0) { 74 slot_(0) {
62 Initialize(destructor); 75 Initialize(destructor);
63 } 76 }
64 77
65 bool ThreadLocalStorage::Slot::Initialize(TLSDestructorFunc destructor) { 78 bool ThreadLocalStorage::Slot::Initialize(TLSDestructorFunc destructor) {
66 if (tls_key_ == TLS_OUT_OF_INDEXES || !TlsGetValue(tls_key_)) 79 if (tls_key_ == TLS_OUT_OF_INDEXES || !TlsGetValue(tls_key_))
67 ThreadLocalStorage::Initialize(); 80 ThreadLocalStorage::Initialize();
68 81
69 // Grab a new slot. 82 // Grab a new slot.
70 slot_ = InterlockedIncrement(&tls_max_) - 1; 83 slot_ = InterlockedIncrement(&tls_max_) - 1;
84 DCHECK_GT(slot_, 0);
71 if (slot_ >= kThreadLocalStorageSize) { 85 if (slot_ >= kThreadLocalStorageSize) {
72 NOTREACHED(); 86 NOTREACHED();
73 return false; 87 return false;
74 } 88 }
75 89
76 // Setup our destructor. 90 // Setup our destructor. Make sure that any thread that is dostroyed can see
rvargas (doing something else) 2011/11/29 01:26:31 nit: typo
jar (doing other things) 2011/11/29 02:32:45 Done.
77 tls_destructors_[slot_] = destructor; 91 // this new setting.
92 subtle::NoBarrier_Store(&tls_destructors_[slot_],
rvargas (doing something else) 2011/11/29 01:26:31 Isn't it more readable to do a regular assignment?
jar (doing other things) 2011/11/29 02:32:45 Yeah... but I think it is a bit wrong. Perhaps if
rvargas (doing something else) 2011/11/29 02:46:46 The way I'm reading this code (I may be wrong) is
93 reinterpret_cast<subtle::AtomicWord>(destructor));
78 initialized_ = true; 94 initialized_ = true;
79 return true; 95 return true;
80 } 96 }
81 97
82 void ThreadLocalStorage::Slot::Free() { 98 void ThreadLocalStorage::Slot::Free() {
83 // At this time, we don't reclaim old indices for TLS slots. 99 // At this time, we don't reclaim old indices for TLS slots.
84 // So all we need to do is wipe the destructor. 100 // So all we need to do is wipe the destructor.
85 tls_destructors_[slot_] = NULL; 101 DCHECK_GT(slot_, 0);
102 DCHECK_LT(slot_, kThreadLocalStorageSize);
103 subtle::NoBarrier_Store(&tls_destructors_[slot_], NULL);
104 slot_ = 0;
86 initialized_ = false; 105 initialized_ = false;
87 } 106 }
88 107
89 void* ThreadLocalStorage::Slot::Get() const { 108 void* ThreadLocalStorage::Slot::Get() const {
90 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_)); 109 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_));
91 if (!tls_data) 110 if (!tls_data)
92 tls_data = ThreadLocalStorage::Initialize(); 111 tls_data = ThreadLocalStorage::Initialize();
93 DCHECK_GE(slot_, 0); 112 DCHECK_GT(slot_, 0);
94 DCHECK_LT(slot_, kThreadLocalStorageSize); 113 DCHECK_LT(slot_, kThreadLocalStorageSize);
95 return tls_data[slot_]; 114 return tls_data[slot_];
96 } 115 }
97 116
98 void ThreadLocalStorage::Slot::Set(void* value) { 117 void ThreadLocalStorage::Slot::Set(void* value) {
99 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_)); 118 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_));
100 if (!tls_data) 119 if (!tls_data)
101 tls_data = ThreadLocalStorage::Initialize(); 120 tls_data = ThreadLocalStorage::Initialize();
102 DCHECK_GE(slot_, 0); 121 DCHECK_GT(slot_, 0);
103 DCHECK_LT(slot_, kThreadLocalStorageSize); 122 DCHECK_LT(slot_, kThreadLocalStorageSize);
104 tls_data[slot_] = value; 123 tls_data[slot_] = value;
105 } 124 }
106 125
107 void ThreadLocalStorage::ThreadExit() { 126 void ThreadLocalStorage::ThreadExit() {
108 if (tls_key_ == TLS_OUT_OF_INDEXES) 127 if (tls_key_ == TLS_OUT_OF_INDEXES)
109 return; 128 return;
110 129
111 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_)); 130 void** tls_data = static_cast<void**>(TlsGetValue(tls_key_));
112
113 // Maybe we have never initialized TLS for this thread. 131 // Maybe we have never initialized TLS for this thread.
114 if (!tls_data) 132 if (!tls_data)
115 return; 133 return;
116 134
117 for (int slot = 0; slot < tls_max_; slot++) { 135 // Some allocators, such as TCMalloc, use TLS. As a result, when a thread
118 if (tls_destructors_[slot] != NULL) { 136 // terminates, one of the destructor calls we make may be to shut down an
119 void* value = tls_data[slot]; 137 // allocator. We have to be careful that after we've shutdown all of the
120 tls_destructors_[slot](value); 138 // known destructors (perchance including an allocator), that we don't call
139 // the allocator and cause it to resurrect itself (with no possibly destructor
140 // call to follow). We handle this problem as follows:
141 // Switch to using a stack allocated vector, so that we don't have dependence
142 // on our allocator after we have called all tls_destructors_. (i.e., don't
143 // even call delete[] after we're done with destructors.)
144 void* stack_allocated_tls_data[kThreadLocalStorageSize];
145 memcpy(stack_allocated_tls_data, tls_data, sizeof(stack_allocated_tls_data));
146 // Ensure that any rentrant calls change the temp version.
147 TlsSetValue(tls_key_, stack_allocated_tls_data);
148 delete[] tls_data; // Our last dependence on an allocator.
149
150 int remaining_attempts = PTHREAD_DESTRUCTOR_ITERATIONS;
151 bool need_to_scan_destructors = true;
152 while (need_to_scan_destructors) {
153 need_to_scan_destructors = false;
154 // Try to destroy the first-created-slot (which is slot 1) in our last
155 // destructor call. That user was able to function, and define a slot with
156 // no other services running, so perhaps it is a basic service (like an
157 // allocator) and should also be destroyed last.
158 for (int slot = tls_max_ - 1; slot > 0; --slot) {
159 void* value = stack_allocated_tls_data[slot];
160 if (value == NULL)
161 continue;
162 TLSDestructorFunc destructor =
163 reinterpret_cast<ThreadLocalStorage::TLSDestructorFunc>(
164 subtle::NoBarrier_Load(&tls_destructors_[slot]));
165 if (destructor == NULL)
166 continue;
167 stack_allocated_tls_data[slot] = NULL; // pre-clear the slot.
168 destructor(value);
169 // Any destructor might have called a different service, which then set
170 // a different slot to a non-NULL value. Hence we need to check
171 // the whole vector again. This is a pthread standard.
172 need_to_scan_destructors = true;
173 }
174 if (--remaining_attempts <= 0) {
175 NOTREACHED(); // Destructors might not have been called.
176 break;
121 } 177 }
122 } 178 }
123 179
124 delete[] tls_data; 180 // Remove our stack allocated vector.
125
126 // In case there are other "onexit" handlers...
127 TlsSetValue(tls_key_, NULL); 181 TlsSetValue(tls_key_, NULL);
128 } 182 }
129 183
130 } // namespace base 184 } // namespace base
131 185
132 // Thread Termination Callbacks. 186 // Thread Termination Callbacks.
133 // Windows doesn't support a per-thread destructor with its 187 // Windows doesn't support a per-thread destructor with its
134 // TLS primitives. So, we build it manually by inserting a 188 // TLS primitives. So, we build it manually by inserting a
135 // function to be called on each thread's exit. 189 // function to be called on each thread's exit.
136 // This magic is from http://www.codeproject.com/threads/tls.asp 190 // This magic is from http://www.codeproject.com/threads/tls.asp
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
192 #else // _WIN64 246 #else // _WIN64
193 247
194 #pragma data_seg(".CRT$XLB") 248 #pragma data_seg(".CRT$XLB")
195 PIMAGE_TLS_CALLBACK p_thread_callback_base = OnThreadExit; 249 PIMAGE_TLS_CALLBACK p_thread_callback_base = OnThreadExit;
196 250
197 // Reset the default section. 251 // Reset the default section.
198 #pragma data_seg() 252 #pragma data_seg()
199 253
200 #endif // _WIN64 254 #endif // _WIN64
201 } // extern "C" 255 } // extern "C"
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698