OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 #ifndef BASE_THREADING_THREAD_LOCAL_STORAGE_H_ | 5 #ifndef BASE_THREADING_THREAD_LOCAL_STORAGE_H_ |
6 #define BASE_THREADING_THREAD_LOCAL_STORAGE_H_ | 6 #define BASE_THREADING_THREAD_LOCAL_STORAGE_H_ |
7 | 7 |
8 #include "base/base_export.h" | 8 #include "base/base_export.h" |
9 #include "base/basictypes.h" | 9 #include "base/basictypes.h" |
10 | 10 |
11 #if defined(OS_WIN) | 11 #if defined(OS_POSIX) |
12 #include <windows.h> | |
13 #elif defined(OS_POSIX) | |
14 #include <pthread.h> | 12 #include <pthread.h> |
15 #endif | 13 #endif |
16 | 14 |
17 namespace base { | 15 namespace base { |
18 | 16 |
19 namespace internal { | |
20 | |
21 // WARNING: You should *NOT* be using this class directly. | |
22 // PlatformThreadLocalStorage is low-level abstraction to the OS's TLS | |
23 // interface, you should instead be using ThreadLocalStorage::StaticSlot/Slot. | |
24 class BASE_EXPORT PlatformThreadLocalStorage { | |
25 public: | |
26 | |
27 #if defined(OS_WIN) | |
28 typedef unsigned long TLSKey; | |
29 enum { TLS_KEY_OUT_OF_INDEXES = TLS_OUT_OF_INDEXES }; | |
30 #elif defined(OS_POSIX) | |
31 typedef pthread_key_t TLSKey; | |
32 // The following is a "reserved key" which is used in our generic Chromium | |
33 // ThreadLocalStorage implementation. We expect that an OS will not return | |
34 // such a key, but if it is returned (i.e., the OS tries to allocate it) we | |
35 // will just request another key. | |
36 enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF }; | |
37 #endif | |
38 | |
39 // The following methods need to be supported on each OS platform, so that | |
40 // the Chromium ThreadLocalStore functionality can be constructed. | |
41 // Chromium will use these methods to acquire a single OS slot, and then use | |
42 // that to support a much larger number of Chromium slots (independent of the | |
43 // OS restrictions). | |
44 // The following returns true if it successfully is able to return an OS | |
45 // key in |key|. | |
46 static bool AllocTLS(TLSKey* key); | |
47 // Note: FreeTLS() doesn't have to be called, it is fine with this leak, OS | |
48 // might not reuse released slot, you might just reset the TLS value with | |
49 // SetTLSValue(). | |
50 static void FreeTLS(TLSKey key); | |
51 static void SetTLSValue(TLSKey key, void* value); | |
52 static void* GetTLSValue(TLSKey key); | |
53 | |
54 // Each platform (OS implementation) is required to call this method on each | |
55 // terminating thread when the thread is about to terminate. This method | |
56 // will then call all registered destructors for slots in Chromium | |
57 // ThreadLocalStorage, until there are no slot values remaining as having | |
58 // been set on this thread. | |
59 // Destructors may end up being called multiple times on a terminating | |
60 // thread, as other destructors may re-set slots that were previously | |
61 // destroyed. | |
62 #if defined(OS_WIN) | |
63 // Since Windows which doesn't support TLS destructor, the implementation | |
64 // should use GetTLSValue() to retrieve the value of TLS slot. | |
65 static void OnThreadExit(); | |
66 #elif defined(OS_POSIX) | |
67 // |Value| is the data stored in TLS slot, The implementation can't use | |
68 // GetTLSValue() to retrieve the value of slot as it has already been reset | |
69 // in Posix. | |
70 static void OnThreadExit(void* value); | |
71 #endif | |
72 }; | |
73 | |
74 } // namespace internal | |
75 | |
76 // Wrapper for thread local storage. This class doesn't do much except provide | 17 // Wrapper for thread local storage. This class doesn't do much except provide |
77 // an API for portability. | 18 // an API for portability. |
78 class BASE_EXPORT ThreadLocalStorage { | 19 class BASE_EXPORT ThreadLocalStorage { |
79 public: | 20 public: |
80 | 21 |
81 // Prototype for the TLS destructor function, which can be optionally used to | 22 // Prototype for the TLS destructor function, which can be optionally used to |
82 // cleanup thread local storage on thread exit. 'value' is the data that is | 23 // cleanup thread local storage on thread exit. 'value' is the data that is |
83 // stored in thread local storage. | 24 // stored in thread local storage. |
84 typedef void (*TLSDestructorFunc)(void* value); | 25 typedef void (*TLSDestructorFunc)(void* value); |
85 | 26 |
(...skipping 26 matching lines...) Expand all Loading... |
112 void* Get() const; | 53 void* Get() const; |
113 | 54 |
114 // Set the thread-local value stored in slot 'slot' to | 55 // Set the thread-local value stored in slot 'slot' to |
115 // value 'value'. | 56 // value 'value'. |
116 void Set(void* value); | 57 void Set(void* value); |
117 | 58 |
118 bool initialized() const { return initialized_; } | 59 bool initialized() const { return initialized_; } |
119 | 60 |
120 // The internals of this struct should be considered private. | 61 // The internals of this struct should be considered private. |
121 bool initialized_; | 62 bool initialized_; |
| 63 #if defined(OS_WIN) |
122 int slot_; | 64 int slot_; |
| 65 #elif defined(OS_POSIX) |
| 66 pthread_key_t key_; |
| 67 #endif |
| 68 |
123 }; | 69 }; |
124 | 70 |
125 // A convenience wrapper around StaticSlot with a constructor. Can be used | 71 // A convenience wrapper around StaticSlot with a constructor. Can be used |
126 // as a member variable. | 72 // as a member variable. |
127 class BASE_EXPORT Slot : public StaticSlot { | 73 class BASE_EXPORT Slot : public StaticSlot { |
128 public: | 74 public: |
129 // Calls StaticSlot::Initialize(). | 75 // Calls StaticSlot::Initialize(). |
130 explicit Slot(TLSDestructorFunc destructor = NULL); | 76 explicit Slot(TLSDestructorFunc destructor = NULL); |
131 | 77 |
132 private: | 78 private: |
133 using StaticSlot::initialized_; | 79 using StaticSlot::initialized_; |
| 80 #if defined(OS_WIN) |
134 using StaticSlot::slot_; | 81 using StaticSlot::slot_; |
135 | 82 #elif defined(OS_POSIX) |
| 83 using StaticSlot::key_; |
| 84 #endif |
136 DISALLOW_COPY_AND_ASSIGN(Slot); | 85 DISALLOW_COPY_AND_ASSIGN(Slot); |
137 }; | 86 }; |
138 | 87 |
139 DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage); | 88 DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage); |
140 }; | 89 }; |
141 | 90 |
142 } // namespace base | 91 } // namespace base |
143 | 92 |
144 #endif // BASE_THREADING_THREAD_LOCAL_STORAGE_H_ | 93 #endif // BASE_THREADING_THREAD_LOCAL_STORAGE_H_ |
OLD | NEW |