proxygen: folly::detail::SingletonHolder< T

#include <Singleton.h>

Inheritance diagram for folly::detail::SingletonHolder< T >:

Public Types
typedef std::function< void(T *)>	TeardownFunc

typedef std::function< T *(void)>	CreateFunc

Public Member Functions
T *	get ()

std::weak_ptr< T >	get_weak ()

std::shared_ptr< T >	try_get ()

folly::ReadMostlySharedPtr< T >	try_get_fast ()

void	vivify ()

void	registerSingleton (CreateFunc c, TeardownFunc t)

void	registerSingletonMock (CreateFunc c, TeardownFunc t)

bool	hasLiveInstance () override

void	createInstance () override

bool	creationStarted () override

void	preDestroyInstance (ReadMostlyMainPtrDeleter<> &) override

void	destroyInstance () override

Public Member Functions inherited from folly::detail::SingletonHolderBase
	SingletonHolderBase (TypeDescriptor typeDesc)

virtual	~SingletonHolderBase ()=default

TypeDescriptor	type () const

Static Public Member Functions
template<typename Tag , typename VaultTag >
static SingletonHolder< T > &	singleton ()

Private Types
enum	SingletonHolderState { SingletonHolderState::NotRegistered, SingletonHolderState::Dead, SingletonHolderState::Living }

Private Member Functions
	SingletonHolder (TypeDescriptor type, SingletonVault &vault)

	SingletonHolder (const SingletonHolder &)=delete

SingletonHolder &	operator= (const SingletonHolder &)=delete

SingletonHolder &	operator= (SingletonHolder &&)=delete

	SingletonHolder (SingletonHolder &&)=delete

Private Attributes
SingletonVault &	vault_

std::mutex	mutex_

std::atomic< SingletonHolderState >	state_ {SingletonHolderState::NotRegistered}

std::atomic< std::thread::id >	creating_thread_ {}

folly::ReadMostlyMainPtr< T >	instance_

folly::ReadMostlySharedPtr< T >	instance_copy_

std::weak_ptr< T >	instance_weak_

folly::ReadMostlyWeakPtr< T >	instance_weak_fast_

std::shared_ptr< folly::Baton<> >	destroy_baton_

T *	instance_ptr_ = nullptr

CreateFunc	create_ = nullptr

TeardownFunc	teardown_ = nullptr

std::shared_ptr< std::atomic< bool > >	print_destructor_stack_trace_

Detailed Description

template<typename T>
struct folly::detail::SingletonHolder< T >

Definition at line 302 of file Singleton.h.

Member Typedef Documentation

template<typename T>

typedef std::function<T*(void)> folly::detail::SingletonHolder< T >::CreateFunc

Definition at line 305 of file Singleton.h.

template<typename T>

typedef std::function<void(T*)> folly::detail::SingletonHolder< T >::TeardownFunc

Definition at line 304 of file Singleton.h.

Member Enumeration Documentation

template<typename T>

enum folly::detail::SingletonHolder::SingletonHolderState

strongprivate

Enumerator
NotRegistered
Dead
Living

Definition at line 327 of file Singleton.h.

                                   {
     NotRegistered,
     Dead,
     Living,
   };

Constructor & Destructor Documentation

template<typename T >

folly::detail::SingletonHolder< T >::SingletonHolder	(	TypeDescriptor	type,
		SingletonVault &	vault
	)

private

Definition at line 181 of file Singleton-inl.h.

184 : SingletonHolderBase(typeDesc), vault_(vault) {}

folly::detail::SingletonHolderBase::SingletonHolderBase

SingletonHolderBase(TypeDescriptor typeDesc)

Definition: Singleton.h:282

folly::detail::SingletonHolder::vault_

SingletonVault & vault_

Definition: Singleton.h:333

template<typename T>

folly::detail::SingletonHolder< T >::SingletonHolder ( const SingletonHolder< T > & )

privatedelete

template<typename T>

folly::detail::SingletonHolder< T >::SingletonHolder ( SingletonHolder< T > && )

privatedelete

Member Function Documentation

template<typename T >

void folly::detail::SingletonHolder< T >::createInstance ( )

overridevirtual

Implements folly::detail::SingletonHolderBase.

Definition at line 203 of file Singleton-inl.h.

                                         {
   if (creating_thread_.load(std::memory_order_acquire) ==
       std::this_thread::get_id()) {
     detail::singletonWarnCreateCircularDependencyAndAbort(type());
   }
 
   std::lock_guard<std::mutex> entry_lock(mutex_);
   if (state_.load(std::memory_order_acquire) == SingletonHolderState::Living) {
     return;
   }
   if (state_.load(std::memory_order_acquire) ==
       SingletonHolderState::NotRegistered) {
     detail::singletonWarnCreateUnregisteredAndAbort(type());
   }
 
   if (state_.load(std::memory_order_acquire) == SingletonHolderState::Living) {
     return;
   }
 
   SCOPE_EXIT {
     // Clean up creator thread when complete, and also, in case of errors here,
     // so that subsequent attempts don't think this is still in the process of
     // being built.
     creating_thread_.store(std::thread::id(), std::memory_order_release);
   };
 
   creating_thread_.store(std::this_thread::get_id(), std::memory_order_release);
 
   auto state = vault_.state_.rlock();
   if (vault_.type_ != SingletonVault::Type::Relaxed &&
       !state->registrationComplete) {
     detail::singletonWarnCreateBeforeRegistrationCompleteAndAbort(type());
   }
   if (state->state == detail::SingletonVaultState::Type::Quiescing) {
     return;
   }
 
   auto destroy_baton = std::make_shared<folly::Baton<>>();
   auto print_destructor_stack_trace =
       std::make_shared<std::atomic<bool>>(false);
 
   // Can't use make_shared -- no support for a custom deleter, sadly.
   std::shared_ptr<T> instance(
       create_(),
       [destroy_baton, print_destructor_stack_trace, type = type()](T*) mutable {
         destroy_baton->post();
         if (print_destructor_stack_trace->load()) {
           detail::singletonPrintDestructionStackTrace(type);
         }
       });
 
   // We should schedule destroyInstances() only after the singleton was
   // created. This will ensure it will be destroyed before singletons,
   // not managed by folly::Singleton, which were initialized in its
   // constructor
   SingletonVault::scheduleDestroyInstances();
 
   instance_weak_ = instance;
   instance_ptr_ = instance.get();
   instance_.reset(std::move(instance));
   instance_weak_fast_ = instance_;
 
   destroy_baton_ = std::move(destroy_baton);
   print_destructor_stack_trace_ = std::move(print_destructor_stack_trace);
 
   // This has to be the last step, because once state is Living other threads
   // may access instance and instance_weak w/o synchronization.
   state_.store(SingletonHolderState::Living, std::memory_order_release);
 
   vault_.creationOrder_.wlock()->push_back(type());
 }

template<typename T >

bool folly::detail::SingletonHolder< T >::creationStarted ( )

overridevirtual

Implements folly::detail::SingletonHolderBase.

Definition at line 187 of file Singleton-inl.h.

References folly::detail::SingletonHolder< T >::creating_thread_, folly::detail::SingletonHolder< T >::Living, and folly::detail::SingletonHolder< T >::state_.

                                          {
   // If alive, then creation was of course started.
   // This is flipped after creating_thread_ was set, and before it was reset.
   if (state_.load(std::memory_order_acquire) == SingletonHolderState::Living) {
     return true;
   }
 
   // Not yet built.  Is it currently in progress?
   if (creating_thread_.load(std::memory_order_acquire) != std::thread::id()) {
     return true;
   }
 
   return false;
 }

template<typename T >

void folly::detail::SingletonHolder< T >::destroyInstance ( )

overridevirtual

Implements folly::detail::SingletonHolderBase.

Definition at line 163 of file Singleton-inl.h.

References folly::detail::singletonWarnDestroyInstanceLeak(), and type.

                                          {
   state_ = SingletonHolderState::Dead;
   instance_.reset();
   instance_copy_.reset();
   if (destroy_baton_) {
     constexpr std::chrono::seconds kDestroyWaitTime{5};
     auto last_reference_released =
         destroy_baton_->try_wait_for(kDestroyWaitTime);
     if (last_reference_released) {
       teardown_(instance_ptr_);
     } else {
       print_destructor_stack_trace_->store(true);
       detail::singletonWarnDestroyInstanceLeak(type(), instance_ptr_);
     }
   }
 }

template<typename T >

T * folly::detail::SingletonHolder< T >::get ( )

inline

Definition at line 93 of file Singleton-inl.h.

References LIKELY, folly::detail::singletonThrowGetInvokedAfterDestruction(), and type.

                            {
   if (LIKELY(
           state_.load(std::memory_order_acquire) ==
           SingletonHolderState::Living)) {
     return instance_ptr_;
   }
   createInstance();
 
   if (instance_weak_.expired()) {
     detail::singletonThrowGetInvokedAfterDestruction(type());
   }
 
   return instance_ptr_;
 }

template<typename T >

std::weak_ptr< T > folly::detail::SingletonHolder< T >::get_weak ( )

inline

Definition at line 109 of file Singleton-inl.h.

References UNLIKELY.

                                             {
   if (UNLIKELY(
           state_.load(std::memory_order_acquire) !=
           SingletonHolderState::Living)) {
     createInstance();
   }
 
   return instance_weak_;
 }

template<typename T >

bool folly::detail::SingletonHolder< T >::hasLiveInstance ( )

overridevirtual

Implements folly::detail::SingletonHolderBase.

Definition at line 151 of file Singleton-inl.h.

                                          {
   return !instance_weak_.expired();
 }

template<typename T>

SingletonHolder& folly::detail::SingletonHolder< T >::operator= ( const SingletonHolder< T > & )

privatedelete

template<typename T>

SingletonHolder& folly::detail::SingletonHolder< T >::operator= ( SingletonHolder< T > && )

privatedelete

template<typename T >

void folly::detail::SingletonHolder< T >::preDestroyInstance ( ReadMostlyMainPtrDeleter<> & deleter )

overridevirtual

Implements folly::detail::SingletonHolderBase.

Definition at line 156 of file Singleton-inl.h.

References folly::ReadMostlyMainPtrDeleter< RefCount >::add(), and folly::gen::move.

                                          {
   instance_copy_ = instance_;
   deleter.add(std::move(instance_));
 }

template<typename T >

void folly::detail::SingletonHolder< T >::registerSingleton	(	CreateFunc	c,
		TeardownFunc	t
	)

Definition at line 36 of file Singleton-inl.h.

References folly::gen::move, mutex_, folly::detail::singletonWarnDoubleRegistrationAndAbort(), and type.

                                                                        {
   std::lock_guard<std::mutex> entry_lock(mutex_);
 
   if (state_ != SingletonHolderState::NotRegistered) {
     /* Possible causes:
      *
      * You have two instances of the same
      * folly::Singleton<Class>. Probably because you define the
      * singleton in a header included in multiple places? In general,
      * folly::Singleton shouldn't be in the header, only off in some
      * anonymous namespace in a cpp file. Code needing the singleton
      * will find it when that code references folly::Singleton<Class>.
      *
      * Alternatively, you could have 2 singletons with the same type
      * defined with a different name in a .cpp (source) file. For
      * example:
      *
      * Singleton<int> a([] { return new int(3); });
      * Singleton<int> b([] { return new int(4); });
      *
      * Adding tags should fix this (see documentation in the header).
      *
      */
     singletonWarnDoubleRegistrationAndAbort(type());
   }
 
   create_ = std::move(c);
   teardown_ = std::move(t);
 
   state_ = SingletonHolderState::Dead;
 }

template<typename T >

void folly::detail::SingletonHolder< T >::registerSingletonMock	(	CreateFunc	c,
		TeardownFunc	t
	)

Definition at line 69 of file Singleton-inl.h.

References folly::gen::move, mutex_, folly::detail::singletonWarnRegisterMockEarlyAndAbort(), and type.

                                                                            {
   if (state_ == SingletonHolderState::NotRegistered) {
     detail::singletonWarnRegisterMockEarlyAndAbort(type());
   }
   if (state_ == SingletonHolderState::Living) {
     destroyInstance();
   }
 
   {
     auto creationOrder = vault_.creationOrder_.wlock();
 
     auto it = std::find(creationOrder->begin(), creationOrder->end(), type());
     if (it != creationOrder->end()) {
       creationOrder->erase(it);
     }
   }
 
   std::lock_guard<std::mutex> entry_lock(mutex_);
 
   create_ = std::move(c);
   teardown_ = std::move(t);
 }

template<typename T >

template<typename Tag , typename VaultTag >

SingletonHolder< T > & folly::detail::SingletonHolder< T >::singleton ( )

inlinestatic

Definition at line 23 of file Singleton-inl.h.

References folly::detail::singletonWarnDoubleRegistrationAndAbort(), folly::T, and type.

                                                   {
   /* library-local */ static auto entry =
       createGlobal<SingletonHolder<T>, std::pair<Tag, VaultTag>>([]() {
         return new SingletonHolder<T>(
             {typeid(T), typeid(Tag)}, *SingletonVault::singleton<VaultTag>());
       });
   return *entry;
 }

template<typename T >

std::shared_ptr< T > folly::detail::SingletonHolder< T >::try_get ( )

inline

Definition at line 120 of file Singleton-inl.h.

References UNLIKELY.

                                              {
   if (UNLIKELY(
           state_.load(std::memory_order_acquire) !=
           SingletonHolderState::Living)) {
     createInstance();
   }
 
   return instance_weak_.lock();
 }

template<typename T >

folly::ReadMostlySharedPtr< T > folly::detail::SingletonHolder< T >::try_get_fast ( )

inline

Definition at line 131 of file Singleton-inl.h.

References UNLIKELY.

                                                              {
   if (UNLIKELY(
           state_.load(std::memory_order_acquire) !=
           SingletonHolderState::Living)) {
     createInstance();
   }
 
   return instance_weak_fast_.lock();
 }

template<typename T >

void folly::detail::SingletonHolder< T >::vivify ( )

inline

Definition at line 142 of file Singleton-inl.h.

References UNLIKELY.

                                 {
   if (UNLIKELY(
           state_.load(std::memory_order_relaxed) !=
           SingletonHolderState::Living)) {
     createInstance();
   }
 }