folly::ThreadCachedInt< IntT, Tag > Class Template Reference

#include <ThreadCachedInt.h>

Inheritance diagram for folly::ThreadCachedInt< IntT, Tag >:

Classes
struct	IntCache

Public Member Functions
	ThreadCachedInt (IntT initialVal=0, uint32_t cacheSize=1000)
void	increment (IntT inc)
IntT	readFast () const
IntT	readFull () const
IntT	readFastAndReset ()
IntT	readFullAndReset ()
void	setCacheSize (uint32_t newSize)
uint32_t	getCacheSize () const
ThreadCachedInt &	operator+= (IntT inc)
ThreadCachedInt &	operator-= (IntT inc)
ThreadCachedInt &	operator++ ()
ThreadCachedInt &	operator-- ()
void	set (IntT newVal)

Private Attributes
std::atomic< IntT >	target_
std::atomic< uint32_t >	cacheSize_
ThreadLocalPtr< IntCache, Tag, AccessModeStrict >	cache_

Detailed Description

template<class IntT, class Tag = IntT>
class folly::ThreadCachedInt< IntT, Tag >

Definition at line 39 of file ThreadCachedInt.h.

Constructor & Destructor Documentation

template<class IntT, class Tag = IntT>

folly::ThreadCachedInt< IntT, Tag >::ThreadCachedInt ( IntT  initialVal = 0, uint32_t  cacheSize = 1000  )

inlineexplicit

Definition at line 43 of file ThreadCachedInt.h.

      : target_(initialVal), cacheSize_(cacheSize) {}

Member Function Documentation

template<class IntT, class Tag = IntT>

uint32_t folly::ThreadCachedInt< IntT, Tag >::getCacheSize ( ) const

inline

Definition at line 103 of file ThreadCachedInt.h.

                                {
    return cacheSize_.load();
  }

template<class IntT, class Tag = IntT>

void folly::ThreadCachedInt< IntT, Tag >::increment ( IntT  inc )

inline

Definition at line 46 of file ThreadCachedInt.h.

Referenced by folly::ThreadCachedInt< uint64_t >::operator++(), folly::ThreadCachedInt< uint64_t >::operator+=(), folly::ThreadCachedInt< uint64_t >::operator--(), and folly::ThreadCachedInt< uint64_t >::operator-=().

                           {
    auto cache = cache_.get();
    if (UNLIKELY(cache == nullptr)) {
      cache = new IntCache(*this);
      cache_.reset(cache);
    }
    cache->increment(inc);
  }

template<class IntT, class Tag = IntT>

ThreadCachedInt& folly::ThreadCachedInt< IntT, Tag >::operator++ ( )

inline

Definition at line 116 of file ThreadCachedInt.h.

                                {
    increment(1);
    return *this;
  }

template<class IntT, class Tag = IntT>

ThreadCachedInt& folly::ThreadCachedInt< IntT, Tag >::operator+= ( IntT  inc )

inline

Definition at line 107 of file ThreadCachedInt.h.

                                        {
    increment(inc);
    return *this;
  }

template<class IntT, class Tag = IntT>

ThreadCachedInt& folly::ThreadCachedInt< IntT, Tag >::operator-- ( )

inline

Definition at line 120 of file ThreadCachedInt.h.

                                {
    increment(IntT(-1));
    return *this;
  }

template<class IntT, class Tag = IntT>

ThreadCachedInt& folly::ThreadCachedInt< IntT, Tag >::operator-= ( IntT  inc )

inline

Definition at line 111 of file ThreadCachedInt.h.

                                        {
    increment(-inc);
    return *this;
  }

template<class IntT, class Tag = IntT>

IntT folly::ThreadCachedInt< IntT, Tag >::readFast ( ) const

inline

Definition at line 57 of file ThreadCachedInt.h.

Referenced by BENCHMARK(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::insertInternal(), folly::ThreadCachedInt< uint64_t >::readFull(), and TEST().

                        {
    return target_.load(std::memory_order_relaxed);
  }

template<class IntT, class Tag = IntT>

IntT folly::ThreadCachedInt< IntT, Tag >::readFastAndReset ( )

inline

Definition at line 77 of file ThreadCachedInt.h.

Referenced by folly::ThreadCachedInt< uint64_t >::readFullAndReset().

                          {
    return target_.exchange(0, std::memory_order_release);
  }

template<class IntT, class Tag = IntT>

IntT folly::ThreadCachedInt< IntT, Tag >::readFull ( ) const

inline

Definition at line 63 of file ThreadCachedInt.h.

Referenced by BENCHMARK(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::insertInternal(), folly::AtomicHashMap< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::spaceRemaining(), and TEST().

                        {
    // This could race with thread destruction and so the access lock should be
    // acquired before reading the current value
    const auto accessor = cache_.accessAllThreads();
    IntT ret = readFast();
    for (const auto& cache : accessor) {
      if (!cache.reset_.load(std::memory_order_acquire)) {
        ret += cache.val_.load(std::memory_order_relaxed);
      }
    }
    return ret;
  }

template<class IntT, class Tag = IntT>

IntT folly::ThreadCachedInt< IntT, Tag >::readFullAndReset ( )

inline

Definition at line 85 of file ThreadCachedInt.h.

                          {
    // This could race with thread destruction and so the access lock should be
    // acquired before reading the current value
    auto accessor = cache_.accessAllThreads();
    IntT ret = readFastAndReset();
    for (auto& cache : accessor) {
      if (!cache.reset_.load(std::memory_order_acquire)) {
        ret += cache.val_.load(std::memory_order_relaxed);
        cache.reset_.store(true, std::memory_order_release);
      }
    }
    return ret;
  }

template<class IntT, class Tag = IntT>

void folly::ThreadCachedInt< IntT, Tag >::set ( IntT  newVal )

inline

Definition at line 128 of file ThreadCachedInt.h.

Referenced by folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::clear(), and TEST().

                        {
    for (auto& cache : cache_.accessAllThreads()) {
      cache.reset_.store(true, std::memory_order_release);
    }
    target_.store(newVal, std::memory_order_release);
  }

template<class IntT, class Tag = IntT>

void folly::ThreadCachedInt< IntT, Tag >::setCacheSize ( uint32_t  newSize )

inline

Definition at line 99 of file ThreadCachedInt.h.

                                      {
    cacheSize_.store(newSize, std::memory_order_release);
  }

Member Data Documentation

template<class IntT, class Tag = IntT>

ThreadLocalPtr<IntCache, Tag, AccessModeStrict> folly::ThreadCachedInt< IntT, Tag >::cache_

private

Definition at line 139 of file ThreadCachedInt.h.

Referenced by folly::ThreadCachedInt< uint64_t >::increment(), folly::ThreadCachedInt< uint64_t >::readFull(), folly::ThreadCachedInt< uint64_t >::readFullAndReset(), and folly::ThreadCachedInt< uint64_t >::set().

template<class IntT, class Tag = IntT>

std::atomic<uint32_t> folly::ThreadCachedInt< IntT, Tag >::cacheSize_

private

Definition at line 137 of file ThreadCachedInt.h.

Referenced by folly::ThreadCachedInt< uint64_t >::getCacheSize(), folly::ThreadCachedInt< IntT, Tag >::IntCache::increment(), and folly::ThreadCachedInt< uint64_t >::setCacheSize().

template<class IntT, class Tag = IntT>

std::atomic<IntT> folly::ThreadCachedInt< IntT, Tag >::target_

private

Definition at line 136 of file ThreadCachedInt.h.

Referenced by folly::ThreadCachedInt< IntT, Tag >::IntCache::flush(), folly::ThreadCachedInt< uint64_t >::readFast(), folly::ThreadCachedInt< uint64_t >::readFastAndReset(), and folly::ThreadCachedInt< uint64_t >::set().

---

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

• proxygen/folly/folly/ThreadCachedInt.h