folly::AtomicCoreCachedSharedPtr< T, kNumSlots > Class Template Reference

#include <CoreCachedSharedPtr.h>

Classes
struct	Slots

Public Member Functions
	AtomicCoreCachedSharedPtr (const std::shared_ptr< T > &p=nullptr)
	~AtomicCoreCachedSharedPtr ()
void	reset (const std::shared_ptr< T > &p=nullptr)
std::shared_ptr< T >	get () const

Private Types
using	Holder = std::shared_ptr< T >

Private Attributes
std::atomic< Slots * >	slots_ {nullptr}

Detailed Description

template<class T, size_t kNumSlots = 64>
class folly::AtomicCoreCachedSharedPtr< T, kNumSlots >

This class creates core-local caches for a given shared_ptr, to mitigate contention when acquiring/releasing it.

All methods are threadsafe. Hazard pointers are used to avoid use-after-free for concurrent reset() and get() operations.

Concurrent reset()s are sequenced with respect to each other: the sharded shared_ptrs will always all be set to the same value. get()s will never see a newer pointer on one core, and an older pointer on another after a subsequent thread migration.

Definition at line 100 of file CoreCachedSharedPtr.h.

Member Typedef Documentation

template<class T, size_t kNumSlots = 64>

using folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::Holder = std::shared_ptr<T>

private

Definition at line 142 of file CoreCachedSharedPtr.h.

Constructor & Destructor Documentation

template<class T, size_t kNumSlots = 64>

folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::AtomicCoreCachedSharedPtr ( const std::shared_ptr< T > &  p = nullptr )

inlineexplicit

Definition at line 102 of file CoreCachedSharedPtr.h.

References folly::CoreCachedSharedPtr< T, kNumSlots >::reset().

                                                                          {
    reset(p);
  }

template<class T, size_t kNumSlots = 64>

folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::~AtomicCoreCachedSharedPtr ( )

inline

Definition at line 106 of file CoreCachedSharedPtr.h.

References folly::CoreCachedSharedPtr< T, kNumSlots >::slots_.

                               {
    auto slots = slots_.load(std::memory_order_acquire);
    // Delete of AtomicCoreCachedSharedPtr must be synchronized, no
    // need for stlots->retire().
    if (slots) {
      delete slots;
    }
  }

Member Function Documentation

template<class T, size_t kNumSlots = 64>

std::shared_ptr<T> folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::get ( ) const

inline

Definition at line 132 of file CoreCachedSharedPtr.h.

References folly::AccessSpreader< Atom >::current(), and folly::CoreCachedSharedPtr< T, kNumSlots >::slots_.

                               {
    folly::hazptr_local<1> hazptr;
    auto slots = hazptr[0].get_protected(slots_);
    if (!slots) {
      return nullptr;
    }
    return (slots->slots_)[AccessSpreader<>::current(kNumSlots)];
  }

template<class T, size_t kNumSlots = 64>

void folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::reset ( const std::shared_ptr< T > &  p = nullptr )

inline

Definition at line 115 of file CoreCachedSharedPtr.h.

References folly::enumerate(), and folly::CoreCachedSharedPtr< T, kNumSlots >::slots_.

                                                  {
    auto newslots = folly::make_unique<Slots>();
    // Allocate each Holder in a different CoreRawAllocator stripe to
    // prevent false sharing. Their control blocks will be adjacent
    // thanks to allocate_shared().
    for (auto slot : folly::enumerate(newslots->slots_)) {
      auto alloc = getCoreAllocator<Holder, kNumSlots>(slot.index);
      auto holder = std::allocate_shared<Holder>(alloc, p);
      *slot = std::shared_ptr<T>(holder, p.get());
    }

    auto oldslots = slots_.exchange(newslots.release());
    if (oldslots) {
      oldslots->retire();
    }
  }

Member Data Documentation

template<class T, size_t kNumSlots = 64>

std::atomic<Slots*> folly::AtomicCoreCachedSharedPtr< T, kNumSlots >::slots_ {nullptr}

private

Definition at line 146 of file CoreCachedSharedPtr.h.

---

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

• proxygen/folly/folly/concurrency/CoreCachedSharedPtr.h