| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef BASE_LAZY_INSTANCE_INTERNAL_H_ |
| #define BASE_LAZY_INSTANCE_INTERNAL_H_ |
| |
| #include "base/atomicops.h" |
| #include "base/base_export.h" |
| #include "base/check.h" |
| |
| // Helper methods used by LazyInstance and a few other base APIs for thread-safe |
| // lazy construction. |
| |
| namespace base { |
| namespace internal { |
| |
| // Our AtomicWord doubles as a spinlock, where a value of |
| // kLazyInstanceStateCreating means the spinlock is being held for creation. |
| constexpr subtle::AtomicWord kLazyInstanceStateCreating = 1; |
| |
| // Helper for GetOrCreateLazyPointer(). Checks if instance needs to be created. |
| // If so returns true otherwise if another thread has beat us, waits for |
| // instance to be created and returns false. |
| BASE_EXPORT bool NeedsLazyInstance(subtle::AtomicWord* state); |
| |
| // Helper for GetOrCreateLazyPointer(). After creating an instance, this is |
| // called to register the dtor to be called at program exit and to update the |
| // atomic state to hold the |new_instance| |
| BASE_EXPORT void CompleteLazyInstance(subtle::AtomicWord* state, |
| subtle::AtomicWord new_instance, |
| void (*destructor)(void*), |
| void* destructor_arg); |
| |
| } // namespace internal |
| |
| namespace subtle { |
| |
| // If |state| is uninitialized (zero), constructs a value using |
| // |creator_func(creator_arg)|, stores it into |state| and registers |
| // |destructor(destructor_arg)| to be called when the current AtExitManager goes |
| // out of scope. Then, returns the value stored in |state|. It is safe to have |
| // concurrent calls to this function with the same |state|. |creator_func| may |
| // return nullptr if it doesn't want to create an instance anymore (e.g. on |
| // shutdown), it is from then on required to return nullptr to all callers (ref. |
| // StaticMemorySingletonTraits). In that case, callers need to synchronize |
| // before |creator_func| may return a non-null instance again (ref. |
| // StaticMemorySingletonTraits::ResurectForTesting()). |
| // Implementation note on |creator_func/creator_arg|. It makes for ugly adapters |
| // but it avoids redundant template instantiations (e.g. saves 27KB in |
| // chrome.dll) because linker is able to fold these for multiple Types but |
| // couldn't with the more advanced CreatorFunc template type which in turn |
| // improves code locality (and application startup) -- ref. |
| // https://chromium-review.googlesource.com/c/chromium/src/+/530984/5/base/lazy_instance.h#140, |
| // worsened by https://chromium-review.googlesource.com/c/chromium/src/+/868013 |
| // and caught then as https://crbug.com/804034. |
| template <typename Type> |
| Type* GetOrCreateLazyPointer(subtle::AtomicWord* state, |
| Type* (*creator_func)(void*), |
| void* creator_arg, |
| void (*destructor)(void*), |
| void* destructor_arg) { |
| DCHECK(state); |
| DCHECK(creator_func); |
| |
| // If any bit in the created mask is true, the instance has already been |
| // fully constructed. |
| constexpr subtle::AtomicWord kLazyInstanceCreatedMask = |
| ~internal::kLazyInstanceStateCreating; |
| |
| // We will hopefully have fast access when the instance is already created. |
| // Since a thread sees |state| == 0 or kLazyInstanceStateCreating at most |
| // once, the load is taken out of NeedsLazyInstance() as a fast-path. The load |
| // has acquire memory ordering as a thread which sees |state| > creating needs |
| // to acquire visibility over the associated data. Pairing Release_Store is in |
| // CompleteLazyInstance(). |
| subtle::AtomicWord instance = subtle::Acquire_Load(state); |
| if (!(instance & kLazyInstanceCreatedMask)) { |
| if (internal::NeedsLazyInstance(state)) { |
| // This thread won the race and is now responsible for creating the |
| // instance and storing it back into |state|. |
| instance = |
| reinterpret_cast<subtle::AtomicWord>((*creator_func)(creator_arg)); |
| internal::CompleteLazyInstance(state, instance, destructor, |
| destructor_arg); |
| } else { |
| // This thread lost the race but now has visibility over the constructed |
| // instance (NeedsLazyInstance() doesn't return until the constructing |
| // thread releases the instance via CompleteLazyInstance()). |
| instance = subtle::Acquire_Load(state); |
| DCHECK(instance & kLazyInstanceCreatedMask); |
| } |
| } |
| return reinterpret_cast<Type*>(instance); |
| } |
| |
| } // namespace subtle |
| |
| } // namespace base |
| |
| #endif // BASE_LAZY_INSTANCE_INTERNAL_H_ |