| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // The LazyInstance<Type, Traits> class manages a single instance of Type, | |
| 6 // which will be lazily created on the first time it's accessed. This class is | |
| 7 // useful for places you would normally use a function-level static, but you | |
| 8 // need to have guaranteed thread-safety. The Type constructor will only ever | |
| 9 // be called once, even if two threads are racing to create the object. Get() | |
| 10 // and Pointer() will always return the same, completely initialized instance. | |
| 11 // When the instance is constructed it is registered with AtExitManager. The | |
| 12 // destructor will be called on program exit. | |
| 13 // | |
| 14 // LazyInstance is completely thread safe, assuming that you create it safely. | |
| 15 // The class was designed to be POD initialized, so it shouldn't require a | |
| 16 // static constructor. It really only makes sense to declare a LazyInstance as | |
| 17 // a global variable using the LAZY_INSTANCE_INITIALIZER initializer. | |
| 18 // | |
| 19 // LazyInstance is similar to Singleton, except it does not have the singleton | |
| 20 // property. You can have multiple LazyInstance's of the same type, and each | |
| 21 // will manage a unique instance. It also preallocates the space for Type, as | |
| 22 // to avoid allocating the Type instance on the heap. This may help with the | |
| 23 // performance of creating the instance, and reducing heap fragmentation. This | |
| 24 // requires that Type be a complete type so we can determine the size. | |
| 25 // | |
| 26 // Example usage: | |
| 27 // static LazyInstance<MyClass> my_instance = LAZY_INSTANCE_INITIALIZER; | |
| 28 // void SomeMethod() { | |
| 29 // my_instance.Get().SomeMethod(); // MyClass::SomeMethod() | |
| 30 // | |
| 31 // MyClass* ptr = my_instance.Pointer(); | |
| 32 // ptr->DoDoDo(); // MyClass::DoDoDo | |
| 33 // } | |
| 34 | |
| 35 #ifndef BASE_LAZY_INSTANCE_H_ | |
| 36 #define BASE_LAZY_INSTANCE_H_ | |
| 37 | |
| 38 #include <new> // For placement new. | |
| 39 | |
| 40 #include "base/atomicops.h" | |
| 41 #include "base/base_export.h" | |
| 42 #include "base/basictypes.h" | |
| 43 #include "base/debug/leak_annotations.h" | |
| 44 #include "base/logging.h" | |
| 45 #include "base/memory/aligned_memory.h" | |
| 46 #include "base/threading/thread_restrictions.h" | |
| 47 | |
| 48 // LazyInstance uses its own struct initializer-list style static | |
| 49 // initialization, as base's LINKER_INITIALIZED requires a constructor and on | |
| 50 // some compilers (notably gcc 4.4) this still ends up needing runtime | |
| 51 // initialization. | |
| 52 #define LAZY_INSTANCE_INITIALIZER {0} | |
| 53 | |
| 54 namespace base { | |
| 55 | |
| 56 template <typename Type> | |
| 57 struct DefaultLazyInstanceTraits { | |
| 58 static const bool kRegisterOnExit = true; | |
| 59 #ifndef NDEBUG | |
| 60 static const bool kAllowedToAccessOnNonjoinableThread = false; | |
| 61 #endif | |
| 62 | |
| 63 static Type* New(void* instance) { | |
| 64 DCHECK_EQ(reinterpret_cast<uintptr_t>(instance) & (ALIGNOF(Type) - 1), 0u) | |
| 65 << ": Bad boy, the buffer passed to placement new is not aligned!\n" | |
| 66 "This may break some stuff like SSE-based optimizations assuming the " | |
| 67 "<Type> objects are word aligned."; | |
| 68 // Use placement new to initialize our instance in our preallocated space. | |
| 69 // The parenthesis is very important here to force POD type initialization. | |
| 70 return new (instance) Type(); | |
| 71 } | |
| 72 static void Delete(Type* instance) { | |
| 73 // Explicitly call the destructor. | |
| 74 instance->~Type(); | |
| 75 } | |
| 76 }; | |
| 77 | |
| 78 // We pull out some of the functionality into non-templated functions, so we | |
| 79 // can implement the more complicated pieces out of line in the .cc file. | |
| 80 namespace internal { | |
| 81 | |
| 82 // Use LazyInstance<T>::Leaky for a less-verbose call-site typedef; e.g.: | |
| 83 // base::LazyInstance<T>::Leaky my_leaky_lazy_instance; | |
| 84 // instead of: | |
| 85 // base::LazyInstance<T, base::internal::LeakyLazyInstanceTraits<T> > | |
| 86 // my_leaky_lazy_instance; | |
| 87 // (especially when T is MyLongTypeNameImplClientHolderFactory). | |
| 88 // Only use this internal::-qualified verbose form to extend this traits class | |
| 89 // (depending on its implementation details). | |
| 90 template <typename Type> | |
| 91 struct LeakyLazyInstanceTraits { | |
| 92 static const bool kRegisterOnExit = false; | |
| 93 #ifndef NDEBUG | |
| 94 static const bool kAllowedToAccessOnNonjoinableThread = true; | |
| 95 #endif | |
| 96 | |
| 97 static Type* New(void* instance) { | |
| 98 ANNOTATE_SCOPED_MEMORY_LEAK; | |
| 99 return DefaultLazyInstanceTraits<Type>::New(instance); | |
| 100 } | |
| 101 static void Delete(Type* instance) { | |
| 102 } | |
| 103 }; | |
| 104 | |
| 105 // Our AtomicWord doubles as a spinlock, where a value of | |
| 106 // kBeingCreatedMarker means the spinlock is being held for creation. | |
| 107 static const subtle::AtomicWord kLazyInstanceStateCreating = 1; | |
| 108 | |
| 109 // Check if instance needs to be created. If so return true otherwise | |
| 110 // if another thread has beat us, wait for instance to be created and | |
| 111 // return false. | |
| 112 BASE_EXPORT bool NeedsLazyInstance(subtle::AtomicWord* state); | |
| 113 | |
| 114 // After creating an instance, call this to register the dtor to be called | |
| 115 // at program exit and to update the atomic state to hold the |new_instance| | |
| 116 BASE_EXPORT void CompleteLazyInstance(subtle::AtomicWord* state, | |
| 117 subtle::AtomicWord new_instance, | |
| 118 void* lazy_instance, | |
| 119 void (*dtor)(void*)); | |
| 120 | |
| 121 } // namespace internal | |
| 122 | |
| 123 template <typename Type, typename Traits = DefaultLazyInstanceTraits<Type> > | |
| 124 class LazyInstance { | |
| 125 public: | |
| 126 // Do not define a destructor, as doing so makes LazyInstance a | |
| 127 // non-POD-struct. We don't want that because then a static initializer will | |
| 128 // be created to register the (empty) destructor with atexit() under MSVC, for | |
| 129 // example. We handle destruction of the contained Type class explicitly via | |
| 130 // the OnExit member function, where needed. | |
| 131 // ~LazyInstance() {} | |
| 132 | |
| 133 // Convenience typedef to avoid having to repeat Type for leaky lazy | |
| 134 // instances. | |
| 135 typedef LazyInstance<Type, internal::LeakyLazyInstanceTraits<Type> > Leaky; | |
| 136 | |
| 137 Type& Get() { | |
| 138 return *Pointer(); | |
| 139 } | |
| 140 | |
| 141 Type* Pointer() { | |
| 142 #ifndef NDEBUG | |
| 143 // Avoid making TLS lookup on release builds. | |
| 144 if (!Traits::kAllowedToAccessOnNonjoinableThread) | |
| 145 ThreadRestrictions::AssertSingletonAllowed(); | |
| 146 #endif | |
| 147 // If any bit in the created mask is true, the instance has already been | |
| 148 // fully constructed. | |
| 149 static const subtle::AtomicWord kLazyInstanceCreatedMask = | |
| 150 ~internal::kLazyInstanceStateCreating; | |
| 151 | |
| 152 // We will hopefully have fast access when the instance is already created. | |
| 153 // Since a thread sees private_instance_ == 0 or kLazyInstanceStateCreating | |
| 154 // at most once, the load is taken out of NeedsInstance() as a fast-path. | |
| 155 // The load has acquire memory ordering as a thread which sees | |
| 156 // private_instance_ > creating needs to acquire visibility over | |
| 157 // the associated data (private_buf_). Pairing Release_Store is in | |
| 158 // CompleteLazyInstance(). | |
| 159 subtle::AtomicWord value = subtle::Acquire_Load(&private_instance_); | |
| 160 if (!(value & kLazyInstanceCreatedMask) && | |
| 161 internal::NeedsLazyInstance(&private_instance_)) { | |
| 162 // Create the instance in the space provided by |private_buf_|. | |
| 163 value = reinterpret_cast<subtle::AtomicWord>( | |
| 164 Traits::New(private_buf_.void_data())); | |
| 165 internal::CompleteLazyInstance(&private_instance_, value, this, | |
| 166 Traits::kRegisterOnExit ? OnExit : NULL); | |
| 167 } | |
| 168 return instance(); | |
| 169 } | |
| 170 | |
| 171 bool operator==(Type* p) { | |
| 172 switch (subtle::NoBarrier_Load(&private_instance_)) { | |
| 173 case 0: | |
| 174 return p == NULL; | |
| 175 case internal::kLazyInstanceStateCreating: | |
| 176 return static_cast<void*>(p) == private_buf_.void_data(); | |
| 177 default: | |
| 178 return p == instance(); | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 // Effectively private: member data is only public to allow the linker to | |
| 183 // statically initialize it and to maintain a POD class. DO NOT USE FROM | |
| 184 // OUTSIDE THIS CLASS. | |
| 185 | |
| 186 subtle::AtomicWord private_instance_; | |
| 187 // Preallocated space for the Type instance. | |
| 188 base::AlignedMemory<sizeof(Type), ALIGNOF(Type)> private_buf_; | |
| 189 | |
| 190 private: | |
| 191 Type* instance() { | |
| 192 return reinterpret_cast<Type*>(subtle::NoBarrier_Load(&private_instance_)); | |
| 193 } | |
| 194 | |
| 195 // Adapter function for use with AtExit. This should be called single | |
| 196 // threaded, so don't synchronize across threads. | |
| 197 // Calling OnExit while the instance is in use by other threads is a mistake. | |
| 198 static void OnExit(void* lazy_instance) { | |
| 199 LazyInstance<Type, Traits>* me = | |
| 200 reinterpret_cast<LazyInstance<Type, Traits>*>(lazy_instance); | |
| 201 Traits::Delete(me->instance()); | |
| 202 subtle::NoBarrier_Store(&me->private_instance_, 0); | |
| 203 } | |
| 204 }; | |
| 205 | |
| 206 } // namespace base | |
| 207 | |
| 208 #endif // BASE_LAZY_INSTANCE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
