folly::TLRefCount Class Reference

#include <TLRefCount.h>

Classes
class	LocalRefCount

Public Types
using	Int = int64_t

Public Member Functions
	TLRefCount ()
	~TLRefCount () noexcept
Int	operator++ () noexcept
Int	operator-- () noexcept
Int	operator* () const
void	useGlobal () noexcept

Static Public Member Functions
template<typename Container >
static void	useGlobal (const Container &refCountPtrs)

Private Types
enum	State { State::LOCAL, State::GLOBAL_TRANSITION, State::GLOBAL }
using	AtomicInt = std::atomic< Int >

Private Attributes
std::atomic< State >	state_ {State::LOCAL}
folly::ThreadLocal< LocalRefCount, TLRefCount >	localCount_
std::atomic< int64_t >	globalCount_ {1}
std::mutex	globalMutex_
std::shared_ptr< void >	collectGuard_

Detailed Description

Definition at line 23 of file TLRefCount.h.

Member Typedef Documentation

using folly::TLRefCount::AtomicInt = std::atomic<Int>

private

Definition at line 128 of file TLRefCount.h.

using folly::TLRefCount::Int = int64_t

Definition at line 25 of file TLRefCount.h.

Member Enumeration Documentation

enum folly::TLRefCount::State

strongprivate

Enumerator
LOCAL
GLOBAL_TRANSITION
GLOBAL

Definition at line 130 of file TLRefCount.h.

                   {
    LOCAL,
    GLOBAL_TRANSITION,
    GLOBAL,
  };

Constructor & Destructor Documentation

folly::TLRefCount::TLRefCount ( )

inline

Definition at line 27 of file TLRefCount.h.

References collectGuard_.

      : localCount_([&]() { return new LocalRefCount(*this); }),
        collectGuard_(this, [](void*) {}) {}

folly::TLRefCount::~TLRefCount ( )

inlinenoexcept

Definition at line 31 of file TLRefCount.h.

References GLOBAL, globalCount_, and state_.

                         {
    assert(globalCount_.load() == 0);
    assert(state_.load() == State::GLOBAL);
  }

Member Function Documentation

Int folly::TLRefCount::operator* ( ) const

inline

Definition at line 76 of file TLRefCount.h.

References GLOBAL, globalCount_, and state_.

                        {
    if (state_ != State::GLOBAL) {
      return 42;
    }
    return globalCount_.load();
  }

Int folly::TLRefCount::operator++ ( )

inlinenoexcept

Definition at line 37 of file TLRefCount.h.

References GLOBAL, GLOBAL_TRANSITION, globalCount_, globalMutex_, localCount_, state_, and folly::value().

                            {
    auto& localCount = *localCount_;

    if (++localCount) {
      return 42;
    }

    if (state_.load() == State::GLOBAL_TRANSITION) {
      std::lock_guard<std::mutex> lg(globalMutex_);
    }

    assert(state_.load() == State::GLOBAL);

    auto value = globalCount_.load();
    do {
      if (value == 0) {
        return 0;
      }
    } while (!globalCount_.compare_exchange_weak(value, value + 1));

    return value + 1;
  }

Int folly::TLRefCount::operator-- ( )

inlinenoexcept

Definition at line 60 of file TLRefCount.h.

References GLOBAL, GLOBAL_TRANSITION, globalCount_, globalMutex_, localCount_, and state_.

                            {
    auto& localCount = *localCount_;

    if (--localCount) {
      return 42;
    }

    if (state_.load() == State::GLOBAL_TRANSITION) {
      std::lock_guard<std::mutex> lg(globalMutex_);
    }

    assert(state_.load() == State::GLOBAL);

    return globalCount_-- - 1;
  }

void folly::TLRefCount::useGlobal ( )

inlinenoexcept

Definition at line 83 of file TLRefCount.h.

Referenced by folly::shutdown().

                            {
    std::array<TLRefCount*, 1> ptrs{{this}};
    useGlobal(ptrs);
  }

template<typename Container >

static void folly::TLRefCount::useGlobal ( const Container &  refCountPtrs )

inlinestatic

Definition at line 89 of file TLRefCount.h.

References folly::asymmetricHeavyBarrier(), count, GLOBAL, and GLOBAL_TRANSITION.

                                                       {
#ifdef FOLLY_SANITIZE_THREAD
    // TSAN has a limitation for the number of locks held concurrently, so it's
    // safer to call useGlobal() serially.
    if (refCountPtrs.size() > 1) {
      for (auto refCountPtr : refCountPtrs) {
        refCountPtr->useGlobal();
      }
      return;
    }
#endif

    std::vector<std::unique_lock<std::mutex>> lgs_;
    for (auto refCountPtr : refCountPtrs) {
      lgs_.emplace_back(refCountPtr->globalMutex_);

      refCountPtr->state_ = State::GLOBAL_TRANSITION;
    }

    asymmetricHeavyBarrier();

    for (auto refCountPtr : refCountPtrs) {
      std::weak_ptr<void> collectGuardWeak = refCountPtr->collectGuard_;

      // Make sure we can't create new LocalRefCounts
      refCountPtr->collectGuard_.reset();

      while (!collectGuardWeak.expired()) {
        auto accessor = refCountPtr->localCount_.accessAllThreads();
        for (auto& count : accessor) {
          count.collect();
        }
      }

      refCountPtr->state_ = State::GLOBAL;
    }
  }

Member Data Documentation

std::shared_ptr<void> folly::TLRefCount::collectGuard_

private

Definition at line 209 of file TLRefCount.h.

Referenced by folly::TLRefCount::LocalRefCount::collect(), folly::TLRefCount::LocalRefCount::LocalRefCount(), TLRefCount(), and folly::TLRefCount::LocalRefCount::update().

std::atomic<int64_t> folly::TLRefCount::globalCount_ {1}

private

Definition at line 207 of file TLRefCount.h.

Referenced by operator*(), operator++(), operator--(), and ~TLRefCount().

std::mutex folly::TLRefCount::globalMutex_

private

Definition at line 208 of file TLRefCount.h.

Referenced by folly::TLRefCount::LocalRefCount::LocalRefCount(), operator++(), and operator--().

folly::ThreadLocal<LocalRefCount, TLRefCount> folly::TLRefCount::localCount_

private

Definition at line 206 of file TLRefCount.h.

Referenced by operator++(), and operator--().

std::atomic<State> folly::TLRefCount::state_ {State::LOCAL}

private

Definition at line 205 of file TLRefCount.h.

Referenced by operator*(), operator++(), operator--(), and ~TLRefCount().

---

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

• proxygen/folly/folly/experimental/TLRefCount.h