mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-12-01 09:46:09 +03:00
102 lines
4.6 KiB
C++
102 lines
4.6 KiB
C++
// 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_HELPERS_H_
|
|
#define BASE_LAZY_INSTANCE_HELPERS_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_HELPERS_H_
|