atomic File Reference

#include <yvals.h>
#include <type_traits>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <limits.h>
#include <xatomic.h>
#include <xxatomic>

Classes
struct	atomic< _Ty >
struct	atomic_flag
struct	_Atomic_impl< _Bytes >
struct	_Atomic_impl< 1U >
struct	_Atomic_impl< 2U >
struct	_Atomic_impl< 4U >
struct	_Atomic_impl< 8U >
struct	_Atomic_base< _Ty, _Bytes >
struct	atomic< _Ty >

Macros
#define	_ATOMIC_
#define	ATOMIC_CHAR_LOCK_FREE   _ATOMIC_CHAR_LOCK_FREE
#define	ATOMIC_CHAR16_T_LOCK_FREE   _ATOMIC_CHAR16_T_LOCK_FREE
#define	ATOMIC_CHAR32_T_LOCK_FREE   _ATOMIC_CHAR32_T_LOCK_FREE
#define	ATOMIC_WCHAR_T_LOCK_FREE   _ATOMIC_WCHAR_T_LOCK_FREE
#define	ATOMIC_SHORT_LOCK_FREE   _ATOMIC_SHORT_LOCK_FREE
#define	ATOMIC_INT_LOCK_FREE   _ATOMIC_INT_LOCK_FREE
#define	ATOMIC_LONG_LOCK_FREE   _ATOMIC_LONG_LOCK_FREE
#define	ATOMIC_LLONG_LOCK_FREE   _ATOMIC_LLONG_LOCK_FREE
#define	ATOMIC_FLAG_INIT   {0}
#define	ATOMIC_VAR_INIT(_Val)   { _Val }
#define	_ATOMIC_ITYPE   _Atomic_bool
#define	_ITYPE   bool
#define	_ISIZE   1
#define	_ATOMIC_ITYPE   _Atomic_char
#define	_ITYPE   char
#define	_ISIZE   1
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_schar
#define	_ITYPE   signed char
#define	_ISIZE   1
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_uchar
#define	_ITYPE   unsigned char
#define	_ISIZE   1
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_char16_t
#define	_ITYPE   char16_t
#define	_ISIZE   2
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_char32_t
#define	_ITYPE   char32_t
#define	_ISIZE   4
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_wchar_t
#define	_ITYPE   wchar_t
#define	_ISIZE   _WCHAR_T_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_HAS_NO_SPECIALIZATION
#define	_ATOMIC_ITYPE   _Atomic_short
#define	_ITYPE   short
#define	_ISIZE   _SHORT_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_ushort
#define	_ITYPE   unsigned short
#define	_ISIZE   _SHORT_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_int
#define	_ITYPE   int
#define	_ISIZE   _INT_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_uint
#define	_ITYPE   unsigned int
#define	_ISIZE   _INT_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_long
#define	_ITYPE   long
#define	_ISIZE   _LONG_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_ulong
#define	_ITYPE   unsigned long
#define	_ISIZE   _LONG_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_llong
#define	_ITYPE   long long
#define	_ISIZE   _LONGLONG_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_ullong
#define	_ITYPE   unsigned long long
#define	_ISIZE   _LONGLONG_SIZE
#define	_ATOMIC_HAS_ARITHMETIC_OPS
#define	_ATOMIC_ITYPE   _Atomic_address
#define	_ITYPE   void *
#define	_ISIZE   _ADDR_SIZE
#define	_ATOMIC_IS_ADDRESS_TYPE
#define	_ATOMIC_HAS_NO_SPECIALIZATION

Typedefs
typedef struct atomic_flag	atomic_flag
typedef atomic< bool >	atomic_bool
typedef atomic< char >	atomic_char
typedef atomic< signed char >	atomic_schar
typedef atomic< unsigned char >	atomic_uchar
typedef atomic< short >	atomic_short
typedef atomic< unsigned short >	atomic_ushort
typedef atomic< int >	atomic_int
typedef atomic< unsigned int >	atomic_uint
typedef atomic< long >	atomic_long
typedef atomic< unsigned long >	atomic_ulong
typedef atomic< long long >	atomic_llong
typedef atomic< unsigned long long >	atomic_ullong
typedef atomic< char16_t >	atomic_char16_t
typedef atomic< char32_t >	atomic_char32_t
typedef atomic< wchar_t >	atomic_wchar_t
typedef atomic< int8_t >	atomic_int8_t
typedef atomic< uint8_t >	atomic_uint8_t
typedef atomic< int16_t >	atomic_int16_t
typedef atomic< uint16_t >	atomic_uint16_t
typedef atomic< int32_t >	atomic_int32_t
typedef atomic< uint32_t >	atomic_uint32_t
typedef atomic< int64_t >	atomic_int64_t
typedef atomic< uint64_t >	atomic_uint64_t
typedef atomic< int_least8_t >	atomic_int_least8_t
typedef atomic< uint_least8_t >	atomic_uint_least8_t
typedef atomic< int_least16_t >	atomic_int_least16_t
typedef atomic< uint_least16_t >	atomic_uint_least16_t
typedef atomic< int_least32_t >	atomic_int_least32_t
typedef atomic< uint_least32_t >	atomic_uint_least32_t
typedef atomic< int_least64_t >	atomic_int_least64_t
typedef atomic< uint_least64_t >	atomic_uint_least64_t
typedef atomic< int_fast8_t >	atomic_int_fast8_t
typedef atomic< uint_fast8_t >	atomic_uint_fast8_t
typedef atomic< int_fast16_t >	atomic_int_fast16_t
typedef atomic< uint_fast16_t >	atomic_uint_fast16_t
typedef atomic< int_fast32_t >	atomic_int_fast32_t
typedef atomic< uint_fast32_t >	atomic_uint_fast32_t
typedef atomic< int_fast64_t >	atomic_int_fast64_t
typedef atomic< uint_fast64_t >	atomic_uint_fast64_t
typedef atomic< intptr_t >	atomic_intptr_t
typedef atomic< uintptr_t >	atomic_uintptr_t
typedef atomic< size_t >	atomic_size_t
typedef atomic< ptrdiff_t >	atomic_ptrdiff_t
typedef atomic< intmax_t >	atomic_intmax_t
typedef atomic< uintmax_t >	atomic_uintmax_t

Functions
_STD_BEGIN memory_order	_Get_memory_order (memory_order _Order)
template<class _Ty >
_Ty	kill_dependency (_Ty _Arg) _NOEXCEPT
template<class _Ty >
bool	atomic_is_lock_free (const volatile atomic< _Ty > *) _NOEXCEPT
template<class _Ty >
bool	atomic_is_lock_free (const atomic< _Ty > *) _NOEXCEPT
template<class _Ty >
void	atomic_init (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
void	atomic_init (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
void	atomic_store (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
void	atomic_store (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
void	atomic_store_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
void	atomic_store_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_load (const volatile atomic< _Ty > *) _NOEXCEPT
template<class _Ty >
_Ty	atomic_load (const atomic< _Ty > *) _NOEXCEPT
template<class _Ty >
_Ty	atomic_load_explicit (const volatile atomic< _Ty > *, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_load_explicit (const atomic< _Ty > *, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_exchange (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_exchange (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_exchange_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_exchange_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_weak (volatile atomic< _Ty > *, _Ty *, _Ty) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_weak (atomic< _Ty > *, _Ty *, _Ty) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_weak_explicit (volatile atomic< _Ty > *, _Ty *, _Ty, memory_order, memory_order) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_weak_explicit (atomic< _Ty > *, _Ty *, _Ty, memory_order, memory_order) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_strong (volatile atomic< _Ty > *, _Ty *, _Ty) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_strong (atomic< _Ty > *, _Ty *, _Ty) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_strong_explicit (volatile atomic< _Ty > *, _Ty *, _Ty, memory_order, memory_order) _NOEXCEPT
template<class _Ty >
bool	atomic_compare_exchange_strong_explicit (atomic< _Ty > *, _Ty *, _Ty, memory_order, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_add (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_add (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_add_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_add_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_sub (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_sub (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_sub_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_sub_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_and (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_and (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_and_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_and_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_or (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_or (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_or_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_or_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_xor (volatile atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_xor (atomic< _Ty > *, _Ty) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_xor_explicit (volatile atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
template<class _Ty >
_Ty	atomic_fetch_xor_explicit (atomic< _Ty > *, _Ty, memory_order) _NOEXCEPT
bool	atomic_flag_test_and_set (volatile atomic_flag *_Flag) _NOEXCEPT
bool	atomic_flag_test_and_set (atomic_flag *_Flag) _NOEXCEPT
bool	atomic_flag_test_and_set_explicit (volatile atomic_flag *_Flag, memory_order _Order) _NOEXCEPT
bool	atomic_flag_test_and_set_explicit (atomic_flag *_Flag, memory_order _Order) _NOEXCEPT
void	atomic_flag_clear (volatile atomic_flag *_Flag) _NOEXCEPT
void	atomic_flag_clear (atomic_flag *_Flag) _NOEXCEPT
void	atomic_flag_clear_explicit (volatile atomic_flag *_Flag, memory_order _Order) _NOEXCEPT
void	atomic_flag_clear_explicit (atomic_flag *_Flag, memory_order _Order) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_add (volatile atomic< _Ty * > *_Atom, ptrdiff_t _Value) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_add (atomic< _Ty * > *_Atom, ptrdiff_t _Value) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_add_explicit (volatile atomic< _Ty * > *_Atom, ptrdiff_t _Value, memory_order _Order) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_add_explicit (atomic< _Ty * > *_Atom, ptrdiff_t _Value, memory_order _Order) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_sub (volatile atomic< _Ty * > *_Atom, ptrdiff_t _Value) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_sub (atomic< _Ty * > *_Atom, ptrdiff_t _Value) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_sub_explicit (volatile atomic< _Ty * > *_Atom, ptrdiff_t _Value, memory_order _Order) _NOEXCEPT
template<class _Ty >
_Ty *	atomic_fetch_sub_explicit (atomic< _Ty * > *_Atom, ptrdiff_t _Value, memory_order _Order) _NOEXCEPT
void	atomic_thread_fence (memory_order _Order) _NOEXCEPT
void	atomic_signal_fence (memory_order _Order) _NOEXCEPT

Macro Definition Documentation

#define _ATOMIC_

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_ARITHMETIC_OPS

#define _ATOMIC_HAS_NO_SPECIALIZATION

#define _ATOMIC_HAS_NO_SPECIALIZATION

#define _ATOMIC_IS_ADDRESS_TYPE

#define _ATOMIC_ITYPE   _Atomic_bool

#define _ATOMIC_ITYPE   _Atomic_char

#define _ATOMIC_ITYPE   _Atomic_schar

#define _ATOMIC_ITYPE   _Atomic_uchar

#define _ATOMIC_ITYPE   _Atomic_char16_t

#define _ATOMIC_ITYPE   _Atomic_char32_t

#define _ATOMIC_ITYPE   _Atomic_wchar_t

#define _ATOMIC_ITYPE   _Atomic_short

#define _ATOMIC_ITYPE   _Atomic_ushort

#define _ATOMIC_ITYPE   _Atomic_int

#define _ATOMIC_ITYPE   _Atomic_uint

#define _ATOMIC_ITYPE   _Atomic_long

#define _ATOMIC_ITYPE   _Atomic_ulong

#define _ATOMIC_ITYPE   _Atomic_llong

#define _ATOMIC_ITYPE   _Atomic_ullong

#define _ATOMIC_ITYPE   _Atomic_address

#define _ISIZE   1

#define _ISIZE   1

#define _ISIZE   1

#define _ISIZE   1

#define _ISIZE   2

#define _ISIZE   4

#define _ISIZE   _WCHAR_T_SIZE

#define _ISIZE   _SHORT_SIZE

#define _ISIZE   _SHORT_SIZE

#define _ISIZE   _INT_SIZE

#define _ISIZE   _INT_SIZE

#define _ISIZE   _LONG_SIZE

#define _ISIZE   _LONG_SIZE

#define _ISIZE   _LONGLONG_SIZE

#define _ISIZE   _LONGLONG_SIZE

#define _ISIZE   _ADDR_SIZE

#define _ITYPE   bool

#define _ITYPE   char

#define _ITYPE   signed char

#define _ITYPE   unsigned char

#define _ITYPE   char16_t

#define _ITYPE   char32_t

#define _ITYPE   wchar_t

#define _ITYPE   short

#define _ITYPE   unsigned short

#define _ITYPE   int

#define _ITYPE   unsigned int

#define _ITYPE   long

#define _ITYPE   unsigned long

#define _ITYPE   long long

#define _ITYPE   unsigned long long

#define _ITYPE   void *

#define ATOMIC_CHAR16_T_LOCK_FREE   _ATOMIC_CHAR16_T_LOCK_FREE

#define ATOMIC_CHAR32_T_LOCK_FREE   _ATOMIC_CHAR32_T_LOCK_FREE

#define ATOMIC_CHAR_LOCK_FREE   _ATOMIC_CHAR_LOCK_FREE

#define ATOMIC_FLAG_INIT   {0}

#define ATOMIC_INT_LOCK_FREE   _ATOMIC_INT_LOCK_FREE

#define ATOMIC_LLONG_LOCK_FREE   _ATOMIC_LLONG_LOCK_FREE

#define ATOMIC_LONG_LOCK_FREE   _ATOMIC_LONG_LOCK_FREE

#define ATOMIC_SHORT_LOCK_FREE   _ATOMIC_SHORT_LOCK_FREE

#define ATOMIC_VAR_INIT

(

_Val

)

{ _Val }

#define ATOMIC_WCHAR_T_LOCK_FREE   _ATOMIC_WCHAR_T_LOCK_FREE

Typedef Documentation

typedef atomic<bool> atomic_bool

typedef atomic<char> atomic_char

typedef atomic<char16_t> atomic_char16_t

typedef atomic<char32_t> atomic_char32_t

typedef struct atomic_flag atomic_flag

typedef atomic<int> atomic_int

typedef atomic<int16_t> atomic_int16_t

typedef atomic<int32_t> atomic_int32_t

typedef atomic<int64_t> atomic_int64_t

typedef atomic<int8_t> atomic_int8_t

typedef atomic<int_fast16_t> atomic_int_fast16_t

typedef atomic<int_fast32_t> atomic_int_fast32_t

typedef atomic<int_fast64_t> atomic_int_fast64_t

typedef atomic<int_fast8_t> atomic_int_fast8_t

typedef atomic<int_least16_t> atomic_int_least16_t

typedef atomic<int_least32_t> atomic_int_least32_t

typedef atomic<int_least64_t> atomic_int_least64_t

typedef atomic<int_least8_t> atomic_int_least8_t

typedef atomic<intmax_t> atomic_intmax_t

typedef atomic<intptr_t> atomic_intptr_t

typedef atomic<long long> atomic_llong

typedef atomic<long> atomic_long

typedef atomic<ptrdiff_t> atomic_ptrdiff_t

typedef atomic<signed char> atomic_schar

typedef atomic<short> atomic_short

typedef atomic<size_t> atomic_size_t

typedef atomic<unsigned char> atomic_uchar

typedef atomic<unsigned int> atomic_uint

typedef atomic<uint16_t> atomic_uint16_t

typedef atomic<uint32_t> atomic_uint32_t

typedef atomic<uint64_t> atomic_uint64_t

typedef atomic<uint8_t> atomic_uint8_t

typedef atomic<uint_fast16_t> atomic_uint_fast16_t

typedef atomic<uint_fast32_t> atomic_uint_fast32_t

typedef atomic<uint_fast64_t> atomic_uint_fast64_t

typedef atomic<uint_fast8_t> atomic_uint_fast8_t

typedef atomic<uint_least16_t> atomic_uint_least16_t

typedef atomic<uint_least32_t> atomic_uint_least32_t

typedef atomic<uint_least64_t> atomic_uint_least64_t

typedef atomic<uint_least8_t> atomic_uint_least8_t

typedef atomic<uintmax_t> atomic_uintmax_t

typedef atomic<uintptr_t> atomic_uintptr_t

typedef atomic<unsigned long long> atomic_ullong

typedef atomic<unsigned long> atomic_ulong

typedef atomic<unsigned short> atomic_ushort

typedef atomic<wchar_t> atomic_wchar_t

Function Documentation

_STD_BEGIN memory_order _Get_memory_order ( memory_order  _Order )

inline

    {   // get second memory_order argument for cas functions
        // that take only one memory_order argument
    return (_Order == memory_order_acq_rel ? memory_order_acquire
        : _Order == memory_order_release ? memory_order_relaxed
        : _Order);
    }

template<class _Ty >

bool atomic_compare_exchange_strong ( volatile atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value  )

inline

    {
    return (_Atom->compare_exchange_strong(*_Exp, _Value));
    }

template<class _Ty >

bool atomic_compare_exchange_strong ( atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value  )

inline

    {
    return (_Atom->compare_exchange_strong(*_Exp, _Value));
    }

template<class _Ty >

bool atomic_compare_exchange_strong_explicit ( volatile atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return (_Atom->compare_exchange_strong(*_Exp, _Value, _Order1, _Order2));
    }

template<class _Ty >

bool atomic_compare_exchange_strong_explicit ( atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return (_Atom->compare_exchange_strong(*_Exp, _Value, _Order1, _Order2));
    }

template<class _Ty >

bool atomic_compare_exchange_weak ( volatile atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value  )

inline

    {
    return (_Atom->compare_exchange_weak(*_Exp, _Value));
    }

template<class _Ty >

bool atomic_compare_exchange_weak ( atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value  )

inline

    {
    return (_Atom->compare_exchange_weak(*_Exp, _Value));
    }

template<class _Ty >

bool atomic_compare_exchange_weak_explicit ( volatile atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return (_Atom->compare_exchange_weak(*_Exp, _Value, _Order1, _Order2));
    }

template<class _Ty >

bool atomic_compare_exchange_weak_explicit ( atomic< _Ty > *  _Atom, _Ty *  _Exp, _Ty  _Value, memory_order  _Order1, memory_order  _Order2  )

inline

    {
    return (_Atom->compare_exchange_weak(*_Exp, _Value, _Order1, _Order2));
    }

template<class _Ty >

_Ty atomic_exchange ( volatile atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    return (_Atom->exchange(_Value));
    }

template<class _Ty >

_Ty atomic_exchange ( atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    return (_Atom->exchange(_Value));
    }

template<class _Ty >

_Ty atomic_exchange_explicit ( volatile atomic< _Ty > *  _Atom, _Ty  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->exchange(_Value, _Order));
    }

template<class _Ty >

_Ty atomic_exchange_explicit ( atomic< _Ty > *  _Atom, _Ty  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->exchange(_Value, _Order));
    }

template<class _Ty >

_Ty atomic_fetch_add	(	volatile atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_add	(	atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty* atomic_fetch_add ( volatile atomic< _Ty * > *  _Atom, ptrdiff_t  _Value  )

inline

    {
    return (_Atom->fetch_add(_Value));
    }

template<class _Ty >

_Ty* atomic_fetch_add ( atomic< _Ty * > *  _Atom, ptrdiff_t  _Value  )

inline

    {
    return (_Atom->fetch_add(_Value));
    }

template<class _Ty >

_Ty atomic_fetch_add_explicit	(	volatile atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_add_explicit	(	atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty* atomic_fetch_add_explicit ( volatile atomic< _Ty * > *  _Atom, ptrdiff_t  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->fetch_add(_Value, _Order));
    }

template<class _Ty >

_Ty* atomic_fetch_add_explicit ( atomic< _Ty * > *  _Atom, ptrdiff_t  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->fetch_add(_Value, _Order));
    }

template<class _Ty >

_Ty atomic_fetch_and	(	volatile atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_and	(	atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_and_explicit	(	volatile atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_and_explicit	(	atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_or	(	volatile atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_or	(	atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_or_explicit	(	volatile atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_or_explicit	(	atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_sub	(	volatile atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_sub	(	atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty* atomic_fetch_sub ( volatile atomic< _Ty * > *  _Atom, ptrdiff_t  _Value  )

inline

    {
    return (_Atom->fetch_sub(_Value));
    }

template<class _Ty >

_Ty* atomic_fetch_sub ( atomic< _Ty * > *  _Atom, ptrdiff_t  _Value  )

inline

    {
    return (_Atom->fetch_sub(_Value));
    }

template<class _Ty >

_Ty atomic_fetch_sub_explicit	(	volatile atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_sub_explicit	(	atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty* atomic_fetch_sub_explicit ( volatile atomic< _Ty * > *  _Atom, ptrdiff_t  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->fetch_sub(_Value, _Order));
    }

template<class _Ty >

_Ty* atomic_fetch_sub_explicit ( atomic< _Ty * > *  _Atom, ptrdiff_t  _Value, memory_order  _Order  )

inline

    {
    return (_Atom->fetch_sub(_Value, _Order));
    }

template<class _Ty >

_Ty atomic_fetch_xor	(	volatile atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_xor	(	atomic< _Ty > *	,
		_Ty
	)

template<class _Ty >

_Ty atomic_fetch_xor_explicit	(	volatile atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

template<class _Ty >

_Ty atomic_fetch_xor_explicit	(	atomic< _Ty > *	,
		_Ty	,
		memory_order
	)

void atomic_flag_clear ( volatile atomic_flag *  _Flag )

inline

    {   // atomically clear *_Flag
    _ATOMIC_FLAG_CLEAR(&_Flag->_My_flag, memory_order_seq_cst);
    }

void atomic_flag_clear ( atomic_flag *  _Flag )

inline

    {   // atomically clear *_Flag
    _ATOMIC_FLAG_CLEAR(&_Flag->_My_flag, memory_order_seq_cst);
    }

void atomic_flag_clear_explicit ( volatile atomic_flag *  _Flag, memory_order  _Order  )

inline

    {   // atomically clear *_Flag
    _ATOMIC_FLAG_CLEAR(&_Flag->_My_flag, _Order);
    }

void atomic_flag_clear_explicit ( atomic_flag *  _Flag, memory_order  _Order  )

inline

    {   // atomically clear *_Flag
    _ATOMIC_FLAG_CLEAR(&_Flag->_My_flag, _Order);
    }

bool atomic_flag_test_and_set ( volatile atomic_flag *  _Flag )

inline

    {   // atomically set *_Flag to true and return previous value
    return (_ATOMIC_FLAG_TEST_AND_SET(&_Flag->_My_flag, memory_order_seq_cst));
    }

bool atomic_flag_test_and_set ( atomic_flag *  _Flag )

inline

    {   // atomically set *_Flag to true and return previous value
    return (_ATOMIC_FLAG_TEST_AND_SET(&_Flag->_My_flag, memory_order_seq_cst));
    }

bool atomic_flag_test_and_set_explicit ( volatile atomic_flag *  _Flag, memory_order  _Order  )

inline

    {   // atomically set *_Flag to true and return previous value
    return (_ATOMIC_FLAG_TEST_AND_SET(&_Flag->_My_flag, _Order));
    }

bool atomic_flag_test_and_set_explicit ( atomic_flag *  _Flag, memory_order  _Order  )

inline

    {   // atomically set *_Flag to true and return previous value
    return (_ATOMIC_FLAG_TEST_AND_SET(&_Flag->_My_flag, _Order));
    }

template<class _Ty >

void atomic_init ( volatile atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    *_Atom = _Value;
    }

template<class _Ty >

void atomic_init ( atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    *_Atom = _Value;
    }

template<class _Ty >

bool atomic_is_lock_free ( const volatile atomic< _Ty > *  _Atom )

inline

    {
    return (_Atom->is_lock_free());
    }

template<class _Ty >

bool atomic_is_lock_free ( const atomic< _Ty > *  _Atom )

inline

    {
    return (_Atom->is_lock_free());
    }

template<class _Ty >

_Ty atomic_load ( const volatile atomic< _Ty > *  _Atom )

inline

    {
    return (_Atom->load());
    }

template<class _Ty >

_Ty atomic_load ( const atomic< _Ty > *  _Atom )

inline

    {
    return (_Atom->load());
    }

template<class _Ty >

_Ty atomic_load_explicit ( const volatile atomic< _Ty > *  _Atom, memory_order  _Order  )

inline

    {
    return (_Atom->load(_Order));
    }

template<class _Ty >

_Ty atomic_load_explicit ( const atomic< _Ty > *  _Atom, memory_order  _Order  )

inline

    {
    return (_Atom->load(_Order));
    }

void atomic_signal_fence ( memory_order  _Order )

inline

    {   // force memory visibility and inhibit compiler reordering
    return (_ATOMIC_SIGNAL_FENCE(_Order));
    }

template<class _Ty >

void atomic_store ( volatile atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    _Atom->store(_Value);
    }

template<class _Ty >

void atomic_store ( atomic< _Ty > *  _Atom, _Ty  _Value  )

inline

    {
    _Atom->store(_Value);
    }

template<class _Ty >

void atomic_store_explicit ( volatile atomic< _Ty > *  _Atom, _Ty  _Value, memory_order  _Order  )

inline

    {
    _Atom->store(_Value, _Order);
    }

template<class _Ty >

void atomic_store_explicit ( atomic< _Ty > *  _Atom, _Ty  _Value, memory_order  _Order  )

inline

    {
    _Atom->store(_Value, _Order);
    }

void atomic_thread_fence ( memory_order  _Order )

inline

    {   // force memory visibility and inhibit compiler reordering
    return (_ATOMIC_THREAD_FENCE(_Order));
    }

template<class _Ty >

_Ty kill_dependency

(

_Ty

_Arg

)

    {   // magic template that kills dependency ordering when called
    return (_Arg);
    }