folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type > Class Template Reference

#include <ConcurrentSkipList-inl.h>

Public Member Functions
	NodeRecycler (const NodeAlloc &alloc)
	NodeRecycler ()
	~NodeRecycler ()
void	add (NodeType *node)
int	addRef ()
int	releaseRef ()
NodeAlloc &	alloc ()

Private Member Functions
int	refs () const

Private Attributes
std::unique_ptr< std::vector< NodeType * > >	nodes_
std::atomic< int32_t >	refs_
std::atomic< bool >	dirty_
MicroSpinLock	lock_
NodeAlloc	alloc_

Detailed Description

template<typename NodeType, typename NodeAlloc>
class folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >

Definition at line 259 of file ConcurrentSkipList-inl.h.

Constructor & Destructor Documentation

template<typename NodeType , typename NodeAlloc >

folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::NodeRecycler ( const NodeAlloc &  alloc )

inlineexplicit

Definition at line 265 of file ConcurrentSkipList-inl.h.

      : refs_(0), dirty_(false), alloc_(alloc) {
    lock_.init();
  }

template<typename NodeType , typename NodeAlloc >

folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::NodeRecycler ( )

inlineexplicit

Definition at line 270 of file ConcurrentSkipList-inl.h.

                          : refs_(0), dirty_(false) {
    lock_.init();
  }

template<typename NodeType , typename NodeAlloc >

folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::~NodeRecycler ( )

inline

Definition at line 274 of file ConcurrentSkipList-inl.h.

References destroy(), and refs.

                  {
    CHECK_EQ(refs(), 0);
    if (nodes_) {
      for (auto& node : *nodes_) {
        NodeType::destroy(alloc_, node);
      }
    }
  }

Member Function Documentation

template<typename NodeType , typename NodeAlloc >

void folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::add ( NodeType *  node )

inline

Definition at line 283 of file ConcurrentSkipList-inl.h.

References g(), and refs.

                           {
    std::lock_guard<MicroSpinLock> g(lock_);
    if (nodes_.get() == nullptr) {
      nodes_ = std::make_unique<std::vector<NodeType*>>(1, node);
    } else {
      nodes_->push_back(node);
    }
    DCHECK_GT(refs(), 0);
    dirty_.store(true, std::memory_order_relaxed);
  }

template<typename NodeType , typename NodeAlloc >

int folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::addRef ( )

inline

Definition at line 294 of file ConcurrentSkipList-inl.h.

               {
    return refs_.fetch_add(1, std::memory_order_relaxed);
  }

template<typename NodeType , typename NodeAlloc >

NodeAlloc& folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::alloc ( )

inline

Definition at line 335 of file ConcurrentSkipList-inl.h.

                     {
    return alloc_;
  }

template<typename NodeType , typename NodeAlloc >

int folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::refs ( ) const

inlineprivate

Definition at line 340 of file ConcurrentSkipList-inl.h.

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

template<typename NodeType , typename NodeAlloc >

int folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::releaseRef ( )

inline

Definition at line 298 of file ConcurrentSkipList-inl.h.

References destroy(), g(), LIKELY, and refs.

                   {
    // We don't expect to clean the recycler immediately everytime it is OK
    // to do so. Here, it is possible that multiple accessors all release at
    // the same time but nobody would clean the recycler here. If this
    // happens, the recycler will usually still get cleaned when
    // such a race doesn't happen. The worst case is the recycler will
    // eventually get deleted along with the skiplist.
    if (LIKELY(!dirty_.load(std::memory_order_relaxed) || refs() > 1)) {
      return refs_.fetch_add(-1, std::memory_order_relaxed);
    }

    std::unique_ptr<std::vector<NodeType*>> newNodes;
    {
      std::lock_guard<MicroSpinLock> g(lock_);
      if (nodes_.get() == nullptr || refs() > 1) {
        return refs_.fetch_add(-1, std::memory_order_relaxed);
      }
      // once refs_ reaches 1 and there is no other accessor, it is safe to
      // remove all the current nodes in the recycler, as we already acquired
      // the lock here so no more new nodes can be added, even though new
      // accessors may be added after that.
      newNodes.swap(nodes_);
      dirty_.store(false, std::memory_order_relaxed);
    }

    // TODO(xliu) should we spawn a thread to do this when there are large
    // number of nodes in the recycler?
    for (auto& node : *newNodes) {
      NodeType::destroy(alloc_, node);
    }

    // decrease the ref count at the very end, to minimize the
    // chance of other threads acquiring lock_ to clear the deleted
    // nodes again.
    return refs_.fetch_add(-1, std::memory_order_relaxed);
  }

Member Data Documentation

template<typename NodeType , typename NodeAlloc >

NodeAlloc folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::alloc_

private

Definition at line 348 of file ConcurrentSkipList-inl.h.

template<typename NodeType , typename NodeAlloc >

std::atomic<bool> folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::dirty_

private

Definition at line 346 of file ConcurrentSkipList-inl.h.

template<typename NodeType , typename NodeAlloc >

MicroSpinLock folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::lock_

private

Definition at line 347 of file ConcurrentSkipList-inl.h.

template<typename NodeType , typename NodeAlloc >

std::unique_ptr<std::vector<NodeType*> > folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::nodes_

private

Definition at line 344 of file ConcurrentSkipList-inl.h.

template<typename NodeType , typename NodeAlloc >

std::atomic<int32_t> folly::detail::NodeRecycler< NodeType, NodeAlloc, typename std::enable_if< !NodeType::template DestroyIsNoOp< NodeAlloc >::value >::type >::refs_

private

Definition at line 345 of file ConcurrentSkipList-inl.h.

---

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

• proxygen/folly/folly/ConcurrentSkipList-inl.h