folly::atomic_shared_ptr< T, Atom, CountedDetail > Class Template Reference

#include <AtomicSharedPtr.h>

Public Member Functions
	atomic_shared_ptr () noexcept
	atomic_shared_ptr (SharedPtr foo)
	atomic_shared_ptr (const atomic_shared_ptr< T > &)=delete
	~atomic_shared_ptr ()
void	operator= (SharedPtr desired)
void	operator= (const atomic_shared_ptr< T > &)=delete
bool	is_lock_free () const noexcept
SharedPtr	load (std::memory_order order=std::memory_order_seq_cst) const noexcept
	operator SharedPtr () const
void	store (SharedPtr n, std::memory_order order=std::memory_order_seq_cst)
SharedPtr	exchange (SharedPtr n, std::memory_order order=std::memory_order_seq_cst)
bool	compare_exchange_weak (SharedPtr &expected, const SharedPtr &n, std::memory_order mo=std::memory_order_seq_cst) noexcept
bool	compare_exchange_weak (SharedPtr &expected, const SharedPtr &n, std::memory_order success, std::memory_order failure)
bool	compare_exchange_weak (SharedPtr &expected, SharedPtr &&desired, std::memory_order mo=std::memory_order_seq_cst) noexcept
bool	compare_exchange_weak (SharedPtr &expected, SharedPtr &&desired, std::memory_order success, std::memory_order failure)
bool	compare_exchange_strong (SharedPtr &expected, const SharedPtr &n, std::memory_order mo=std::memory_order_seq_cst) noexcept
bool	compare_exchange_strong (SharedPtr &expected, const SharedPtr &n, std::memory_order success, std::memory_order failure)
bool	compare_exchange_strong (SharedPtr &expected, SharedPtr &&desired, std::memory_order mo=std::memory_order_seq_cst) noexcept
bool	compare_exchange_strong (SharedPtr &expected, SharedPtr &&desired, std::memory_order success, std::memory_order failure)

Private Types
using	SharedPtr = typename CountedDetail::template CountedPtr< T >
using	BasePtr = typename CountedDetail::counted_base
using	PackedPtr = folly::PackedSyncPtr< BasePtr >

Private Member Functions
void	add_external (BasePtr *res, int64_t c=0) const
void	release_external (PackedPtr &res, int64_t c=0) const
PackedPtr	get_newptr (const SharedPtr &n) const
PackedPtr	get_newptr (SharedPtr &&n) const
void	init ()
unsigned int	get_local_count (const PackedPtr &p) const
bool	owners_eq (PackedPtr &p1, BasePtr *p2)
SharedPtr	get_shared_ptr (const PackedPtr &p, bool inc=true) const
PackedPtr	takeOwnedBase (std::memory_order order) const noexcept
void	putOwnedBase (BasePtr *p, unsigned int count, std::memory_order mo) const noexcept

Private Attributes
AtomicStruct< PackedPtr, Atom >	ptr_

Static Private Attributes
static constexpr unsigned	EXTERNAL_OFFSET {0x2000}
static constexpr unsigned	ALIASED_PTR {0x4000}

Detailed Description

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>
class folly::atomic_shared_ptr< T, Atom, CountedDetail >

Definition at line 73 of file AtomicSharedPtr.h.

Member Typedef Documentation

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

using folly::atomic_shared_ptr< T, Atom, CountedDetail >::BasePtr = typename CountedDetail::counted_base

private

Definition at line 75 of file AtomicSharedPtr.h.

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

using folly::atomic_shared_ptr< T, Atom, CountedDetail >::PackedPtr = folly::PackedSyncPtr<BasePtr>

private

Definition at line 76 of file AtomicSharedPtr.h.

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

using folly::atomic_shared_ptr< T, Atom, CountedDetail >::SharedPtr = typename CountedDetail::template CountedPtr<T>

private

Definition at line 74 of file AtomicSharedPtr.h.

Constructor & Destructor Documentation

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr ( )

inlinenoexcept

Definition at line 79 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::init().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr().

                               {
    init();
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr ( SharedPtr  foo )

inlineexplicit

Definition at line 82 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr(), folly::gen::move, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

      : atomic_shared_ptr() {
    store(std::move(foo));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr ( const atomic_shared_ptr< T > &  )

delete

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

folly::atomic_shared_ptr< T, Atom, CountedDetail >::~atomic_shared_ptr ( )

inline

Definition at line 88 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

                       {
    store(SharedPtr(nullptr));
  }

Member Function Documentation

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::add_external ( BasePtr *  res, int64_t  c = 0  ) const

inlineprivate

Definition at line 237 of file AtomicSharedPtr.h.

References c, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::EXTERNAL_OFFSET.

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr().

                                                       {
    assert(res);
    CountedDetail::inc_shared_count(res, EXTERNAL_OFFSET + c);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong ( SharedPtr &  expected, const SharedPtr &  n, std::memory_order  mo = std::memory_order_seq_cst  )

inlinenoexcept

Definition at line 191 of file AtomicSharedPtr.h.

References folly::detail::default_failure_memory_order().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong().

                                                             {
    return compare_exchange_strong(
        expected, n, mo, detail::default_failure_memory_order(mo));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong ( SharedPtr &  expected, const SharedPtr &  n, std::memory_order  success, std::memory_order  failure  )

inline

Definition at line 198 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak().

                                 {
    auto local_expected = expected;
    do {
      if (compare_exchange_weak(expected, n, success, failure)) {
        return true;
      }
    } while (local_expected == expected);

    return false;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong ( SharedPtr &  expected, SharedPtr &&  desired, std::memory_order  mo = std::memory_order_seq_cst  )

inlinenoexcept

Definition at line 212 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong(), and folly::detail::default_failure_memory_order().

                                                             {
    return compare_exchange_strong(
        expected, desired, mo, detail::default_failure_memory_order(mo));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong ( SharedPtr &  expected, SharedPtr &&  desired, std::memory_order  success, std::memory_order  failure  )

inline

Definition at line 219 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong().

                                 {
    return compare_exchange_strong(expected, desired, success, failure);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak ( SharedPtr &  expected, const SharedPtr &  n, std::memory_order  mo = std::memory_order_seq_cst  )

inlinenoexcept

Definition at line 140 of file AtomicSharedPtr.h.

References folly::detail::default_failure_memory_order().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_strong(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak().

                                                             {
    return compare_exchange_weak(
        expected, n, mo, detail::default_failure_memory_order(mo));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak ( SharedPtr &  expected, const SharedPtr &  n, std::memory_order  success, std::memory_order  failure  )

inline

Definition at line 147 of file AtomicSharedPtr.h.

References folly::PackedSyncPtr< T >::get(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_shared_ptr(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::owners_eq(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::ptr_, folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase().

                                 {
    auto newptr = get_newptr(n);
    PackedPtr oldptr, expectedptr;

    oldptr = takeOwnedBase(success);
    if (!owners_eq(oldptr, CountedDetail::get_counted_base(expected))) {
      expected = get_shared_ptr(oldptr, false);
      release_external(newptr);
      return false;
    }
    expectedptr = oldptr; // Need oldptr to release if failed
    if (ptr_.compare_exchange_weak(expectedptr, newptr, success, failure)) {
      if (oldptr.get()) {
        release_external(oldptr, -1);
      }
      return true;
    } else {
      if (oldptr.get()) {
        expected = get_shared_ptr(oldptr, false);
      } else {
        expected = SharedPtr(nullptr);
      }
      release_external(newptr);
      return false;
    }
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak ( SharedPtr &  expected, SharedPtr &&  desired, std::memory_order  mo = std::memory_order_seq_cst  )

inlinenoexcept

Definition at line 177 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), and folly::detail::default_failure_memory_order().

                                                             {
    return compare_exchange_weak(
        expected, desired, mo, detail::default_failure_memory_order(mo));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak ( SharedPtr &  expected, SharedPtr &&  desired, std::memory_order  success, std::memory_order  failure  )

inline

Definition at line 184 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak().

                                 {
    return compare_exchange_weak(expected, desired, success, failure);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

SharedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange ( SharedPtr  n, std::memory_order  order = std::memory_order_seq_cst  )

inline

Definition at line 124 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_shared_ptr(), folly::gen::move, order, folly::atomic_shared_ptr< T, Atom, CountedDetail >::ptr_, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external().

                                                         {
    auto newptr = get_newptr(std::move(n));
    auto old = ptr_.exchange(newptr, order);

    SharedPtr old_ptr;

    if (old.get()) {
      old_ptr = get_shared_ptr(old);
      release_external(old);
    }

    return old_ptr;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

unsigned int folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_local_count ( const PackedPtr &  p ) const

inlineprivate

Definition at line 307 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR, and folly::PackedSyncPtr< T >::extra().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::putOwnedBase(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase().

                                                         {
    return p.extra() & ~ALIASED_PTR;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

PackedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr ( const SharedPtr &  n ) const

inlineprivate

Definition at line 250 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::add_external(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR, count, folly::data(), and folly::PackedSyncPtr< T >::init().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

                                                 {
    BasePtr* newval;
    unsigned count = 0;
    if (!n) {
      newval = nullptr;
    } else {
      newval = CountedDetail::get_counted_base(n);
      if (n.get() != CountedDetail::template get_shared_ptr<T>(newval)) {
        // This is an aliased sharedptr.  Make an un-aliased one
        // by wrapping in *another* shared_ptr.
        auto data = CountedDetail::template make_ptr<SharedPtr>(n);
        newval = CountedDetail::get_counted_base(data);
        count = ALIASED_PTR;
        // (add external must happen before data goes out of scope)
        add_external(newval);
      } else {
        add_external(newval);
      }
    }

    PackedPtr newptr;
    newptr.init(newval, count);

    return newptr;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

PackedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr ( SharedPtr &&  n ) const

inlineprivate

Definition at line 275 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::add_external(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR, count, folly::data(), folly::PackedSyncPtr< T >::init(), and folly::gen::move.

                                            {
    BasePtr* newval;
    unsigned count = 0;
    if (!n) {
      newval = nullptr;
    } else {
      newval = CountedDetail::get_counted_base(n);
      if (n.get() != CountedDetail::template get_shared_ptr<T>(newval)) {
        // This is an aliased sharedptr.  Make an un-aliased one
        // by wrapping in *another* shared_ptr.
        auto data = CountedDetail::template make_ptr<SharedPtr>(std::move(n));
        newval = CountedDetail::get_counted_base(data);
        count = ALIASED_PTR;
        CountedDetail::release_ptr(data);
        add_external(newval, -1);
      } else {
        CountedDetail::release_ptr(n);
        add_external(newval, -1);
      }
    }

    PackedPtr newptr;
    newptr.init(newval, count);

    return newptr;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

SharedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_shared_ptr ( const PackedPtr &  p, bool  inc = true  ) const

inlineprivate

Definition at line 322 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR, folly::PackedSyncPtr< T >::extra(), and folly::PackedSyncPtr< T >::get().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::load().

                                                                      {
    bool aliased = p.extra() & ALIASED_PTR;

    auto res = CountedDetail::template get_shared_ptr_from_counted_base<T>(
        p.get(), inc);
    if (aliased) {
      auto aliasedp =
          CountedDetail::template get_shared_ptr_from_counted_base<SharedPtr>(
              p.get());
      res = *aliasedp;
    }
    return res;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::init ( )

inlineprivate

Definition at line 301 of file AtomicSharedPtr.h.

References folly::data(), folly::PackedSyncPtr< T >::init(), and folly::AtomicStruct< T, Atom >::store().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr().

              {
    PackedPtr data;
    data.init();
    ptr_.store(data);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::is_lock_free ( ) const

inlinenoexcept

Definition at line 96 of file AtomicSharedPtr.h.

                                     {
    // lock free unless more than EXTERNAL_OFFSET threads are
    // contending and they all get unlucky and scheduled out during
    // load().
    //
    // TODO: Could use a lock-free external map to fix this
    // corner case.
    return true;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

SharedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::load ( std::memory_order  order = std::memory_order_seq_cst ) const

inlinenoexcept

Definition at line 106 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_shared_ptr(), folly::fibers::local(), order, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator SharedPtr().

               {
    auto local = takeOwnedBase(order);
    return get_shared_ptr(local, false);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator SharedPtr ( ) const

inline

Definition at line 112 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::load().

                               {
    return load();
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator= ( SharedPtr  desired )

inline

Definition at line 91 of file AtomicSharedPtr.h.

References folly::gen::move, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

                                      {
    store(std::move(desired));
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator= ( const atomic_shared_ptr< T > &  )

delete

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

bool folly::atomic_shared_ptr< T, Atom, CountedDetail >::owners_eq ( PackedPtr &  p1, BasePtr *  p2  )

inlineprivate

Definition at line 312 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR, folly::PackedSyncPtr< T >::extra(), and folly::PackedSyncPtr< T >::get().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak().

                                             {
    bool aliased1 = p1.extra() & ALIASED_PTR;
    if (aliased1) {
      auto p1a = CountedDetail::template get_shared_ptr_from_counted_base<T>(
          p1.get(), false);
      return CountedDetail::get_counted_base(p1a) == p2;
    }
    return p1.get() == p2;
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::putOwnedBase ( BasePtr *  p, unsigned int  count, std::memory_order  mo  ) const

inlineprivatenoexcept

Definition at line 375 of file AtomicSharedPtr.h.

References folly::AtomicStruct< T, Atom >::compare_exchange_weak(), count, folly::PackedSyncPtr< T >::extra(), folly::PackedSyncPtr< T >::get(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_local_count(), folly::AtomicStruct< T, Atom >::load(), and folly::fibers::local().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase().

               {
    PackedPtr local = ptr_.load(std::memory_order_acquire);
    while (true) {
      if (local.get() != p) {
        break;
      }
      auto newlocal = local;
      if (get_local_count(local) > count) {
        newlocal.setExtra(local.extra() - count);
      } else {
        // Otherwise it may be the same pointer, but someone else won
        // the compare_exchange below, local count was already made
        // global.  We decrement the global count directly instead of
        // the local one.
        break;
      }
      if (ptr_.compare_exchange_weak(local, newlocal, mo)) {
        return;
      }
    }

    CountedDetail::template release_shared<T>(p, count);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external ( PackedPtr &  res, int64_t  c = 0  ) const

inlineprivate

Definition at line 241 of file AtomicSharedPtr.h.

References c, count, diff(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::EXTERNAL_OFFSET, folly::PackedSyncPtr< T >::get(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_local_count(), and int64_t.

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

                                                             {
    if (!res.get()) {
      return;
    }
    int64_t count = get_local_count(res) + c;
    int64_t diff = EXTERNAL_OFFSET - count;
    assert(diff >= 0);
    CountedDetail::template release_shared<T>(res.get(), diff);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

void folly::atomic_shared_ptr< T, Atom, CountedDetail >::store ( SharedPtr  n, std::memory_order  order = std::memory_order_seq_cst  )

inline

Definition at line 116 of file AtomicSharedPtr.h.

References folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr(), folly::gen::move, order, folly::atomic_shared_ptr< T, Atom, CountedDetail >::ptr_, and folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::atomic_shared_ptr(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::operator=(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::~atomic_shared_ptr().

                                                         {
    auto newptr = get_newptr(std::move(n));
    auto old = ptr_.exchange(newptr, order);
    release_external(old);
  }

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

PackedPtr folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase ( std::memory_order  order ) const

inlineprivatenoexcept

Definition at line 342 of file AtomicSharedPtr.h.

References folly::AtomicStruct< T, Atom >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::EXTERNAL_OFFSET, folly::PackedSyncPtr< T >::extra(), folly::PackedSyncPtr< T >::get(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_local_count(), folly::AtomicStruct< T, Atom >::load(), folly::fibers::local(), order, folly::atomic_shared_ptr< T, Atom, CountedDetail >::putOwnedBase(), folly::PackedSyncPtr< T >::setExtra(), and folly::fibers::yield().

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::load().

                                                                {
    PackedPtr local, newlocal;
    local = ptr_.load(std::memory_order_acquire);
    while (true) {
      if (!local.get()) {
        return local;
      }
      newlocal = local;
      if (get_local_count(newlocal) + 1 > EXTERNAL_OFFSET) {
        // spinlock in the rare case we have more than
        // EXTERNAL_OFFSET threads trying to access at once.
        std::this_thread::yield();
        // Force DeterministicSchedule to choose a different thread
        local = ptr_.load(std::memory_order_acquire);
      } else {
        newlocal.setExtra(newlocal.extra() + 1);
        assert(get_local_count(newlocal) > 0);
        if (ptr_.compare_exchange_weak(local, newlocal, order)) {
          break;
        }
      }
    }

    // Check if we need to push a batch from local -> global
    auto batchcount = EXTERNAL_OFFSET / 2;
    if (get_local_count(newlocal) > batchcount) {
      CountedDetail::inc_shared_count(newlocal.get(), batchcount);
      putOwnedBase(newlocal.get(), batchcount, order);
    }

    return newlocal;
  }

Member Data Documentation

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

constexpr unsigned folly::atomic_shared_ptr< T, Atom, CountedDetail >::ALIASED_PTR {0x4000}

staticprivate

Definition at line 233 of file AtomicSharedPtr.h.

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_local_count(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_newptr(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::get_shared_ptr(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::owners_eq().

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

constexpr unsigned folly::atomic_shared_ptr< T, Atom, CountedDetail >::EXTERNAL_OFFSET {0x2000}

staticprivate

Definition at line 231 of file AtomicSharedPtr.h.

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::add_external(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::release_external(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase().

template<typename T, template< typename > class Atom = std::atomic, typename CountedDetail = detail::shared_ptr_internals>

AtomicStruct<PackedPtr, Atom> folly::atomic_shared_ptr< T, Atom, CountedDetail >::ptr_

mutableprivate

Definition at line 235 of file AtomicSharedPtr.h.

Referenced by folly::atomic_shared_ptr< T, Atom, CountedDetail >::compare_exchange_weak(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::exchange(), and folly::atomic_shared_ptr< T, Atom, CountedDetail >::store().

---

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

• proxygen/folly/folly/concurrency/AtomicSharedPtr.h