/*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <folly/RWSpinLock.h>
#include <folly/Demangle.h>
#include <folly/Executor.h>
-#include <folly/io/async/Request.h>
+#include <folly/experimental/ReadMostlySharedPtr.h>
+#include <folly/detail/StaticSingletonManager.h>
#include <algorithm>
-#include <vector>
-#include <mutex>
-#include <thread>
+#include <atomic>
#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
#include <string>
+#include <thread>
+#include <typeindex>
+#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
-#include <functional>
-#include <typeinfo>
-#include <typeindex>
+#include <vector>
#include <glog/logging.h>
inline T* get();
inline std::weak_ptr<T> get_weak();
+ inline std::shared_ptr<T> try_get();
+ inline folly::ReadMostlySharedPtr<T> try_get_fast();
void registerSingleton(CreateFunc c, TeardownFunc t);
void registerSingletonMock(CreateFunc c, TeardownFunc t);
// The singleton itself and related functions.
- // holds a shared_ptr to singleton instance, set when state is changed from
- // Dead to Living. Reset when state is changed from Living to Dead.
- std::shared_ptr<T> instance_;
+ // 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_;
// 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
// that state is set to Living
std::weak_ptr<T> instance_weak_;
+ // Fast equivalent of instance_weak_
+ folly::ReadMostlyWeakPtr<T> instance_weak_fast_;
// Time we wait on destroy_baton after releasing Singleton shared_ptr.
std::shared_ptr<folly::Baton<>> destroy_baton_;
T* instance_ptr_ = nullptr;
Relaxed, // Singletons can be created before registrationComplete()
};
+ /**
+ * Clears all singletons in the given vault at ctor and dtor times.
+ * Useful for unit-tests that need to clear the world.
+ *
+ * This need can arise when a unit-test needs to swap out an object used by a
+ * singleton for a test-double, but the singleton needing its dependency to be
+ * swapped has a type or a tag local to some other translation unit and
+ * unavailable in the current translation unit.
+ *
+ * Other, better approaches to this need are "plz 2 refactor" ....
+ */
+ struct ScopedExpunger {
+ SingletonVault* vault;
+ explicit ScopedExpunger(SingletonVault* v) : vault(v) { expunge(); }
+ ~ScopedExpunger() { expunge(); }
+ void expunge() {
+ vault->destroyInstances();
+ vault->reenableInstances();
+ }
+ };
+
explicit SingletonVault(Type type = Type::Relaxed) : type_(type) {}
// Destructor is only called by unit tests to check destroyInstances.
/**
* Schedule eager singletons' initializations through the given executor.
+ * If baton ptr is not null, its `post` method is called after all
+ * early initialization has completed.
+ *
+ * If exceptions are thrown during initialization, this method will still
+ * `post` the baton to indicate completion. The exception will not propagate
+ * and future attempts to `try_get` or `get_weak` the failed singleton will
+ * retry initialization.
+ *
+ * Sample usage:
+ *
+ * wangle::IOThreadPoolExecutor executor(max_concurrency_level);
+ * folly::Baton<> done;
+ * doEagerInitVia(executor, &done);
+ * done.wait(); // or 'timed_wait', or spin with 'try_wait'
+ *
*/
- void doEagerInitVia(Executor* exe);
+ void doEagerInitVia(Executor& exe, folly::Baton<>* done = nullptr);
// Destroy all singletons; when complete, the vault can't create
// singletons once again until reenableInstances() is called.
return singletons_.size();
}
+ /**
+ * Flips to true if eager initialization was used, and has completed.
+ * Never set to true if "doEagerInit()" or "doEagerInitVia" never called.
+ */
+ bool eagerInitComplete() const;
+
size_t livingSingletonCount() const {
RWSpinLock::ReadHolder rh(&mutex_);
// tests only.
template <typename VaultTag = detail::DefaultTag>
static SingletonVault* singleton() {
- static SingletonVault* vault = new SingletonVault();
+ static SingletonVault* vault =
+ detail::createGlobal<SingletonVault, VaultTag>();
return vault;
}
typedef std::string(*StackTraceGetterPtr)();
static std::atomic<StackTraceGetterPtr>& stackTraceGetter() {
- static std::atomic<StackTraceGetterPtr> stackTraceGetterPtr;
- return stackTraceGetterPtr;
+ static std::atomic<StackTraceGetterPtr>* stackTraceGetterPtr =
+ detail::createGlobal<std::atomic<StackTraceGetterPtr>,
+ SingletonVault>();
+ return *stackTraceGetterPtr;
}
private:
// Generally your program life cycle should be fine with calling
// get() repeatedly rather than saving the reference, and then not
// call get() during process shutdown.
- static T* get() __attribute__ ((__deprecated__("Replaced by try_get"))) {
- return getEntry().get();
- }
+ FOLLY_DEPRECATED("Replaced by try_get")
+ static T* get() { return getEntry().get(); }
// If, however, you do need to hold a reference to the specific
// singleton, you can try to do so with a weak_ptr. Avoid this when
// possible but the inability to lock the weak pointer can be a
// signal that the vault has been destroyed.
- static std::weak_ptr<T> get_weak() {
- return getEntry().get_weak();
- }
+ FOLLY_DEPRECATED("Replaced by try_get")
+ static std::weak_ptr<T> get_weak() { return getEntry().get_weak(); }
// Preferred alternative to get_weak, it returns shared_ptr that can be
// stored; a singleton won't be destroyed unless shared_ptr is destroyed.
// Avoid holding these shared_ptrs beyond the scope of a function;
// don't put them in member variables, always use try_get() instead
+ //
+ // try_get() can return nullptr if the singleton was destroyed, caller is
+ // responsible for handling nullptr return
static std::shared_ptr<T> try_get() {
- auto ret = get_weak().lock();
- if (!ret) {
- LOG(DFATAL) <<
- "folly::Singleton<" << getEntry().type().name() <<
- ">::get_weak() called on destructed singleton; "
- "returning nullptr, possible segfault coming";
- }
- return ret;
+ return getEntry().try_get();
}
- explicit Singleton(std::nullptr_t _ = nullptr,
- typename Singleton::TeardownFunc t = nullptr) :
- Singleton ([]() { return new T; }, std::move(t)) {
+ static folly::ReadMostlySharedPtr<T> try_get_fast() {
+ return getEntry().try_get_fast();
}
+ explicit Singleton(std::nullptr_t /* _ */ = nullptr,
+ typename Singleton::TeardownFunc t = nullptr)
+ : Singleton([]() { return new T; }, std::move(t)) {}
+
explicit Singleton(typename Singleton::CreateFunc c,
typename Singleton::TeardownFunc t = nullptr) {
if (c == nullptr) {
* the injection. The returned mock singleton is functionality identical to
* regular singletons.
*/
- static void make_mock(std::nullptr_t c = nullptr,
+ static void make_mock(std::nullptr_t /* c */ = nullptr,
typename Singleton<T>::TeardownFunc t = nullptr) {
make_mock([]() { return new T; }, t);
}
}
};
+template <typename T, typename Tag = detail::DefaultTag>
+class LeakySingleton {
+ public:
+ using CreateFunc = std::function<T*()>;
+
+ LeakySingleton() : LeakySingleton([] { return new T(); }) {}
+
+ explicit LeakySingleton(CreateFunc createFunc) {
+ auto& entry = entryInstance();
+ if (entry.state != State::NotRegistered) {
+ LOG(FATAL) << "Double registration of singletons of the same "
+ << "underlying type; check for multiple definitions "
+ << "of type folly::LeakySingleton<" + entry.type_.name() + ">";
+ }
+ entry.createFunc = createFunc;
+ entry.state = State::Dead;
+ }
+
+ static T& get() { return instance(); }
+
+ private:
+ enum class State { NotRegistered, Dead, Living };
+
+ struct Entry {
+ Entry() {}
+ Entry(const Entry&) = delete;
+ Entry& operator=(const Entry&) = delete;
+
+ std::atomic<State> state{State::NotRegistered};
+ T* ptr{nullptr};
+ CreateFunc createFunc;
+ std::mutex mutex;
+ detail::TypeDescriptor type_{typeid(T), typeid(Tag)};
+ };
+
+ static Entry& entryInstance() {
+ static auto entry = detail::createGlobal<Entry, Tag>();
+ return *entry;
+ }
+
+ static T& instance() {
+ auto& entry = entryInstance();
+ if (UNLIKELY(entry.state != State::Living)) {
+ createInstance();
+ }
+
+ return *entry.ptr;
+ }
+
+ static void createInstance() {
+ auto& entry = entryInstance();
+
+ std::lock_guard<std::mutex> lg(entry.mutex);
+ if (entry.state == State::Living) {
+ return;
+ }
+
+ if (entry.state == State::NotRegistered) {
+ auto ptr = SingletonVault::stackTraceGetter().load();
+ LOG(FATAL) << "Creating instance for unregistered singleton: "
+ << entry.type_.name() << "\n"
+ << "Stacktrace:"
+ << "\n" << (ptr ? (*ptr)() : "(not available)");
+ }
+
+ entry.ptr = entry.createFunc();
+ entry.state = State::Living;
+ }
+};
}
#include <folly/Singleton-inl.h>
projects / folly.git / blobdiff