folly::rcu_domain< Tag > Class Template Reference

#include <Rcu.h>

Public Member Functions
	rcu_domain (Executor *executor=nullptr) noexcept
	rcu_domain (const rcu_domain &)=delete
	rcu_domain (rcu_domain &&)=delete
rcu_domain &	operator= (const rcu_domain &)=delete
rcu_domain &	operator= (rcu_domain &&)=delete
	~rcu_domain ()
FOLLY_ALWAYS_INLINE rcu_token	lock_shared ()
FOLLY_ALWAYS_INLINE void	unlock_shared (rcu_token &&)
template<typename T >
void	call (T &&cbin)
void	retire (list_node *node) noexcept
void	synchronize () noexcept

Private Types
using	list_head = typename detail::ThreadCachedLists< Tag >::ListHead
using	list_node = typename detail::ThreadCachedLists< Tag >::Node

Private Member Functions
void	half_sync (bool blocking, list_head &cbs)

Private Attributes
detail::ThreadCachedInts< Tag >	counters_
std::atomic< uint64_t >	version_ {0}
std::atomic< uint64_t >	work_ {0}
detail::TurnSequencer< std::atomic >	turn_
std::mutex	syncMutex_
std::atomic< uint64_t >	syncTime_ {0}
detail::ThreadCachedLists< Tag >	q_
Executor *	executor_ {nullptr}
list_head	queues_ [2] {}

Static Private Attributes
static constexpr uint64_t	syncTimePeriod_ {1600 * 2 }
static bool	singleton_ = false

Detailed Description

template<typename Tag>
class folly::rcu_domain< Tag >

Definition at line 287 of file Rcu.h.

Member Typedef Documentation

template<typename Tag>

using folly::rcu_domain< Tag >::list_head = typename detail::ThreadCachedLists<Tag>::ListHead

private

Definition at line 312 of file Rcu.h.

template<typename Tag>

using folly::rcu_domain< Tag >::list_node = typename detail::ThreadCachedLists<Tag>::Node

private

Definition at line 313 of file Rcu.h.

Constructor & Destructor Documentation

template<typename Tag >

folly::rcu_domain< Tag >::rcu_domain ( Executor *  executor = nullptr )

noexcept

Definition at line 27 of file Rcu-inl.h.

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

    : executor_(executor ? executor : &QueuedImmediateExecutor::instance()) {
  // Please use a unique tag for each domain.
  CHECK(!singleton_);
  singleton_ = true;

  // Register fork handlers.  Holding read locks across fork is not
  // supported.  Using read locks in other atfork handlers is not
  // supported.  Other atfork handlers launching new child threads
  // that use read locks *is* supported.
  detail::AtFork::registerHandler(
      this,
      [this]() { return syncMutex_.try_lock(); },
      [this]() { syncMutex_.unlock(); },
      [this]() {
        counters_.resetAfterFork();
        syncMutex_.unlock();
      });
}

template<typename Tag>

folly::rcu_domain< Tag >::rcu_domain ( const rcu_domain< Tag > &  )

delete

template<typename Tag>

folly::rcu_domain< Tag >::rcu_domain ( rcu_domain< Tag > &&  )

delete

template<typename Tag >

folly::rcu_domain< Tag >::~rcu_domain

(

)

Definition at line 48 of file Rcu-inl.h.

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

                             {
  detail::AtFork::unregisterHandler(this);
}

Member Function Documentation

template<typename Tag >

template<typename T >

void folly::rcu_domain< Tag >::call

(

T &&

cbin

)

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

Referenced by folly::rcu_retire().

                                   {
  auto node = new list_node;
  node->cb_ = [node, cb = std::forward<T>(cbin)]() {
    cb();
    delete node;
  };
  retire(node);
}

template<typename Tag >

void folly::rcu_domain< Tag >::half_sync ( bool  blocking, list_head &  cbs  )

private

Definition at line 146 of file Rcu-inl.h.

References cpp.ast::next(), and uint64_t.

                                                                  {
  uint64_t curr = version_.load(std::memory_order_acquire);
  auto next = curr + 1;

  // Push all work to a queue for moving through two epochs.  One
  // version is not enough because of late readers of the version_
  // counter in lock_shared.
  //
  // Note that for a similar reason we can't swap out the q here,
  // and instead drain it, so concurrent calls to call() are safe,
  // and will wait for the next epoch.
  q_.collect(queues_[0]);

  if (blocking) {
    counters_.waitForZero(next & 1);
  } else {
    if (counters_.readFull(next & 1) != 0) {
      return;
    }
  }

  // Run callbacks that have been through two epochs, and swap queues
  // for those only through a single epoch.
  finished.splice(queues_[1]);
  queues_[1].splice(queues_[0]);

  version_.store(next, std::memory_order_release);
  // Notify synchronous waiters in synchronize().
  turn_.completeTurn(curr);
}

template<typename Tag >

rcu_token folly::rcu_domain< Tag >::lock_shared

(

)

Definition at line 53 of file Rcu-inl.h.

                                       {
  auto idx = version_.load(std::memory_order_acquire);
  idx &= 1;
  counters_.increment(idx);

  return idx;
}

template<typename Tag>

rcu_domain& folly::rcu_domain< Tag >::operator= ( const rcu_domain< Tag > &  )

delete

template<typename Tag>

rcu_domain& folly::rcu_domain< Tag >::operator= ( rcu_domain< Tag > &&  )

delete

template<typename Tag >

void folly::rcu_domain< Tag >::retire ( list_node *  node )

noexcept

Definition at line 79 of file Rcu-inl.h.

References count, g(), folly::gen::move, now(), folly::detail::distributed_mutex::time(), and uint64_t.

Referenced by folly::rcu_obj_base< T, D, Tag >::retire().

                                                     {
  q_.push(node);

  // Note that it's likely we hold a read lock here,
  // so we can only half_sync(false).  half_sync(true)
  // or a synchronize() call might block forever.
  uint64_t time = std::chrono::duration_cast<std::chrono::milliseconds>(
                      std::chrono::steady_clock::now().time_since_epoch())
                      .count();
  auto syncTime = syncTime_.load(std::memory_order_relaxed);
  if (time > syncTime + syncTimePeriod_ &&
      syncTime_.compare_exchange_strong(
          syncTime, time, std::memory_order_relaxed)) {
    list_head finished;
    {
      std::lock_guard<std::mutex> g(syncMutex_);
      half_sync(false, finished);
    }
    // callbacks are called outside of syncMutex_
    finished.forEach(
        [&](list_node* item) { executor_->add(std::move(item->cb_)); });
  }
}

template<typename Tag >

void folly::rcu_domain< Tag >::synchronize ( )

noexcept

Definition at line 104 of file Rcu-inl.h.

References g(), and folly::gen::move.

                                           {
  auto curr = version_.load(std::memory_order_acquire);
  // Target is two epochs away.
  auto target = curr + 2;
  while (true) {
    // Try to assign ourselves to do the sync work.
    // If someone else is already assigned, we can wait for
    // the work to be finished by waiting on turn_.
    auto work = work_.load(std::memory_order_acquire);
    auto tmp = work;
    if (work < target && work_.compare_exchange_strong(tmp, target)) {
      list_head finished;
      {
        std::lock_guard<std::mutex> g(syncMutex_);
        while (version_.load(std::memory_order_acquire) < target) {
          half_sync(true, finished);
        }
      }
      // callbacks are called outside of syncMutex_
      finished.forEach(
          [&](list_node* node) { executor_->add(std::move(node->cb_)); });
      return;
    } else {
      if (version_.load(std::memory_order_acquire) >= target) {
        return;
      }
      std::atomic<uint32_t> cutoff{100};
      // Wait for someone to finish the work.
      turn_.tryWaitForTurn(work, cutoff, false);
    }
  }
}

template<typename Tag >

void folly::rcu_domain< Tag >::unlock_shared

(

rcu_token &&

token

)

Definition at line 62 of file Rcu-inl.h.

                                                     {
  DCHECK(0 == token.epoch_ || 1 == token.epoch_);
  counters_.decrement(token.epoch_);
}

Member Data Documentation

template<typename Tag>

detail::ThreadCachedInts<Tag> folly::rcu_domain< Tag >::counters_

private

Definition at line 350 of file Rcu.h.

template<typename Tag>

Executor* folly::rcu_domain< Tag >::executor_ {nullptr}

private

Definition at line 368 of file Rcu.h.

template<typename Tag>

detail::ThreadCachedLists<Tag> folly::rcu_domain< Tag >::q_

private

Definition at line 366 of file Rcu.h.

template<typename Tag>

list_head folly::rcu_domain< Tag >::queues_[2] {}

private

Definition at line 372 of file Rcu.h.

template<typename Tag>

bool folly::rcu_domain< Tag >::singleton_ = false

staticprivate

Definition at line 369 of file Rcu.h.

template<typename Tag>

std::mutex folly::rcu_domain< Tag >::syncMutex_

private

Definition at line 359 of file Rcu.h.

template<typename Tag>

std::atomic<uint64_t> folly::rcu_domain< Tag >::syncTime_ {0}

private

Definition at line 364 of file Rcu.h.

template<typename Tag>

constexpr uint64_t folly::rcu_domain< Tag >::syncTimePeriod_ {1600 * 2 }

staticprivate

Definition at line 363 of file Rcu.h.

template<typename Tag>

detail::TurnSequencer<std::atomic> folly::rcu_domain< Tag >::turn_

private

Definition at line 357 of file Rcu.h.

template<typename Tag>

std::atomic<uint64_t> folly::rcu_domain< Tag >::version_ {0}

private

Definition at line 352 of file Rcu.h.

template<typename Tag>

std::atomic<uint64_t> folly::rcu_domain< Tag >::work_ {0}

private

Definition at line 354 of file Rcu.h.

---

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

• proxygen/folly/folly/synchronization/Rcu.h
• proxygen/folly/folly/synchronization/Rcu-inl.h