/*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// Where create and destroy are functions, Singleton<T>::CreateFunc
// Singleton<T>::TeardownFunc.
//
+// For example, if you need to pass arguments to your class's constructor:
+// class X {
+// public:
+// X(int a1, std::string a2);
+// // ...
+// }
+// Make your singleton like this:
+// folly::Singleton<X> singleton_x([]() { return new X(42, "foo"); });
+//
// The above examples detail a situation where an expensive singleton is loaded
// on-demand (thus only if needed). However if there is an expensive singleton
// that will likely be needed, and initialization takes a potentially long time,
#pragma once
#include <folly/Baton.h>
+#include <folly/Demangle.h>
#include <folly/Exception.h>
+#include <folly/Executor.h>
#include <folly/Hash.h>
#include <folly/Memory.h>
#include <folly/RWSpinLock.h>
-#include <folly/Demangle.h>
-#include <folly/Executor.h>
+#include <folly/Synchronized.h>
+#include <folly/detail/StaticSingletonManager.h>
#include <folly/experimental/ReadMostlySharedPtr.h>
#include <algorithm>
namespace detail {
-// This internal-use-only class is used to create all leaked Meyers singletons.
-// It guarantees that only one instance of every such singleton will ever be
-// created, even when requested from different compilation units linked
-// dynamically.
-class StaticSingletonManager {
- public:
- static StaticSingletonManager& instance();
-
- template <typename T, typename Tag, typename F>
- inline T* create(F&& creator) {
- auto& entry = [&]() mutable -> Entry<T>& {
- std::lock_guard<std::mutex> lg(mutex_);
-
- auto& id = typeid(TypePair<T, Tag>);
- auto& entryPtr = reinterpret_cast<Entry<T>*&>(map_[id]);
- if (!entryPtr) {
- entryPtr = new Entry<T>();
- }
- return *entryPtr;
- }();
-
- std::lock_guard<std::mutex> lg(entry.mutex);
-
- if (!entry.ptr) {
- entry.ptr = creator();
- }
- return entry.ptr;
- }
-
- private:
- template <typename A, typename B>
- class TypePair {};
-
- StaticSingletonManager() {}
-
- template <typename T>
- struct Entry {
- T* ptr{nullptr};
- std::mutex mutex;
- };
-
- std::unordered_map<std::type_index, intptr_t> map_;
- std::mutex mutex_;
-};
-
-template <typename T, typename Tag, typename F>
-inline T* createGlobal(F&& creator) {
- return StaticSingletonManager::instance().create<T, Tag>(
- std::forward<F>(creator));
-}
-
-template <typename T, typename Tag>
-inline T* createGlobal() {
- return createGlobal<T, Tag>([]() { return new T(); });
-}
-
struct DefaultTag {};
// A TypeDescriptor is the unique handle for a given singleton. It is
// SingletonHolders.
class SingletonHolderBase {
public:
+ explicit SingletonHolderBase(TypeDescriptor typeDesc) : type_(typeDesc) {}
virtual ~SingletonHolderBase() = default;
- virtual TypeDescriptor type() = 0;
+ TypeDescriptor type() const {
+ return type_;
+ }
virtual bool hasLiveInstance() = 0;
virtual void createInstance() = 0;
virtual bool creationStarted() = 0;
+ virtual void preDestroyInstance(ReadMostlyMainPtrDeleter<>&) = 0;
virtual void destroyInstance() = 0;
- protected:
- static constexpr std::chrono::seconds kDestroyWaitTime{5};
+ private:
+ TypeDescriptor type_;
};
// An actual instance of a singleton, tracking the instance itself,
void registerSingleton(CreateFunc c, TeardownFunc t);
void registerSingletonMock(CreateFunc c, TeardownFunc t);
- virtual TypeDescriptor type() override;
virtual bool hasLiveInstance() override;
virtual void createInstance() override;
virtual bool creationStarted() override;
+ virtual void preDestroyInstance(ReadMostlyMainPtrDeleter<>&) override;
virtual void destroyInstance() override;
private:
Living,
};
- TypeDescriptor type_;
SingletonVault& vault_;
// mutex protects the entire entry during construction/destruction
// holds a ReadMostlyMainPtr to singleton instance, set when state is changed
// from Dead to Living. Reset when state is changed from Living to Dead.
folly::ReadMostlyMainPtr<T> instance_;
+ // used to release all ReadMostlyMainPtrs at once
+ folly::ReadMostlySharedPtr<T> instance_copy_;
// weak_ptr to the singleton instance, set when state is changed from Dead
// to Living. We never write to this object after initialization, so it is
// safe to read it from different threads w/o synchronization if we know
}
};
- explicit SingletonVault(Type type = Type::Relaxed) : type_(type) {}
+ explicit SingletonVault(Type type = Type::Strict) : type_(type) {}
// Destructor is only called by unit tests to check destroyInstances.
~SingletonVault();
// For testing; how many registered and living singletons we have.
size_t registeredSingletonCount() const {
- RWSpinLock::ReadHolder rh(&mutex_);
-
- return singletons_.size();
+ return singletons_.rlock()->size();
}
/**
bool eagerInitComplete() const;
size_t livingSingletonCount() const {
- RWSpinLock::ReadHolder rh(&mutex_);
+ auto singletons = singletons_.rlock();
size_t ret = 0;
- for (const auto& p : singletons_) {
+ for (const auto& p : *singletons) {
if (p.second->hasLiveInstance()) {
++ret;
}
// tests only.
template <typename VaultTag = detail::DefaultTag>
static SingletonVault* singleton() {
- static SingletonVault* vault =
+ /* library-local */ static auto vault =
detail::createGlobal<SingletonVault, VaultTag>();
return vault;
}
typedef std::string(*StackTraceGetterPtr)();
static std::atomic<StackTraceGetterPtr>& stackTraceGetter() {
- static std::atomic<StackTraceGetterPtr>* stackTraceGetterPtr =
- detail::createGlobal<std::atomic<StackTraceGetterPtr>,
- SingletonVault>();
+ /* library-local */ static auto stackTraceGetterPtr = detail::
+ createGlobal<std::atomic<StackTraceGetterPtr>, SingletonVault>();
return *stackTraceGetterPtr;
}
+ void setType(Type type) {
+ type_ = type;
+ }
+
private:
template <typename T>
friend struct detail::SingletonHolder;
Quiescing,
};
+ struct State {
+ SingletonVaultState state{SingletonVaultState::Running};
+ bool registrationComplete{false};
+ };
+
// Each singleton in the vault can be in two states: dead
// (registered but never created), living (CreateFunc returned an instance).
- void stateCheck(SingletonVaultState expected,
- const char* msg="Unexpected singleton state change") {
- if (expected != state_) {
- throw std::logic_error(msg);
+ static void stateCheck(
+ SingletonVaultState expected,
+ const State& state,
+ const char* msg = "Unexpected singleton state change") {
+ if (expected != state.state) {
+ throw std::logic_error(msg);
}
}
typedef std::unordered_map<detail::TypeDescriptor,
detail::SingletonHolderBase*,
detail::TypeDescriptorHasher> SingletonMap;
+ folly::Synchronized<SingletonMap> singletons_;
+ folly::Synchronized<std::unordered_set<detail::SingletonHolderBase*>>
+ eagerInitSingletons_;
+ folly::Synchronized<std::vector<detail::TypeDescriptor>> creationOrder_;
+
+ // Using SharedMutexReadPriority is important here, because we want to make
+ // sure we don't block nested singleton creation happening concurrently with
+ // destroyInstances().
+ folly::Synchronized<State, folly::SharedMutexReadPriority> state_;
- mutable folly::RWSpinLock mutex_;
- SingletonMap singletons_;
- std::unordered_set<detail::SingletonHolderBase*> eagerInitSingletons_;
- std::vector<detail::TypeDescriptor> creation_order_;
- SingletonVaultState state_{SingletonVaultState::Running};
- bool registrationComplete_{false};
- folly::RWSpinLock stateMutex_;
- Type type_{Type::Relaxed};
+ Type type_;
};
// This is the wrapper class that most users actually interact with.
};
static Entry& entryInstance() {
- static auto entry = detail::createGlobal<Entry, Tag>();
+ /* library-local */ static auto entry = detail::createGlobal<Entry, Tag>();
return *entry;
}