folly::threadlocal_detail::StaticMeta< Tag, AccessMode > Struct Template Reference

#include <ThreadLocalDetail.h>

Inheritance diagram for folly::threadlocal_detail::StaticMeta< Tag, AccessMode >:

Public Member Functions
	StaticMeta ()
	~StaticMeta ()=delete
Public Member Functions inherited from folly::threadlocal_detail::StaticMetaBase
	StaticMetaBase (ThreadEntry *(*threadEntry)(), bool strict)
void	push_back (ThreadEntry *t)
void	erase (ThreadEntry *t)
uint32_t	elementsCapacity () const
uint32_t	allocate (EntryID *ent)
void	destroy (EntryID *ent)
void	reserve (EntryID *id)
ElementWrapper &	getElement (EntryID *ent)
void	reserveHeadUnlocked (uint32_t id)
void	pushBackLocked (ThreadEntry *t, uint32_t id)
void	pushBackUnlocked (ThreadEntry *t, uint32_t id)

Static Public Member Functions
static StaticMeta< Tag, AccessMode > &	instance ()
FOLLY_EXPORT static FOLLY_ALWAYS_INLINE ElementWrapper &	get (EntryID *ent)
static FOLLY_NOINLINE void	getSlowReserveAndCache (EntryID *ent, uint32_t &id, ThreadEntry *&threadEntry, size_t &capacity)
FOLLY_EXPORT static FOLLY_NOINLINE ThreadEntry *	getThreadEntrySlow ()
static bool	preFork ()
static void	onForkParent ()
static void	onForkChild ()
Static Public Member Functions inherited from folly::threadlocal_detail::StaticMetaBase
static FOLLY_EXPORT ThreadEntryList *	getThreadEntryList ()
static void	onThreadExit (void *ptr)
static ElementWrapper *	reallocate (ThreadEntry *threadEntry, uint32_t idval, size_t &newCapacity)

Additional Inherited Members
Public Attributes inherited from folly::threadlocal_detail::StaticMetaBase
uint32_t	nextId_
std::vector< uint32_t >	freeIds_
std::mutex	lock_
SharedMutex	accessAllThreadsLock_
pthread_key_t	pthreadKey_
ThreadEntry	head_
ThreadEntry *(*	threadEntry_ )()
bool	strict_
Protected Member Functions inherited from folly::threadlocal_detail::StaticMetaBase
	~StaticMetaBase ()

Detailed Description

template<class Tag, class AccessMode>
struct folly::threadlocal_detail::StaticMeta< Tag, AccessMode >

Definition at line 414 of file ThreadLocalDetail.h.

Constructor & Destructor Documentation

template<class Tag , class AccessMode >

folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::StaticMeta ( )

inline

Definition at line 415 of file ThreadLocalDetail.h.

References folly::detail::AtFork::registerHandler().

      : StaticMetaBase(
            &StaticMeta::getThreadEntrySlow,
            std::is_same<AccessMode, AccessModeStrict>::value) {
    detail::AtFork::registerHandler(
        this,
        /*prepare*/ &StaticMeta::preFork,
        /*parent*/ &StaticMeta::onForkParent,
        /*child*/ &StaticMeta::onForkChild);
  }

template<class Tag , class AccessMode >

folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::~StaticMeta ( )

delete

Member Function Documentation

template<class Tag , class AccessMode >

FOLLY_EXPORT static FOLLY_ALWAYS_INLINE ElementWrapper& folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::get ( EntryID *  ent )

inlinestatic

Definition at line 436 of file ThreadLocalDetail.h.

References FOLLY_UNLIKELY, and uint32_t.

                                                                            {
    // Eliminate as many branches and as much extra code as possible in the
    // cached fast path, leaving only one branch here and one indirection below.
    uint32_t id = ent->getOrInvalid();
#ifdef FOLLY_TLD_USE_FOLLY_TLS
    static FOLLY_TLS ThreadEntry* threadEntry{};
    static FOLLY_TLS size_t capacity{};
#else
    ThreadEntry* threadEntry{};
    size_t capacity{};
#endif
    if (FOLLY_UNLIKELY(capacity <= id)) {
      getSlowReserveAndCache(ent, id, threadEntry, capacity);
    }
    return threadEntry->elements[id];
  }

template<class Tag , class AccessMode >

static FOLLY_NOINLINE void folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::getSlowReserveAndCache ( EntryID *  ent, uint32_t &  id, ThreadEntry *&  threadEntry, size_t &  capacity  )

inlinestatic

Definition at line 453 of file ThreadLocalDetail.h.

References folly::threadlocal_detail::ThreadEntry::getElementsCapacity(), folly::threadlocal_detail::StaticMetaBase::EntryID::getOrInvalid(), and UNLIKELY.

                        {
    auto& inst = instance();
    threadEntry = inst.threadEntry_();
    if (UNLIKELY(threadEntry->getElementsCapacity() <= id)) {
      inst.reserve(ent);
      id = ent->getOrInvalid();
    }
    capacity = threadEntry->getElementsCapacity();
    assert(capacity > id);
  }

template<class Tag , class AccessMode >

FOLLY_EXPORT static FOLLY_NOINLINE ThreadEntry* folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::getThreadEntrySlow ( )

inlinestatic

Definition at line 468 of file ThreadLocalDetail.h.

References folly::checkPosixError(), folly::threadlocal_detail::ThreadEntryList::count, folly::threadlocal_detail::ThreadEntryList::head, folly::threadlocal_detail::ThreadEntry::list, folly::threadlocal_detail::ThreadEntry::listNext, and folly::threadlocal_detail::ThreadEntry::meta.

                                                                       {
    auto& meta = instance();
    auto key = meta.pthreadKey_;
    ThreadEntry* threadEntry =
        static_cast<ThreadEntry*>(pthread_getspecific(key));
    if (!threadEntry) {
      ThreadEntryList* threadEntryList = StaticMeta::getThreadEntryList();
#ifdef FOLLY_TLD_USE_FOLLY_TLS
      static FOLLY_TLS ThreadEntry threadEntrySingleton;
      threadEntry = &threadEntrySingleton;
#else
      threadEntry = new ThreadEntry();
#endif
      // if the ThreadEntry already exists
      // but pthread_getspecific returns NULL
      // do not add the same entry twice to the list
      // since this would create a loop in the list
      if (!threadEntry->list) {
        threadEntry->list = threadEntryList;
        threadEntry->listNext = threadEntryList->head;
        threadEntryList->head = threadEntry;
      }

      // if we're adding a thread entry
      // we need to increment the list count
      // even if the entry is reused
      threadEntryList->count++;

      threadEntry->meta = &meta;
      int ret = pthread_setspecific(key, threadEntry);
      checkPosixError(ret, "pthread_setspecific failed");
    }
    return threadEntry;
  }

template<class Tag , class AccessMode >

static StaticMeta<Tag, AccessMode>& folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::instance ( )

inlinestatic

Definition at line 428 of file ThreadLocalDetail.h.

Referenced by folly::SingletonVault::scheduleDestroyInstances().

                                                 {
    // Leak it on exit, there's only one per process and we don't have to
    // worry about synchronization with exiting threads.
    /* library-local */ static auto instance =
        detail::createGlobal<StaticMeta<Tag, AccessMode>, void>();
    return *instance;
  }

template<class Tag , class AccessMode >

static void folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::onForkChild ( )

inlinestatic

Definition at line 511 of file ThreadLocalDetail.h.

References folly::threadlocal_detail::ThreadEntry::elements, folly::threadlocal_detail::ThreadEntry::getElementsCapacity(), i, folly::threadlocal_detail::ThreadEntryNode::initIfZero(), folly::threadlocal_detail::ThreadEntryNode::initZero(), folly::threadlocal_detail::ElementWrapper::node, and folly::threadlocal_detail::ThreadEntryNode::zero().

                            {
    // only the current thread survives
    auto& head = instance().head_;
    // init the head list
    head.next = head.prev = &head;
    // init the circular lists
    auto elementsCapacity = head.getElementsCapacity();
    for (size_t i = 0u; i < elementsCapacity; ++i) {
      head.elements[i].node.init(&head, static_cast<uint32_t>(i));
    }
    // init the thread entry
    ThreadEntry* threadEntry = instance().threadEntry_();
    elementsCapacity = threadEntry->getElementsCapacity();
    for (size_t i = 0u; i < elementsCapacity; ++i) {
      if (!threadEntry->elements[i].node.zero()) {
        threadEntry->elements[i].node.initZero(
            threadEntry, static_cast<uint32_t>(i));
        threadEntry->elements[i].node.initIfZero(false /*locked*/);
      }
    }

    // If this thread was in the list before the fork, add it back.
    if (elementsCapacity != 0) {
      instance().push_back(threadEntry);
    }
    instance().lock_.unlock();
  }

template<class Tag , class AccessMode >

static void folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::onForkParent ( )

inlinestatic

Definition at line 507 of file ThreadLocalDetail.h.

                             {
    instance().lock_.unlock();
  }

template<class Tag , class AccessMode >

static bool folly::threadlocal_detail::StaticMeta< Tag, AccessMode >::preFork ( )

inlinestatic

Definition at line 503 of file ThreadLocalDetail.h.

                        {
    return instance().lock_.try_lock(); // Make sure it's created
  }

---

The documentation for this struct was generated from the following file:

• proxygen/folly/folly/detail/ThreadLocalDetail.h