proxygen: folly::detail::ThreadCachedInts< Tag

#include <ThreadCachedInts.h>

Classes
class	Integer

Public Member Functions
FOLLY_ALWAYS_INLINE void	increment (uint8_t epoch)

FOLLY_ALWAYS_INLINE void	decrement (uint8_t epoch)

int64_t	readFull (uint8_t epoch)

void	waitForZero (uint8_t phase)

void	resetAfterFork ()

Private Member Functions
void	init ()

Private Attributes
std::atomic< int64_t >	orphan_inc_ [2] = {}

std::atomic< int64_t >	orphan_dec_ [2] = {}

folly::detail::Futex	waiting_ {0}

folly::ThreadLocalPtr< Integer, Tag >	cs_

Static Private Attributes
static thread_local Integer *	int_cache_ = nullptr

Detailed Description

template<typename Tag>
class folly::detail::ThreadCachedInts< Tag >

Definition at line 38 of file ThreadCachedInts.h.

Member Function Documentation

template<typename Tag>

FOLLY_ALWAYS_INLINE void folly::detail::ThreadCachedInts< Tag >::decrement ( uint8_t epoch )

inline

Definition at line 92 of file ThreadCachedInts.h.

                                                     {
     folly::asymmetricLightBarrier(); // B
     if (!int_cache_) {
       init();
     }
 
     auto& c = int_cache_->dec_[epoch];
     auto val = c.load(std::memory_order_relaxed);
     c.store(val + 1, std::memory_order_relaxed);
 
     folly::asymmetricLightBarrier(); // C
     if (waiting_.load(std::memory_order_acquire)) {
       waiting_.store(0, std::memory_order_release);
       detail::futexWake(&waiting_);
     }
   }

template<typename Tag>

FOLLY_ALWAYS_INLINE void folly::detail::ThreadCachedInts< Tag >::increment ( uint8_t epoch )

inline

Definition at line 80 of file ThreadCachedInts.h.

                                                     {
     if (!int_cache_) {
       init();
     }
 
     auto& c = int_cache_->inc_[epoch];
     auto val = c.load(std::memory_order_relaxed);
     c.store(val + 1, std::memory_order_relaxed);
 
     folly::asymmetricLightBarrier(); // A
   }

template<typename Tag>

void folly::detail::ThreadCachedInts< Tag >::init ( )

inlineprivate

Definition at line 73 of file ThreadCachedInts.h.

Referenced by folly::detail::ThreadCachedInts< folly::detail::folly::detail::Tag >::decrement(), and folly::detail::ThreadCachedInts< folly::detail::folly::detail::Tag >::increment().

               {
     auto ret = new Integer(this);
     cs_.reset(ret);
     int_cache_ = ret;
   }

template<typename Tag>

int64_t folly::detail::ThreadCachedInts< Tag >::readFull ( uint8_t epoch )

inline

Definition at line 109 of file ThreadCachedInts.h.

Referenced by folly::detail::ThreadCachedInts< folly::detail::folly::detail::Tag >::waitForZero().

                                   {
     int64_t full = -orphan_dec_[epoch].load(std::memory_order_relaxed);
 
     // Matches A - ensure all threads have seen new value of version,
     // *and* that we see current values of counters in readFull()
     //
     // Note that in lock_shared if a reader is currently between the
     // version load and counter increment, they may update the wrong
     // epoch.  However, this is ok - they started concurrently *after*
     // any callbacks that will run, and therefore it is safe to run
     // the callbacks.
     folly::asymmetricHeavyBarrier();
     for (auto& i : cs_.accessAllThreads()) {
       full -= i.dec_[epoch].load(std::memory_order_relaxed);
     }
 
     // Matches B - ensure that all increments are seen if decrements
     // are seen. This is necessary because increment and decrement
     // are allowed to happen on different threads.
     folly::asymmetricHeavyBarrier();
 
     auto accessor = cs_.accessAllThreads();
     for (auto& i : accessor) {
       full += i.inc_[epoch].load(std::memory_order_relaxed);
     }
 
     // orphan is read behind accessAllThreads lock
     return full + orphan_inc_[epoch].load(std::memory_order_relaxed);
   }

template<typename Tag>

void folly::detail::ThreadCachedInts< Tag >::resetAfterFork ( )

inline

Definition at line 161 of file ThreadCachedInts.h.

                         {
     if (int_cache_) {
       int_cache_->dec_[0].store(0, std::memory_order_relaxed);
       int_cache_->dec_[1].store(0, std::memory_order_relaxed);
       int_cache_->inc_[0].store(0, std::memory_order_relaxed);
       int_cache_->inc_[1].store(0, std::memory_order_relaxed);
     }
     orphan_inc_[0].store(0, std::memory_order_relaxed);
     orphan_inc_[1].store(0, std::memory_order_relaxed);
     orphan_dec_[0].store(0, std::memory_order_relaxed);
     orphan_dec_[1].store(0, std::memory_order_relaxed);
   }

template<typename Tag>

void folly::detail::ThreadCachedInts< Tag >::waitForZero ( uint8_t phase )

inline

Definition at line 139 of file ThreadCachedInts.h.

                                   {
     // Try reading before futex sleeping.
     if (readFull(phase) == 0) {
       return;
     }
 
     while (true) {
       waiting_.store(1, std::memory_order_release);
       // Matches C.  Ensure either decrement sees waiting_,
       // or we see their decrement and can safely sleep.
       folly::asymmetricHeavyBarrier();
       if (readFull(phase) == 0) {
         break;
       }
       detail::futexWait(&waiting_, 1);
     }
     waiting_.store(0, std::memory_order_relaxed);
   }