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_POSIX) | 11 #if defined(OS_WIN) |
| 12 #include <windows.h> |
| 13 #elif defined(OS_POSIX) |
12 #include <pthread.h> | 14 #include <pthread.h> |
13 #endif | 15 #endif |
14 | 16 |
15 namespace base { | 17 namespace base { |
16 | 18 |
| 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 |
17 // Wrapper for thread local storage. This class doesn't do much except provide | 76 // Wrapper for thread local storage. This class doesn't do much except provide |
18 // an API for portability. | 77 // an API for portability. |
19 class BASE_EXPORT ThreadLocalStorage { | 78 class BASE_EXPORT ThreadLocalStorage { |
20 public: | 79 public: |
21 | 80 |
22 // Prototype for the TLS destructor function, which can be optionally used to | 81 // Prototype for the TLS destructor function, which can be optionally used to |
23 // cleanup thread local storage on thread exit. 'value' is the data that is | 82 // cleanup thread local storage on thread exit. 'value' is the data that is |
24 // stored in thread local storage. | 83 // stored in thread local storage. |
25 typedef void (*TLSDestructorFunc)(void* value); | 84 typedef void (*TLSDestructorFunc)(void* value); |
26 | 85 |
(...skipping 26 matching lines...) Expand all Loading... |
53 void* Get() const; | 112 void* Get() const; |
54 | 113 |
55 // Set the thread-local value stored in slot 'slot' to | 114 // Set the thread-local value stored in slot 'slot' to |
56 // value 'value'. | 115 // value 'value'. |
57 void Set(void* value); | 116 void Set(void* value); |
58 | 117 |
59 bool initialized() const { return initialized_; } | 118 bool initialized() const { return initialized_; } |
60 | 119 |
61 // The internals of this struct should be considered private. | 120 // The internals of this struct should be considered private. |
62 bool initialized_; | 121 bool initialized_; |
63 #if defined(OS_WIN) | |
64 int slot_; | 122 int slot_; |
65 #elif defined(OS_POSIX) | |
66 pthread_key_t key_; | |
67 #endif | |
68 | |
69 }; | 123 }; |
70 | 124 |
71 // A convenience wrapper around StaticSlot with a constructor. Can be used | 125 // A convenience wrapper around StaticSlot with a constructor. Can be used |
72 // as a member variable. | 126 // as a member variable. |
73 class BASE_EXPORT Slot : public StaticSlot { | 127 class BASE_EXPORT Slot : public StaticSlot { |
74 public: | 128 public: |
75 // Calls StaticSlot::Initialize(). | 129 // Calls StaticSlot::Initialize(). |
76 explicit Slot(TLSDestructorFunc destructor = NULL); | 130 explicit Slot(TLSDestructorFunc destructor = NULL); |
77 | 131 |
78 private: | 132 private: |
79 using StaticSlot::initialized_; | 133 using StaticSlot::initialized_; |
80 #if defined(OS_WIN) | |
81 using StaticSlot::slot_; | 134 using StaticSlot::slot_; |
82 #elif defined(OS_POSIX) | 135 |
83 using StaticSlot::key_; | |
84 #endif | |
85 DISALLOW_COPY_AND_ASSIGN(Slot); | 136 DISALLOW_COPY_AND_ASSIGN(Slot); |
86 }; | 137 }; |
87 | 138 |
88 DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage); | 139 DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage); |
89 }; | 140 }; |
90 | 141 |
91 } // namespace base | 142 } // namespace base |
92 | 143 |
93 #endif // BASE_THREADING_THREAD_LOCAL_STORAGE_H_ | 144 #endif // BASE_THREADING_THREAD_LOCAL_STORAGE_H_ |
OLD | NEW |