proxygen: folly::AtomicStruct< T, Atom > Class Template Reference

#include <AtomicStruct.h>

Public Member Functions
	AtomicStruct ()=default

	~AtomicStruct ()=default

	AtomicStruct (AtomicStruct< T > const &)=delete

AtomicStruct< T > &	operator= (AtomicStruct< T > const &)=delete

constexpr	AtomicStruct (T v) noexcept

bool	is_lock_free () const noexcept

bool	compare_exchange_strong (T &v0, T v1, std::memory_order mo=std::memory_order_seq_cst) noexcept

bool	compare_exchange_strong (T &v0, T v1, std::memory_order success, std::memory_order failure) noexcept

bool	compare_exchange_weak (T &v0, T v1, std::memory_order mo=std::memory_order_seq_cst) noexcept

bool	compare_exchange_weak (T &v0, T v1, std::memory_order success, std::memory_order failure) noexcept

T	exchange (T v, std::memory_order mo=std::memory_order_seq_cst) noexcept

	operator T () const noexcept

T	load (std::memory_order mo=std::memory_order_seq_cst) const noexcept

T	operator= (T v) noexcept

void	store (T v, std::memory_order mo=std::memory_order_seq_cst) noexcept

Private Types
using	Raw = _t< detail::AtomicStructRaw< constexpr_log2_ceil(sizeof(T))>>

Static Private Member Functions
static Raw	encode (T v) noexcept

static T	decode (Raw d) noexcept

Private Attributes
Atom< Raw >	data

Detailed Description

template<typename T, template< typename > class Atom = std::atomic>
class folly::AtomicStruct< T, Atom >

AtomicStruct<T> work like C++ atomics, but can be used on any POD type <= 8 bytes.

Definition at line 55 of file AtomicStruct.h.

Member Typedef Documentation

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

using folly::AtomicStruct< T, Atom >::Raw = _t<detail::AtomicStructRaw<constexpr_log2_ceil(sizeof(T))>>

private

Definition at line 57 of file AtomicStruct.h.

Constructor & Destructor Documentation

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

folly::AtomicStruct< T, Atom >::AtomicStruct ( )

default

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

folly::AtomicStruct< T, Atom >::~AtomicStruct ( )

default

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

folly::AtomicStruct< T, Atom >::AtomicStruct ( AtomicStruct< T > const & )

delete

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

constexpr folly::AtomicStruct< T, Atom >::AtomicStruct ( T v )

inlinenoexcept

Definition at line 87 of file AtomicStruct.h.

87 : data(encode(v)) {}

folly::pushmi

Definition: boosters.h:30

folly::AtomicStruct::data

Atom< Raw > data

Definition: AtomicStruct.h:59

folly::AtomicStruct::encode

static Raw encode(T v) noexcept

Definition: AtomicStruct.h:67

Member Function Documentation

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

bool folly::AtomicStruct< T, Atom >::compare_exchange_strong	(	T &	v0,
		T	v1,
		std::memory_order	mo = `std::memory_order_seq_cst`
	)

inlinenoexcept

Definition at line 93 of file AtomicStruct.h.

Referenced by folly::IndexedMemPool< T, NumLocalLists_, LocalListLimit_, Atom, Traits >::localPop(), and folly::IndexedMemPool< T, NumLocalLists_, LocalListLimit_, Atom, Traits >::localPush().

                                                              {
     return compare_exchange_strong(
         v0, v1, mo, detail::default_failure_memory_order(mo));
   }

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

bool folly::AtomicStruct< T, Atom >::compare_exchange_strong	(	T &	v0,
		T	v1,
		std::memory_order	success,
		std::memory_order	failure
	)

inlinenoexcept

Definition at line 100 of file AtomicStruct.h.

                                         {
     Raw d0 = encode(v0);
     bool rv = data.compare_exchange_strong(d0, encode(v1), success, failure);
     if (!rv) {
       v0 = decode(d0);
     }
     return rv;
   }

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

bool folly::AtomicStruct< T, Atom >::compare_exchange_weak	(	T &	v0,
		T	v1,
		std::memory_order	mo = `std::memory_order_seq_cst`
	)

inlinenoexcept

Definition at line 113 of file AtomicStruct.h.

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

                                                              {
     return compare_exchange_weak(
         v0, v1, mo, detail::default_failure_memory_order(mo));
   }

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

bool folly::AtomicStruct< T, Atom >::compare_exchange_weak	(	T &	v0,
		T	v1,
		std::memory_order	success,
		std::memory_order	failure
	)

inlinenoexcept

Definition at line 120 of file AtomicStruct.h.

                                         {
     Raw d0 = encode(v0);
     bool rv = data.compare_exchange_weak(d0, encode(v1), success, failure);
     if (!rv) {
       v0 = decode(d0);
     }
     return rv;
   }

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

static T folly::AtomicStruct< T, Atom >::decode ( Raw d )

inlinestaticprivatenoexcept

Definition at line 75 of file AtomicStruct.h.

                                   {
     T v;
     memcpy(static_cast<void*>(&v), &d, sizeof(T));
     return v;
   }

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

static Raw folly::AtomicStruct< T, Atom >::encode ( T v )

inlinestaticprivatenoexcept

Definition at line 67 of file AtomicStruct.h.

                                   {
     // we expect the compiler to optimize away the memcpy, but without
     // it we would violate strict aliasing rules
     Raw d = 0;
     memcpy(&d, static_cast<void*>(&v), sizeof(T));
     return d;
   }

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

T folly::AtomicStruct< T, Atom >::exchange	(	T	v,
		std::memory_order	mo = `std::memory_order_seq_cst`
	)

inlinenoexcept

Definition at line 133 of file AtomicStruct.h.

                                                                          {
     return decode(data.exchange(encode(v), mo));
   }

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

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

inlinenoexcept

Definition at line 89 of file AtomicStruct.h.

                                      {
     return data.is_lock_free();
   }

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

T folly::AtomicStruct< T, Atom >::load ( std::memory_order mo = std::memory_order_seq_cst ) const

inlinenoexcept

Definition at line 141 of file AtomicStruct.h.

Referenced by folly::IndexedMemPool< T, NumLocalLists_, LocalListLimit_, Atom, Traits >::localPop(), folly::IndexedMemPool< T, NumLocalLists_, LocalListLimit_, Atom, Traits >::localPush(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::putOwnedBase(), folly::MemoryIdlerTimeout::runLoopCallback(), folly::atomic_shared_ptr< T, Atom, CountedDetail >::takeOwnedBase(), and TEST().

                                                                       {
     return decode(data.load(mo));
   }

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

folly::AtomicStruct< T, Atom >::operator T ( ) const

inlinenoexcept

Definition at line 137 of file AtomicStruct.h.

References fizz::decode().

                                 {
     return decode(data);
   }

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

AtomicStruct<T>& folly::AtomicStruct< T, Atom >::operator= ( AtomicStruct< T > const & )

delete

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

T folly::AtomicStruct< T, Atom >::operator= ( T v )

inlinenoexcept

Definition at line 145 of file AtomicStruct.h.

                             {
     return decode(data = encode(v));
   }

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

void folly::AtomicStruct< T, Atom >::store	(	T	v,
		std::memory_order	mo = `std::memory_order_seq_cst`
	)

inlinenoexcept

Definition at line 149 of file AtomicStruct.h.

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

                                                                          {
     data.store(encode(v), mo);
   }

Member Data Documentation

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

Atom<Raw> folly::AtomicStruct< T, Atom >::data

private

Definition at line 59 of file AtomicStruct.h.

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

proxygen/folly/folly/synchronization/AtomicStruct.h

Public Member Functions

Private Types

Static Private Member Functions

Private Attributes

Detailed Description

template<typename T, template< typename > class Atom = std::atomic> class folly::AtomicStruct< T, Atom >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T, template< typename > class Atom = std::atomic>
class folly::AtomicStruct< T, Atom >