From 3a81a36bbef67d004a60614adca7ef8b72dab6cb Mon Sep 17 00:00:00 2001 From: Andrey Semashev Date: Sun, 11 May 2014 20:28:12 +0400 Subject: [PATCH] Removed no longer used files. --- include/boost/atomic/detail/base.hpp | 605 ---- include/boost/atomic/detail/cas128strong.hpp | 290 -- include/boost/atomic/detail/cas32strong.hpp | 939 ----- include/boost/atomic/detail/cas32weak.hpp | 1017 ------ .../boost/atomic/detail/cas64strong-ptr.hpp | 247 -- include/boost/atomic/detail/cas64strong.hpp | 264 -- include/boost/atomic/detail/gcc-alpha.hpp | 368 -- include/boost/atomic/detail/gcc-armv6plus.hpp | 255 -- include/boost/atomic/detail/gcc-atomic.hpp | 1367 -------- include/boost/atomic/detail/gcc-cas.hpp | 163 - include/boost/atomic/detail/gcc-ppc.hpp | 3046 ----------------- include/boost/atomic/detail/gcc-sparcv9.hpp | 1335 -------- include/boost/atomic/detail/gcc-x86.hpp | 2021 ----------- include/boost/atomic/detail/generic-cas.hpp | 206 -- include/boost/atomic/detail/linux-arm.hpp | 192 -- include/boost/atomic/detail/windows.hpp | 1789 ---------- 16 files changed, 14104 deletions(-) delete mode 100644 include/boost/atomic/detail/base.hpp delete mode 100644 include/boost/atomic/detail/cas128strong.hpp delete mode 100644 include/boost/atomic/detail/cas32strong.hpp delete mode 100644 include/boost/atomic/detail/cas32weak.hpp delete mode 100644 include/boost/atomic/detail/cas64strong-ptr.hpp delete mode 100644 include/boost/atomic/detail/cas64strong.hpp delete mode 100644 include/boost/atomic/detail/gcc-alpha.hpp delete mode 100644 include/boost/atomic/detail/gcc-armv6plus.hpp delete mode 100644 include/boost/atomic/detail/gcc-atomic.hpp delete mode 100644 include/boost/atomic/detail/gcc-cas.hpp delete mode 100644 include/boost/atomic/detail/gcc-ppc.hpp delete mode 100644 include/boost/atomic/detail/gcc-sparcv9.hpp delete mode 100644 include/boost/atomic/detail/gcc-x86.hpp delete mode 100644 include/boost/atomic/detail/generic-cas.hpp delete mode 100644 include/boost/atomic/detail/linux-arm.hpp delete mode 100644 include/boost/atomic/detail/windows.hpp diff --git a/include/boost/atomic/detail/base.hpp b/include/boost/atomic/detail/base.hpp deleted file mode 100644 index eb105b9..0000000 --- a/include/boost/atomic/detail/base.hpp +++ /dev/null @@ -1,605 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_BASE_HPP -#define BOOST_ATOMIC_DETAIL_BASE_HPP - -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -// Base class definition and fallback implementation. -// To be overridden (through partial specialization) by -// platform implementations. - -#include - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -#define BOOST_ATOMIC_DECLARE_BASE_OPERATORS \ - bool \ - compare_exchange_strong( \ - value_type & expected, \ - value_type desired, \ - memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT \ - { \ - return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); \ - } \ - \ - bool \ - compare_exchange_weak( \ - value_type & expected, \ - value_type desired, \ - memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT \ - { \ - return compare_exchange_weak(expected, desired, order, calculate_failure_order(order)); \ - } \ - -#define BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \ - value_type \ - operator++(int) volatile BOOST_NOEXCEPT \ - { \ - return fetch_add(1); \ - } \ - \ - value_type \ - operator++(void) volatile BOOST_NOEXCEPT \ - { \ - return fetch_add(1) + 1; \ - } \ - \ - value_type \ - operator--(int) volatile BOOST_NOEXCEPT \ - { \ - return fetch_sub(1); \ - } \ - \ - value_type \ - operator--(void) volatile BOOST_NOEXCEPT \ - { \ - return fetch_sub(1) - 1; \ - } \ - \ - value_type \ - operator+=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return fetch_add(v) + v; \ - } \ - \ - value_type \ - operator-=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return fetch_sub(v) - v; \ - } \ - -#define BOOST_ATOMIC_DECLARE_VOID_POINTER_ADDITIVE_OPERATORS \ - value_type \ - operator++(int) volatile BOOST_NOEXCEPT \ - { \ - return fetch_add(1); \ - } \ - \ - value_type \ - operator++(void) volatile BOOST_NOEXCEPT \ - { \ - return (char*)fetch_add(1) + 1; \ - } \ - \ - value_type \ - operator--(int) volatile BOOST_NOEXCEPT \ - { \ - return fetch_sub(1); \ - } \ - \ - value_type \ - operator--(void) volatile BOOST_NOEXCEPT \ - { \ - return (char*)fetch_sub(1) - 1; \ - } \ - \ - value_type \ - operator+=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return (char*)fetch_add(v) + v; \ - } \ - \ - value_type \ - operator-=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return (char*)fetch_sub(v) - v; \ - } \ - -#define BOOST_ATOMIC_DECLARE_BIT_OPERATORS \ - value_type \ - operator&=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return fetch_and(v) & v; \ - } \ - \ - value_type \ - operator|=(difference_type v) volatile BOOST_NOEXCEPT \ - { \ - return fetch_or(v) | v; \ - } \ - \ - value_type \ - operator^=(difference_type v) volatile BOOST_NOEXCEPT\ - { \ - return fetch_xor(v) ^ v; \ - } \ - -#define BOOST_ATOMIC_DECLARE_POINTER_OPERATORS \ - BOOST_ATOMIC_DECLARE_BASE_OPERATORS \ - BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \ - -#define BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS \ - BOOST_ATOMIC_DECLARE_BASE_OPERATORS \ - BOOST_ATOMIC_DECLARE_VOID_POINTER_ADDITIVE_OPERATORS \ - -#define BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS \ - BOOST_ATOMIC_DECLARE_BASE_OPERATORS \ - BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \ - BOOST_ATOMIC_DECLARE_BIT_OPERATORS \ - -namespace boost { -namespace atomics { -namespace detail { - -inline memory_order -calculate_failure_order(memory_order order) -{ - switch(order) - { - case memory_order_acq_rel: - return memory_order_acquire; - case memory_order_release: - return memory_order_relaxed; - default: - return order; - } -} - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef lockpool::scoped_lock guard_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(v) - {} - - void - store(value_type const& v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - char * storage = storage_ptr(); - guard_type guard(storage); - - memcpy(storage, &v, sizeof(value_type)); - } - - value_type - load(memory_order /*order*/ = memory_order_seq_cst) volatile const BOOST_NOEXCEPT - { - char * storage = storage_ptr(); - guard_type guard(storage); - - value_type v; - memcpy(&v, storage, sizeof(value_type)); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order /*success_order*/, - memory_order /*failure_order*/) volatile BOOST_NOEXCEPT - { - char * storage = storage_ptr(); - guard_type guard(storage); - - if (memcmp(storage, &expected, sizeof(value_type)) == 0) { - memcpy(storage, &desired, sizeof(value_type)); - return true; - } else { - memcpy(&expected, storage, sizeof(value_type)); - return false; - } - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - exchange(value_type const& v, memory_order /*order*/=memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - char * storage = storage_ptr(); - guard_type guard(storage); - - value_type tmp; - memcpy(&tmp, storage, sizeof(value_type)); - - memcpy(storage, &v, sizeof(value_type)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return false; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - char * storage_ptr() volatile const BOOST_NOEXCEPT - { - return const_cast(&reinterpret_cast(v_)); - } - - T v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef lockpool::scoped_lock guard_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - v_ = v; - } - - value_type - load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type v = const_cast(v_); - return v; - } - - value_type - exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ = v; - return old; - } - - bool - compare_exchange_strong(value_type & expected, value_type desired, - memory_order /*success_order*/, - memory_order /*failure_order*/) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - if (v_ == expected) { - v_ = desired; - return true; - } else { - expected = v_; - return false; - } - } - - bool - compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_add(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ += v; - return old; - } - - value_type - fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ -= v; - return old; - } - - value_type - fetch_and(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ &= v; - return old; - } - - value_type - fetch_or(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ |= v; - return old; - } - - value_type - fetch_xor(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ ^= v; - return old; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return false; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - typedef lockpool::scoped_lock guard_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - v_ = v; - } - - value_type - load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type v = const_cast(v_); - return v; - } - - value_type - exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ = v; - return old; - } - - bool - compare_exchange_strong(value_type & expected, value_type desired, - memory_order /*success_order*/, - memory_order /*failure_order*/) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - if (v_ == expected) { - v_ = desired; - return true; - } else { - expected = v_; - return false; - } - } - - bool - compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type fetch_add(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ += v; - return old; - } - - value_type fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ -= v; - return old; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return false; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - typedef lockpool::scoped_lock guard_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - v_ = v; - } - - value_type - load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type v = const_cast(v_); - return v; - } - - value_type - exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - v_ = v; - return old; - } - - bool - compare_exchange_strong(value_type & expected, value_type desired, - memory_order /*success_order*/, - memory_order /*failure_order*/) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - if (v_ == expected) { - v_ = desired; - return true; - } else { - expected = v_; - return false; - } - } - - bool - compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return false; - } - - value_type fetch_add(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - char * cv = reinterpret_cast(old); - cv += v; - v_ = cv; - return old; - } - - value_type fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile - { - guard_type guard(const_cast(&v_)); - - value_type old = v_; - char * cv = reinterpret_cast(old); - cv -= v; - v_ = cv; - return old; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/cas128strong.hpp b/include/boost/atomic/detail/cas128strong.hpp deleted file mode 100644 index dcb4d7d..0000000 --- a/include/boost/atomic/detail/cas128strong.hpp +++ /dev/null @@ -1,290 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_CAS128STRONG_HPP -#define BOOST_ATOMIC_DETAIL_CAS128STRONG_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann, Andrey Semashev - -// Build 128-bit atomic operation on integers/UDTs from platform_cmpxchg128_strong -// primitive. It is assumed that 128-bit loads/stores are not -// atomic, so they are implemented through platform_load128/platform_store128. - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - platform_store128(v, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = platform_load128(&v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg128_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* generic types */ - -#if defined(BOOST_HAS_INT128) - -typedef boost::uint128_type storage128_type; - -#else // defined(BOOST_HAS_INT128) - -struct BOOST_ALIGNMENT(16) storage128_type -{ - uint64_t data[2]; -}; - -inline bool operator== (storage128_type const& left, storage128_type const& right) -{ - return left.data[0] == right.data[0] && left.data[1] == right.data[1]; -} -inline bool operator!= (storage128_type const& left, storage128_type const& right) -{ - return !(left == right); -} - -#endif // defined(BOOST_HAS_INT128) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef storage128_type storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT - { - memset(&v_, 0, sizeof(v_)); - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type value_s; - memset(&value_s, 0, sizeof(value_s)); - memcpy(&value_s, &value, sizeof(value_type)); - platform_fence_before_store(order); - platform_store128(value_s, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type value_s = platform_load128(&v_); - platform_fence_after_load(order); - value_type value; - memcpy(&value, &value_s, sizeof(value_type)); - return value; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memset(&expected_s, 0, sizeof(expected_s)); - memset(&desired_s, 0, sizeof(desired_s)); - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - bool success = platform_cmpxchg128_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/cas32strong.hpp b/include/boost/atomic/detail/cas32strong.hpp deleted file mode 100644 index 7a35d45..0000000 --- a/include/boost/atomic/detail/cas32strong.hpp +++ /dev/null @@ -1,939 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_CAS32STRONG_HPP -#define BOOST_ATOMIC_DETAIL_CAS32STRONG_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann - - -// Build 8-, 16- and 32-bit atomic operations from -// a platform_cmpxchg32_strong primitive. - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - storage_type expected_s = (storage_type) expected; - storage_type desired_s = (storage_type) desired; - - bool success = platform_cmpxchg32_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - expected = (value_type) expected_s; - } - - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - storage_type expected_s = (storage_type) expected; - storage_type desired_s = (storage_type) desired; - - bool success = platform_cmpxchg32_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - expected = (value_type) expected_s; - } - - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* pointer types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef void * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* generic types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - bool success = platform_cmpxchg32_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - bool success = platform_cmpxchg32_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - bool success = platform_cmpxchg32_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - is_lock_free(void) const volatile - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/cas32weak.hpp b/include/boost/atomic/detail/cas32weak.hpp deleted file mode 100644 index d75215d..0000000 --- a/include/boost/atomic/detail/cas32weak.hpp +++ /dev/null @@ -1,1017 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_CAS32WEAK_HPP -#define BOOST_ATOMIC_DETAIL_CAS32WEAK_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann - - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - storage_type expected_s = (storage_type) expected; - storage_type desired_s = (storage_type) desired; - - bool success = platform_cmpxchg32(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - expected = (value_type) expected_s; - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - storage_type expected_s = (storage_type) expected; - storage_type desired_s = (storage_type) desired; - - bool success = platform_cmpxchg32(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - expected = (value_type) expected_s; - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* pointer types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef void * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed)); - return original; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* generic types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - - bool success = platform_cmpxchg32(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - while (true) - { - value_type tmp = expected; - if (compare_exchange_weak(tmp, desired, success_order, failure_order)) - return true; - if (tmp != expected) - { - expected = tmp; - return false; - } - } - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/cas64strong-ptr.hpp b/include/boost/atomic/detail/cas64strong-ptr.hpp deleted file mode 100644 index 2f04112..0000000 --- a/include/boost/atomic/detail/cas64strong-ptr.hpp +++ /dev/null @@ -1,247 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_CAS64STRONG_PTR_HPP -#define BOOST_ATOMIC_DETAIL_CAS64STRONG_PTR_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann - -// Build 64-bit atomic operation on pointers from platform_cmpxchg64_strong -// primitive. It is assumed that 64-bit loads/stores are not -// atomic, so they are implemented through platform_load64/platform_store64. -// -// The reason for extracting pointer specializations to a separate header is -// that 64-bit CAS is available on some 32-bit platforms (notably, x86). -// On these platforms there is no need for 64-bit pointer specializations, -// since they will never be used. - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -/* pointer types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef void * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - platform_store64(v, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = platform_load64(&v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg64_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - platform_store64(v, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = platform_load64(&v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg64_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/cas64strong.hpp b/include/boost/atomic/detail/cas64strong.hpp deleted file mode 100644 index c283f98..0000000 --- a/include/boost/atomic/detail/cas64strong.hpp +++ /dev/null @@ -1,264 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP -#define BOOST_ATOMIC_DETAIL_CAS64STRONG_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann - -// Build 64-bit atomic operation on integers/UDTs from platform_cmpxchg64_strong -// primitive. It is assumed that 64-bit loads/stores are not -// atomic, so they are implemented through platform_load64/platform_store64. - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before_store(order); - platform_store64(v, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = platform_load64(&v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - - bool success = platform_cmpxchg64_strong(expected, desired, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - } - - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original & v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original | v, order, memory_order_relaxed)); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, original ^ v, order, memory_order_relaxed)); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* generic types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint64_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& value, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type value_s = 0; - memcpy(&value_s, &value, sizeof(value_type)); - platform_fence_before_store(order); - platform_store64(value_s, &v_); - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type value_s = platform_load64(&v_); - platform_fence_after_load(order); - value_type value; - memcpy(&value, &value_s, sizeof(value_type)); - return value; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original = load(memory_order_relaxed); - do { - } while (!compare_exchange_weak(original, v, order, memory_order_relaxed)); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - platform_fence_before(success_order); - bool success = platform_cmpxchg64_strong(expected_s, desired_s, &v_); - - if (success) { - platform_fence_after(success_order); - } else { - platform_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - } - - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/gcc-alpha.hpp b/include/boost/atomic/detail/gcc-alpha.hpp deleted file mode 100644 index 2775499..0000000 --- a/include/boost/atomic/detail/gcc-alpha.hpp +++ /dev/null @@ -1,368 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_ALPHA_HPP -#define BOOST_ATOMIC_DETAIL_GCC_ALPHA_HPP - -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -/* - Refer to http://h71000.www7.hp.com/doc/82final/5601/5601pro_004.html - (HP OpenVMS systems documentation) and the alpha reference manual. - */ - -/* - NB: The most natural thing would be to write the increment/decrement - operators along the following lines: - - __asm__ __volatile__( - "1: ldl_l %0,%1 \n" - "addl %0,1,%0 \n" - "stl_c %0,%1 \n" - "beq %0,1b\n" - : "=&b" (tmp) - : "m" (value) - : "cc" - ); - - However according to the comments on the HP website and matching - comments in the Linux kernel sources this defies branch prediction, - as the cpu assumes that backward branches are always taken; so - instead copy the trick from the Linux kernel, introduce a forward - branch and back again. - - I have, however, had a hard time measuring the difference between - the two versions in microbenchmarks -- I am leaving it in nevertheless - as it apparently does not hurt either. -*/ - -namespace boost { -namespace atomics { -namespace detail { - -inline void fence_before(memory_order order) -{ - switch(order) { - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -inline void fence_after(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -template<> -inline void platform_atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_consume: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("mb" ::: "memory"); - default:; - } -} - -template -class atomic_alpha_32 -{ -public: - typedef T integral_type; - BOOST_CONSTEXPR atomic_alpha_32(T v) BOOST_NOEXCEPT: i(v) {} - atomic_alpha_32() {} - T load(memory_order order=memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - T v=*reinterpret_cast(&i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - fence_before(order); - *reinterpret_cast(&i)=(int)v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - fence_before(success_order); - int current, success; - __asm__ __volatile__( - "1: ldl_l %2, %4\n" - "cmpeq %2, %0, %3\n" - "mov %2, %0\n" - "beq %3, 3f\n" - "stl_c %1, %4\n" - "2:\n" - - ".subsection 2\n" - "3: mov %3, %1\n" - "br 2b\n" - ".previous\n" - - : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success) - : "m" (i) - : - ); - if (desired) fence_after(success_order); - else fence_after(failure_order); - return desired; - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "addl %0, %3, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i), "r" (c) - : - ); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - int original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "addl %0, 1, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - int original, modified; - __asm__ __volatile__( - "1: ldl_l %0, %2\n" - "subl %0, 1, %1\n" - "stl_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } -private: - T i; -}; - -template -class atomic_alpha_64 -{ -public: - typedef T integral_type; - BOOST_CONSTEXPR atomic_alpha_64(T v) BOOST_NOEXCEPT: i(v) {} - atomic_alpha_64() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T v=*reinterpret_cast(&i); - fence_after(order); - return v; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - fence_before(order); - *reinterpret_cast(&i)=v; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - fence_before(success_order); - int current, success; - __asm__ __volatile__( - "1: ldq_l %2, %4\n" - "cmpeq %2, %0, %3\n" - "mov %2, %0\n" - "beq %3, 3f\n" - "stq_c %1, %4\n" - "2:\n" - - ".subsection 2\n" - "3: mov %3, %1\n" - "br 2b\n" - ".previous\n" - - : "+&r" (expected), "+&r" (desired), "=&r"(current), "=&r"(success) - : "m" (i) - : - ); - if (desired) fence_after(success_order); - else fence_after(failure_order); - return desired; - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;} -protected: - inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "addq %0, %3, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i), "r" (c) - : - ); - fence_after(order); - return original; - } - inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "addq %0, 1, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } - inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT - { - fence_before(order); - T original, modified; - __asm__ __volatile__( - "1: ldq_l %0, %2\n" - "subq %0, 1, %1\n" - "stq_c %1, %2\n" - "beq %1, 2f\n" - - ".subsection 2\n" - "2: br 1b\n" - ".previous\n" - - : "=&r" (original), "=&r" (modified) - : "m" (i) - : - ); - fence_after(order); - return original; - } -private: - T i; -}; - -template -class platform_atomic_integral : - public build_atomic_from_typical > > -{ -public: - typedef build_atomic_from_typical > > super; - BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : - public build_atomic_from_typical > > -{ -public: - typedef build_atomic_from_typical > > super; - BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : - public build_atomic_from_larger_type, T> -{ -public: - typedef build_atomic_from_larger_type, T> super; - BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : - public build_atomic_from_larger_type, T> -{ -public: - typedef build_atomic_from_larger_type, T> super; - BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {} - platform_atomic_integral(void) {} -}; - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/gcc-armv6plus.hpp b/include/boost/atomic/detail/gcc-armv6plus.hpp deleted file mode 100644 index cccd111..0000000 --- a/include/boost/atomic/detail/gcc-armv6plus.hpp +++ /dev/null @@ -1,255 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_ARMV6PLUS_HPP -#define BOOST_ATOMIC_DETAIL_GCC_ARMV6PLUS_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2009 Phil Endecott -// Copyright (c) 2013 Tim Blechmann -// ARM Code by Phil Endecott, based on other architectures. - -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -// From the ARM Architecture Reference Manual for architecture v6: -// -// LDREX{} , [] -// Specifies the destination register for the memory word addressed by -// Specifies the register containing the address. -// -// STREX{} , , [] -// Specifies the destination register for the returned status value. -// 0 if the operation updates memory -// 1 if the operation fails to update memory -// Specifies the register containing the word to be stored to memory. -// Specifies the register containing the address. -// Rd must not be the same register as Rm or Rn. -// -// ARM v7 is like ARM v6 plus: -// There are half-word and byte versions of the LDREX and STREX instructions, -// LDREXH, LDREXB, STREXH and STREXB. -// There are also double-word versions, LDREXD and STREXD. -// (Actually it looks like these are available from version 6k onwards.) -// FIXME these are not yet used; should be mostly a matter of copy-and-paste. -// I think you can supply an immediate offset to the address. -// -// A memory barrier is effected using a "co-processor 15" instruction, -// though a separate assembler mnemonic is available for it in v7. - -namespace boost { -namespace atomics { -namespace detail { - -// "Thumb 1" is a subset of the ARM instruction set that uses a 16-bit encoding. It -// doesn't include all instructions and in particular it doesn't include the co-processor -// instruction used for the memory barrier or the load-locked/store-conditional -// instructions. So, if we're compiling in "Thumb 1" mode, we need to wrap all of our -// asm blocks with code to temporarily change to ARM mode. -// -// You can only change between ARM and Thumb modes when branching using the bx instruction. -// bx takes an address specified in a register. The least significant bit of the address -// indicates the mode, so 1 is added to indicate that the destination code is Thumb. -// A temporary register is needed for the address and is passed as an argument to these -// macros. It must be one of the "low" registers accessible to Thumb code, specified -// using the "l" attribute in the asm statement. -// -// Architecture v7 introduces "Thumb 2", which does include (almost?) all of the ARM -// instruction set. So in v7 we don't need to change to ARM mode; we can write "universal -// assembler" which will assemble to Thumb 2 or ARM code as appropriate. The only thing -// we need to do to make this "universal" assembler mode work is to insert "IT" instructions -// to annotate the conditional instructions. These are ignored in other modes (e.g. v6), -// so they can always be present. - -#if defined(__thumb__) && !defined(__thumb2__) -#define BOOST_ATOMIC_ARM_ASM_START(TMPREG) "adr " #TMPREG ", 1f\n" "bx " #TMPREG "\n" ".arm\n" ".align 4\n" "1: " -#define BOOST_ATOMIC_ARM_ASM_END(TMPREG) "adr " #TMPREG ", 1f + 1\n" "bx " #TMPREG "\n" ".thumb\n" ".align 2\n" "1: " -#else -// The tmpreg is wasted in this case, which is non-optimal. -#define BOOST_ATOMIC_ARM_ASM_START(TMPREG) -#define BOOST_ATOMIC_ARM_ASM_END(TMPREG) -#endif - -#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7S__) -#define BOOST_ATOMIC_ARM_DMB "dmb\n" -#else -#define BOOST_ATOMIC_ARM_DMB "mcr\tp15, 0, r0, c7, c10, 5\n" -#endif - -inline void -arm_barrier(void) BOOST_NOEXCEPT -{ - int brtmp; - __asm__ __volatile__ - ( - BOOST_ATOMIC_ARM_ASM_START(%0) - BOOST_ATOMIC_ARM_DMB - BOOST_ATOMIC_ARM_ASM_END(%0) - : "=&l" (brtmp) :: "memory" - ); -} - -inline void -platform_fence_before(memory_order order) BOOST_NOEXCEPT -{ - switch(order) - { - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - arm_barrier(); - case memory_order_consume: - default:; - } -} - -inline void -platform_fence_after(memory_order order) BOOST_NOEXCEPT -{ - switch(order) - { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - arm_barrier(); - default:; - } -} - -inline void -platform_fence_before_store(memory_order order) BOOST_NOEXCEPT -{ - platform_fence_before(order); -} - -inline void -platform_fence_after_store(memory_order order) BOOST_NOEXCEPT -{ - if (order == memory_order_seq_cst) - arm_barrier(); -} - -inline void -platform_fence_after_load(memory_order order) BOOST_NOEXCEPT -{ - platform_fence_after(order); -} - -template -inline bool -platform_cmpxchg32(T & expected, T desired, volatile T * ptr) BOOST_NOEXCEPT -{ - int success; - int tmp; - __asm__ __volatile__ - ( - BOOST_ATOMIC_ARM_ASM_START(%2) - "mov %1, #0\n" // success = 0 - "ldrex %0, %3\n" // expected' = *(&i) - "teq %0, %4\n" // flags = expected'==expected - "ittt eq\n" - "strexeq %2, %5, %3\n" // if (flags.equal) *(&i) = desired, tmp = !OK - "teqeq %2, #0\n" // if (flags.equal) flags = tmp==0 - "moveq %1, #1\n" // if (flags.equal) success = 1 - BOOST_ATOMIC_ARM_ASM_END(%2) - : "=&r" (expected), // %0 - "=&r" (success), // %1 - "=&l" (tmp), // %2 - "+Q" (*ptr) // %3 - : "r" (expected), // %4 - "r" (desired) // %5 - : "cc" - ); - return success; -} - -} -} - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) - { - case memory_order_acquire: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - atomics::detail::arm_barrier(); - default:; - } -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -inline void -atomic_signal_fence(memory_order) -{ - __asm__ __volatile__ ("" ::: "memory"); -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before_store(order); - const_cast(v_) = 0; - atomics::detail::platform_fence_after_store(order); - } - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before(order); - uint32_t expected = v_; - do { - if (expected == 1) - break; - } while (!atomics::detail::platform_cmpxchg32(expected, (uint32_t)1, &v_)); - atomics::detail::platform_fence_after(order); - return expected; - } - - BOOST_DELETED_FUNCTION(atomic_flag(const atomic_flag &)) - BOOST_DELETED_FUNCTION(atomic_flag& operator=(const atomic_flag &)) -}; - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -} - -#undef BOOST_ATOMIC_ARM_ASM_START -#undef BOOST_ATOMIC_ARM_ASM_END - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -#include - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#endif diff --git a/include/boost/atomic/detail/gcc-atomic.hpp b/include/boost/atomic/detail/gcc-atomic.hpp deleted file mode 100644 index 9504e0e..0000000 --- a/include/boost/atomic/detail/gcc-atomic.hpp +++ /dev/null @@ -1,1367 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_ATOMIC_HPP -#define BOOST_ATOMIC_DETAIL_GCC_ATOMIC_HPP - -// Copyright (c) 2013 Andrey Semashev -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -#if (defined(__i386__) && defined(__SSE2__)) || defined(__x86_64__) -#define BOOST_ATOMIC_X86_PAUSE() __asm__ __volatile__ ("pause\n") -#endif - -#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) -#define BOOST_ATOMIC_X86_HAS_CMPXCHG8B 1 -#endif - -#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) -#define BOOST_ATOMIC_X86_HAS_CMPXCHG16B 1 -#endif - -#if defined(BOOST_ATOMIC_X86_HAS_CMPXCHG16B) && defined(__clang__) -// Worraround for bug: http://llvm.org/bugs/show_bug.cgi?id=19149 -// Clang 3.4 does not implement 128-bit __atomic* intrinsics even though it defines __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 -#define BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS -#endif - -BOOST_FORCEINLINE BOOST_CONSTEXPR int convert_memory_order_to_gcc(memory_order order) BOOST_NOEXCEPT -{ - return (order == memory_order_relaxed ? __ATOMIC_RELAXED : (order == memory_order_consume ? __ATOMIC_CONSUME : - (order == memory_order_acquire ? __ATOMIC_ACQUIRE : (order == memory_order_release ? __ATOMIC_RELEASE : - (order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_SEQ_CST))))); -} - -} // namespace detail -} // namespace atomics - -#if __GCC_ATOMIC_BOOL_LOCK_FREE == 2 - -class atomic_flag -{ -private: - bool v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(false) {} - - bool test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_test_and_set(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - void clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_clear(const_cast(&v_), atomics::detail::convert_memory_order_to_gcc(order)); - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -#endif // __GCC_ATOMIC_BOOL_LOCK_FREE == 2 - -} // namespace boost - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#if __GCC_ATOMIC_CHAR_LOCK_FREE == 2 -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_SHORT_LOCK_FREE == 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_INT_LOCK_FREE == 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_LONG_LOCK_FREE == 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_LLONG_LOCK_FREE == 2 -#define BOOST_ATOMIC_LLONG_LOCK_FREE 2 -#endif -#if defined(BOOST_ATOMIC_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT)) -#define BOOST_ATOMIC_INT128_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_POINTER_LOCK_FREE == 2 -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#endif -#if __GCC_ATOMIC_BOOL_LOCK_FREE == 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 -#endif - -namespace boost { - -#define BOOST_ATOMIC_THREAD_FENCE 2 -BOOST_FORCEINLINE void atomic_thread_fence(memory_order order) -{ - __atomic_thread_fence(atomics::detail::convert_memory_order_to_gcc(order)); -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -BOOST_FORCEINLINE void atomic_signal_fence(memory_order order) -{ - __atomic_signal_fence(atomics::detail::convert_memory_order_to_gcc(order)); -} - -namespace atomics { -namespace detail { - -#if defined(BOOST_ATOMIC_CHAR_LOCK_FREE) && BOOST_ATOMIC_CHAR_LOCK_FREE > 0 - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_and(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_or(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_xor(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint8_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : - v_(reinterpret_cast(v)) - { - } - - void store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store(&v_, (storage_type*)&v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __atomic_load(&v_, (storage_type*)&v, atomics::detail::convert_memory_order_to_gcc(order)); - return v; - } - - value_type exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type r; - __atomic_exchange(&v_, (storage_type*)&v, (storage_type*)&r, atomics::detail::convert_memory_order_to_gcc(order)); - return r; - } - - bool compare_exchange_strong( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange(&v_, (storage_type*)&expected, (storage_type*)&desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange(&v_, (storage_type*)&expected, (storage_type*)&desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif // defined(BOOST_ATOMIC_CHAR_LOCK_FREE) && BOOST_ATOMIC_CHAR_LOCK_FREE > 0 - -#if defined(BOOST_ATOMIC_SHORT_LOCK_FREE) && BOOST_ATOMIC_SHORT_LOCK_FREE > 0 - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_and(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_or(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_xor(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint16_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : - v_(reinterpret_cast(v)) - { - } - - void store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store(&v_, (storage_type*)&v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __atomic_load(&v_, (storage_type*)&v, atomics::detail::convert_memory_order_to_gcc(order)); - return v; - } - - value_type exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type r; - __atomic_exchange(&v_, (storage_type*)&v, (storage_type*)&r, atomics::detail::convert_memory_order_to_gcc(order)); - return r; - } - - bool compare_exchange_strong( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange(&v_, (storage_type*)&expected, (storage_type*)&desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange(&v_, (storage_type*)&expected, (storage_type*)&desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif // defined(BOOST_ATOMIC_SHORT_LOCK_FREE) && BOOST_ATOMIC_SHORT_LOCK_FREE > 0 - -#if defined(BOOST_ATOMIC_INT_LOCK_FREE) && BOOST_ATOMIC_INT_LOCK_FREE > 0 - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_and(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_or(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_xor(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - __atomic_store_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - tmp = __atomic_exchange_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool compare_exchange_strong( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool compare_exchange_weak( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif // defined(BOOST_ATOMIC_INT_LOCK_FREE) && BOOST_ATOMIC_INT_LOCK_FREE > 0 - -#if defined(BOOST_ATOMIC_LLONG_LOCK_FREE) && BOOST_ATOMIC_LLONG_LOCK_FREE > 0 - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_and(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_or(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_xor(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint64_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - __atomic_store_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - tmp = __atomic_exchange_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool compare_exchange_strong( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool compare_exchange_weak( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif // defined(BOOST_ATOMIC_LLONG_LOCK_FREE) && BOOST_ATOMIC_LLONG_LOCK_FREE > 0 - -#if defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && !defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_and(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_or(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_xor(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#if defined(BOOST_HAS_INT128) - -typedef boost::uint128_type storage128_type; - -#else // defined(BOOST_HAS_INT128) - -struct BOOST_ALIGNMENT(16) storage128_type -{ - uint64_t data[2]; -}; - -inline bool operator== (storage128_type const& left, storage128_type const& right) -{ - return left.data[0] == right.data[0] && left.data[1] == right.data[1]; -} -inline bool operator!= (storage128_type const& left, storage128_type const& right) -{ - return !(left == right); -} - -#endif // defined(BOOST_HAS_INT128) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef storage128_type storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT - { - memset(&v_, 0, sizeof(v_)); - memcpy(&v_, &v, sizeof(value_type)); - } - - void store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp; - memset(&tmp, 0, sizeof(tmp)); - memcpy(&tmp, &v, sizeof(value_type)); - __atomic_store_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp; - memset(&tmp, 0, sizeof(tmp)); - memcpy(&tmp, &v, sizeof(value_type)); - tmp = __atomic_exchange_n(&v_, tmp, atomics::detail::convert_memory_order_to_gcc(order)); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool compare_exchange_strong( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memset(&expected_s, 0, sizeof(expected_s)); - memset(&desired_s, 0, sizeof(desired_s)); - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool compare_exchange_weak( - value_type& expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memset(&expected_s, 0, sizeof(expected_s)); - memset(&desired_s, 0, sizeof(desired_s)); - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - const bool success = __atomic_compare_exchange_n(&v_, &expected_s, desired_s, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif // defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && !defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) - - -/* pointers */ - -#if defined(BOOST_ATOMIC_POINTER_LOCK_FREE) && BOOST_ATOMIC_POINTER_LOCK_FREE > 0 - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T* value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v * sizeof(T), atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v * sizeof(T), atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef void* value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - __atomic_store_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - return __atomic_load_n(&v_, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_add(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_fetch_sub(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return __atomic_exchange_n(&v_, v, atomics::detail::convert_memory_order_to_gcc(order)); - } - - bool compare_exchange_strong( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, false, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool compare_exchange_weak( - value_type& expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return __atomic_compare_exchange_n(&v_, &expected, desired, true, - atomics::detail::convert_memory_order_to_gcc(success_order), - atomics::detail::convert_memory_order_to_gcc(failure_order)); - } - - bool is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return __atomic_is_lock_free(sizeof(v_), &v_); - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#endif // defined(BOOST_ATOMIC_POINTER_LOCK_FREE) && BOOST_ATOMIC_POINTER_LOCK_FREE > 0 - -#if defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) - -inline void platform_fence_before(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* release */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void platform_fence_after(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* acquire */ - break; - case memory_order_consume: - /* consume */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void platform_fence_after_load(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - break; - case memory_order_consume: - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - break; - default:; - } -} - -inline void platform_fence_before_store(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* release */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void platform_fence_after_store(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* acquire */ - break; - case memory_order_consume: - /* consume */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -template -inline bool platform_cmpxchg128_strong(T& expected, T desired, volatile T* ptr) BOOST_NOEXCEPT -{ - T old_expected = expected; - expected = __sync_val_compare_and_swap(ptr, old_expected, desired); - return expected == old_expected; -} - -template -inline void platform_store128(T value, volatile T* ptr) BOOST_NOEXCEPT -{ - uint64_t const* p_value = (uint64_t const*)&value; - __asm__ __volatile__ - ( - "movq 0(%[dest]), %%rax\n\t" - "movq 8(%[dest]), %%rdx\n\t" - ".align 16\n\t" - "1: lock; cmpxchg16b 0(%[dest])\n\t" - "jne 1b" - : - : "b" (p_value[0]), "c" (p_value[1]), [dest] "r" (ptr) - : "memory", "cc", "rax", "rdx" - ); -} - -template -inline T platform_load128(const volatile T* ptr) BOOST_NOEXCEPT -{ - T value = T(); - return __sync_val_compare_and_swap(ptr, value, value); -} - -#endif // defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) - -} // namespace detail -} // namespace atomics -} // namespace boost - -#if defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) -#undef BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS -#include -#endif // defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 && defined(BOOST_ATOMIC_X86_NO_GCC_128_BIT_ATOMIC_INTRINSICS) - -#endif // !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#endif // BOOST_ATOMIC_DETAIL_GCC_ATOMIC_HPP diff --git a/include/boost/atomic/detail/gcc-cas.hpp b/include/boost/atomic/detail/gcc-cas.hpp deleted file mode 100644 index da85fa8..0000000 --- a/include/boost/atomic/detail/gcc-cas.hpp +++ /dev/null @@ -1,163 +0,0 @@ -// Copyright (c) 2011 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -// Use the gnu builtin __sync_val_compare_and_swap to build -// atomic operations for 32 bit and smaller. - -#ifndef BOOST_ATOMIC_DETAIL_GENERIC_CAS_HPP -#define BOOST_ATOMIC_DETAIL_GENERIC_CAS_HPP - -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - break; - case memory_order_release: - case memory_order_consume: - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __sync_synchronize(); - break; - } -} - -namespace atomics { -namespace detail { - -inline void -platform_fence_before(memory_order) -{ - /* empty, as compare_and_swap is synchronizing already */ -} - -inline void -platform_fence_after(memory_order) -{ - /* empty, as compare_and_swap is synchronizing already */ -} - -inline void -platform_fence_before_store(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __sync_synchronize(); - break; - } -} - -inline void -platform_fence_after_store(memory_order order) -{ - if (order == memory_order_seq_cst) - __sync_synchronize(); -} - -inline void -platform_fence_after_load(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_consume: - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __sync_synchronize(); - break; - } -} - -template -inline bool -platform_cmpxchg32_strong(T & expected, T desired, volatile T * ptr) -{ - T found = __sync_val_compare_and_swap(ptr, expected, desired); - bool success = (found == expected); - expected = found; - return success; -} - -} -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before_store(order); - const_cast(v_) = 0; - atomics::detail::platform_fence_after_store(order); - } - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before(order); - uint32_t expected = v_; - do { - if (expected == 1) - break; - } while (!atomics::detail::platform_cmpxchg32_strong(expected, (uint32_t)1, &v_)); - atomics::detail::platform_fence_after(order); - return expected; - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -} - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE (__SIZEOF_LONG__ <= 4 ? 2 : 0) -#define BOOST_ATOMIC_LLONG_LOCK_FREE (__SIZEOF_LONG_LONG__ <= 4 ? 2 : 0) -#define BOOST_ATOMIC_POINTER_LOCK_FREE (__SIZEOF_POINTER__ <= 4 ? 2 : 0) -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -#include - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#endif diff --git a/include/boost/atomic/detail/gcc-ppc.hpp b/include/boost/atomic/detail/gcc-ppc.hpp deleted file mode 100644 index ce75c20..0000000 --- a/include/boost/atomic/detail/gcc-ppc.hpp +++ /dev/null @@ -1,3046 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_PPC_HPP -#define BOOST_ATOMIC_DETAIL_GCC_PPC_HPP - -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -/* - Refer to: Motorola: "Programming Environments Manual for 32-Bit - Implementations of the PowerPC Architecture", Appendix E: - "Synchronization Programming Examples" for an explanation of what is - going on here (can be found on the web at various places by the - name "MPCFPE32B.pdf", Google is your friend...) - - Most of the atomic operations map to instructions in a relatively - straight-forward fashion, but "load"s may at first glance appear - a bit strange as they map to: - - lwz %rX, addr - cmpw %rX, %rX - bne- 1f - 1: - - That is, the CPU is forced to perform a branch that "formally" depends - on the value retrieved from memory. This scheme has an overhead of - about 1-2 clock cycles per load, but it allows to map "acquire" to - the "isync" instruction instead of "sync" uniformly and for all type - of atomic operations. Since "isync" has a cost of about 15 clock - cycles, while "sync" hast a cost of about 50 clock cycles, the small - penalty to atomic loads more than compensates for this. - - Byte- and halfword-sized atomic values are realized by encoding the - value to be represented into a word, performing sign/zero extension - as appropriate. This means that after add/sub operations the value - needs fixing up to accurately preserve the wrap-around semantic of - the smaller type. (Nothing special needs to be done for the bit-wise - and the "exchange type" operators as the compiler already sees to - it that values carried in registers are extended appropriately and - everything falls into place naturally). - - The register constraint "b" instructs gcc to use any register - except r0; this is sometimes required because the encoding for - r0 is used to signify "constant zero" in a number of instructions, - making r0 unusable in this place. For simplicity this constraint - is used everywhere since I am to lazy to look this up on a - per-instruction basis, and ppc has enough registers for this not - to pose a problem. -*/ - -namespace boost { -namespace atomics { -namespace detail { - -inline void -ppc_fence_before(memory_order order) -{ - switch(order) - { - case memory_order_release: - case memory_order_acq_rel: -#if defined(__powerpc64__) - __asm__ __volatile__ ("lwsync" ::: "memory"); - break; -#endif - case memory_order_seq_cst: - __asm__ __volatile__ ("sync" ::: "memory"); - default:; - } -} - -inline void -ppc_fence_after(memory_order order) -{ - switch(order) - { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("isync"); - case memory_order_consume: - __asm__ __volatile__ ("" ::: "memory"); - default:; - } -} - -inline void -ppc_fence_after_store(memory_order order) -{ - switch(order) - { - case memory_order_seq_cst: - __asm__ __volatile__ ("sync"); - default:; - } -} - -} -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::ppc_fence_before(order); - const_cast(v_) = 0; - atomics::detail::ppc_fence_after_store(order); - } - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - uint32_t original; - atomics::detail::ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (1) - : "cr0" - ); - atomics::detail::ppc_fence_after(order); - return original; - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -} /* namespace boost */ - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#if defined(__powerpc64__) -#define BOOST_ATOMIC_LLONG_LOCK_FREE 2 -#else -#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 -#endif -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -namespace boost { -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef int32_t storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m"(v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=&r" (v) - : "m" (v_) - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "extsb %1, %1\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "extsb %1, %1\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "and %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "or %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "xor %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m"(v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=&r" (v) - : "m" (v_) - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "rlwinm %1, %1, 0, 0xff\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "rlwinm %1, %1, 0, 0xff\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "and %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "or %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "xor %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef int32_t storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m"(v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=&r" (v) - : "m" (v_) - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "extsh %1, %1\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "extsh %1, %1\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "and %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "or %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "xor %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m"(v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=&r" (v) - : "m" (v_) - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "rlwinm %1, %1, 0, 0xffff\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "rlwinm %1, %1, 0, 0xffff\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "and %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "or %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "xor %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - const_cast(v_) = v; - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - __asm__ __volatile__ - ( - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "+b"(v) - : - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "and %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "or %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "xor %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#if defined(__powerpc64__) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - const_cast(v_) = v; - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - __asm__ __volatile__ - ( - "cmpd %0, %0\n" - "bne- 1f\n" - "1:\n" - : "+b"(v) - : - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y1\n" - "stdcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "add %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "sub %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "and %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "or %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "xor %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#endif - -/* pointer types */ - -#if !defined(__powerpc64__) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m" (v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(v) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m" (v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(v) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "add %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y2\n" - "sub %1,%0,%3\n" - "stwcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#else - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "std %1, %0\n" - : "+m" (v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "ld %0, %1\n" - "cmpd %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(v) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y1\n" - "stdcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "add %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "sub %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - ppc_fence_before(order); - __asm__ __volatile__ - ( - "std %1, %0\n" - : "+m" (v_) - : "r" (v) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v; - __asm__ __volatile__ - ( - "ld %0, %1\n" - "cmpd %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(v) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type original; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y1\n" - "stdcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (v) - : "cr0" - ); - ppc_fence_after(order); - return original; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected), "=&b" (success), "+Z"(v_) - : "b" (expected), "b" (desired) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - return success; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "add %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - value_type original, tmp; - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y2\n" - "sub %1,%0,%3\n" - "stdcx. %1,%y2\n" - "bne- 1b\n" - : "=&b" (original), "=&b" (tmp), "+Z"(v_) - : "b" (v) - : "cc" - ); - ppc_fence_after(order); - return original; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#endif - -/* generic */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m" (v_) - : "r" (tmp) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(tmp) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0, original; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (tmp) - : "cr0" - ); - ppc_fence_after(order); - value_type res; - memcpy(&res, &original, sizeof(value_type)); - return res; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m" (v_) - : "r" (tmp) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(tmp) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0, original; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (tmp) - : "cr0" - ); - ppc_fence_after(order); - value_type res; - memcpy(&res, &original, sizeof(value_type)); - return res; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "stw %1, %0\n" - : "+m" (v_) - : "r" (tmp) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp; - __asm__ __volatile__ - ( - "lwz %0, %1\n" - "cmpw %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(tmp) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0, original; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "lwarx %0,%y1\n" - "stwcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (tmp) - : "cr0" - ); - ppc_fence_after(order); - value_type res; - memcpy(&res, &original, sizeof(value_type)); - return res; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: lwarx %0,%y2\n" - "cmpw %0, %3\n" - "bne- 1f\n" - "stwcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#if defined(__powerpc64__) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint64_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "std %1, %0\n" - : "+m" (v_) - : "r" (tmp) - ); - ppc_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp; - __asm__ __volatile__ - ( - "ld %0, %1\n" - "cmpd %0, %0\n" - "bne- 1f\n" - "1:\n" - : "=r"(tmp) - : "m"(v_) - : "cr0" - ); - ppc_fence_after(order); - - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0, original; - memcpy(&tmp, &v, sizeof(value_type)); - ppc_fence_before(order); - __asm__ __volatile__ - ( - "1:\n" - "ldarx %0,%y1\n" - "stdcx. %2,%y1\n" - "bne- 1b\n" - : "=&b" (original), "+Z"(v_) - : "b" (tmp) - : "cr0" - ); - ppc_fence_after(order); - value_type res; - memcpy(&res, &original, sizeof(value_type)); - return res; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 1f\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - - int success; - ppc_fence_before(success_order); - __asm__ __volatile__ - ( - "li %1, 0\n" - "0: ldarx %0,%y2\n" - "cmpd %0, %3\n" - "bne- 1f\n" - "stdcx. %4,%y2\n" - "bne- 0b\n" - "li %1, 1\n" - "1:" - : "=&b" (expected_s), "=&b" (success), "+Z"(v_) - : "b" (expected_s), "b" (desired_s) - : "cr0" - ); - if (success) - ppc_fence_after(success_order); - else - ppc_fence_after(failure_order); - memcpy(&expected, &expected_s, sizeof(value_type)); - return success; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif - -} -} - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) - { - case memory_order_acquire: - __asm__ __volatile__ ("isync" ::: "memory"); - break; - case memory_order_release: -#if defined(__powerpc64__) - __asm__ __volatile__ ("lwsync" ::: "memory"); - break; -#endif - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("sync" ::: "memory"); - default:; - } -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -inline void -atomic_signal_fence(memory_order order) -{ - switch(order) - { - case memory_order_acquire: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - break; - default:; - } -} - -} - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#endif diff --git a/include/boost/atomic/detail/gcc-sparcv9.hpp b/include/boost/atomic/detail/gcc-sparcv9.hpp deleted file mode 100644 index aa4f93f..0000000 --- a/include/boost/atomic/detail/gcc-sparcv9.hpp +++ /dev/null @@ -1,1335 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_SPARC_HPP -#define BOOST_ATOMIC_DETAIL_GCC_SPARC_HPP - -// Copyright (c) 2010 Helge Bahmann -// Copyright (c) 2013 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -inline void -platform_fence_before(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory"); - /* release */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("membar #Sync" ::: "memory"); - /* seq */ - break; - } -} - -inline void -platform_fence_after(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" ::: "memory"); - /* acquire */ - break; - case memory_order_consume: - /* consume */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("membar #Sync" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void -platform_fence_after_store(memory_order order) -{ - switch(order) - { - case memory_order_seq_cst: - __asm__ __volatile__ ("membar #Sync" ::: "memory"); - default:; - } -} - - -inline void -platform_fence_after_load(memory_order order) -{ - platform_fence_after(order); -} - -} -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before(order); - const_cast(v_) = 0; - atomics::detail::platform_fence_after_store(order); - } - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before(order); - uint32_t tmp = 1; - __asm__ ( - "cas [%1], %2, %0" - : "+r" (tmp) - : "r" (&v_), "r" (0) - : "memory" - ); - atomics::detail::platform_fence_after(order); - return tmp; - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -} /* namespace boost */ - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -namespace boost { - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - break; - case memory_order_release: - __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory"); - break; - case memory_order_acquire: - __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" ::: "memory"); - break; - case memory_order_acq_rel: - __asm__ __volatile__ ("membar #LoadLoad | #LoadStore | #StoreStore" ::: "memory"); - break; - case memory_order_consume: - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("membar #Sync" ::: "memory"); - break; - default:; - } -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -inline void -atomic_signal_fence(memory_order) -{ - __asm__ __volatile__ ("" ::: "memory"); -} - -namespace atomics { -namespace detail { - -/* integral types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef int32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - storage_type desired_s = desired; - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" ((storage_type)expected) - : "memory" - ); - desired = desired_s; - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - storage_type desired_s = desired; - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" ((storage_type)expected) - : "memory" - ); - desired = desired_s; - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef int32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - storage_type desired_s = desired; - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" ((storage_type)expected) - : "memory" - ); - desired = desired_s; - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - typedef uint32_t storage_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - storage_type desired_s = desired; - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" ((storage_type)expected) - : "memory" - ); - desired = desired_s; - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired) - : "r" (&v_), "r" (expected) - : "memory" - ); - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* pointer types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired) - : "r" (&v_), "r" (expected) - : "memory" - ); - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - - bool compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, (char*)tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, (char*)tmp - v, order, memory_order_relaxed)); - return tmp; - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - const_cast(v_) = v; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired) - : "r" (&v_), "r" (expected) - : "memory" - ); - bool success = (desired == expected); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = desired; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp + v, order, memory_order_relaxed)); - return tmp; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, tmp - v, order, memory_order_relaxed)); - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -/* generic types */ - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" (expected_s) - : "memory" - ); - bool success = (desired_s == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &desired_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" (expected_s) - : "memory" - ); - bool success = (desired_s == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &desired_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - platform_fence_after_store(order); - } - - value_type - load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - do {} while(!compare_exchange_weak(tmp, v, order, memory_order_relaxed)); - return tmp; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); - __asm__ ( - "cas [%1], %2, %0" - : "+r" (desired_s) - : "r" (&v_), "r" (expected_s) - : "memory" - ); - bool success = (desired_s == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &desired_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -} -} -} - -#endif diff --git a/include/boost/atomic/detail/gcc-x86.hpp b/include/boost/atomic/detail/gcc-x86.hpp deleted file mode 100644 index bb198b0..0000000 --- a/include/boost/atomic/detail/gcc-x86.hpp +++ /dev/null @@ -1,2021 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GCC_X86_HPP -#define BOOST_ATOMIC_DETAIL_GCC_X86_HPP - -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2012 Tim Blechmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -#if defined(__x86_64__) || defined(__SSE2__) -# define BOOST_ATOMIC_X86_FENCE_INSTR "mfence\n" -#else -# define BOOST_ATOMIC_X86_FENCE_INSTR "lock ; addl $0, (%%esp)\n" -#endif - -#define BOOST_ATOMIC_X86_PAUSE() __asm__ __volatile__ ("pause\n") - -#if defined(__i386__) &&\ - (\ - defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) ||\ - defined(__i586__) || defined(__i686__) || defined(__pentium4__) || defined(__nocona__) || defined(__core2__) || defined(__corei7__) ||\ - defined(__k6__) || defined(__athlon__) || defined(__k8__) || defined(__amdfam10__) || defined(__bdver1__) || defined(__bdver2__) || defined(__bdver3__) || defined(__btver1__) || defined(__btver2__)\ - ) -#define BOOST_ATOMIC_X86_HAS_CMPXCHG8B 1 -#endif - -#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) -#define BOOST_ATOMIC_X86_HAS_CMPXCHG16B 1 -#endif - -inline void -platform_fence_before(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* release */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void -platform_fence_after(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* acquire */ - break; - case memory_order_consume: - /* consume */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void -platform_fence_after_load(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - break; - case memory_order_consume: - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - break; - default:; - } -} - -inline void -platform_fence_before_store(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_acquire: - case memory_order_consume: - break; - case memory_order_release: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* release */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -inline void -platform_fence_after_store(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - case memory_order_release: - break; - case memory_order_acquire: - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - /* acquire */ - break; - case memory_order_consume: - /* consume */ - break; - case memory_order_seq_cst: - __asm__ __volatile__ ("" ::: "memory"); - /* seq */ - break; - default:; - } -} - -} -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - uint32_t v = 1; - atomics::detail::platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+r" (v), "+m" (v_) - ); - atomics::detail::platform_fence_after(order); - return v; - } - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order == memory_order_seq_cst) { - uint32_t v = 0; - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+r" (v), "+m" (v_) - ); - } else { - atomics::detail::platform_fence_before(order); - v_ = 0; - } - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -} /* namespace boost */ - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 - -#if defined(__x86_64__) || defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) -#define BOOST_ATOMIC_LLONG_LOCK_FREE 2 -#endif - -#if defined(BOOST_ATOMIC_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT)) -#define BOOST_ATOMIC_INT128_LOCK_FREE 2 -#endif - -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -namespace boost { - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) - { - case memory_order_relaxed: - break; - case memory_order_release: - __asm__ __volatile__ ("" ::: "memory"); - break; - case memory_order_acquire: - __asm__ __volatile__ ("" ::: "memory"); - break; - case memory_order_acq_rel: - __asm__ __volatile__ ("" ::: "memory"); - break; - case memory_order_consume: - break; - case memory_order_seq_cst: - __asm__ __volatile__ (BOOST_ATOMIC_X86_FENCE_INSTR ::: "memory"); - break; - default:; - } -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -inline void -atomic_signal_fence(memory_order) -{ - __asm__ __volatile__ ("" ::: "memory"); -} - -namespace atomics { -namespace detail { - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddb %0, %1" - : "+q" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgb %0, %1" - : "+q" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgb %3, %1\n\t" - "sete %2" - : "+a" (previous), "+m" (v_), "=q" (success) - : "q" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddw %0, %1" - : "+q" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgw %0, %1" - : "+q" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgw %3, %1\n\t" - "sete %2" - : "+a" (previous), "+m" (v_), "=q" (success) - : "q" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddl %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgl %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#if defined(__x86_64__) -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddq %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgq %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgq %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - value_type tmp = load(memory_order_relaxed); - while (!compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed)) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#endif - -/* pointers */ - -// NOTE: x32 target is still regarded to as x86_64 and can only be detected by the size of pointers -#if !defined(__x86_64__) || (defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 4) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool compare_exchange_strong(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgl %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddl %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return reinterpret_cast(v); - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgl %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddl %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return reinterpret_cast(v); - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#else - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void * value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgq %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool compare_exchange_strong(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgq %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddq %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return reinterpret_cast(v); - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T * value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before(order); - const_cast(v_) = v; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = const_cast(v_); - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgq %0, %1" - : "+r" (v), "+m" (v_) - ); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgq %3, %1\n\t" - "sete %2" - : "+a,a" (previous), "+m,m" (v_), "=q,m" (success) - : "r,r" (desired) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = previous; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - platform_fence_before(order); - __asm__ __volatile__ - ( - "lock ; xaddq %0, %1" - : "+r" (v), "+m" (v_) - : - : "cc" - ); - platform_fence_after(order); - return reinterpret_cast(v); - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -#endif - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint8_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : - v_(reinterpret_cast(v)) - { - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgb %0, %1" - : "+q" (tmp), "+m" (v_) - ); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - storage_type previous_s = expected_s; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgb %3, %1\n\t" - "sete %2" - : "+a" (previous_s), "+m" (v_), "=q" (success) - : "q" (desired_s) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &previous_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint16_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : - v_(reinterpret_cast(v)) - { - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgw %0, %1" - : "+q" (tmp), "+m" (v_) - ); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s, desired_s; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - storage_type previous_s = expected_s; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgw %3, %1\n\t" - "sete %2" - : "+a" (previous_s), "+m" (v_), "=q" (success) - : "q" (desired_s) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &previous_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgl %0, %1" - : "+q" (tmp), "+m" (v_) - ); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - storage_type previous_s = expected_s; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgl %3, %1\n\t" - "sete %2" - : "+a,a" (previous_s), "+m,m" (v_), "=q,m" (success) - : "q,q" (desired_s) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &previous_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#if defined(__x86_64__) -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint64_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - const_cast(v_) = tmp; - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = const_cast(v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - __asm__ __volatile__ - ( - "xchgq %0, %1" - : "+q" (tmp), "+m" (v_) - ); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - storage_type previous_s = expected_s; - platform_fence_before(success_order); - bool success; - __asm__ __volatile__ - ( - "lock ; cmpxchgq %3, %1\n\t" - "sete %2" - : "+a,a" (previous_s), "+m,m" (v_), "=q,m" (success) - : "q,q" (desired_s) - : "cc" - ); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &previous_s, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; -#endif - -#if !defined(__x86_64__) && defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) - -template -inline bool -platform_cmpxchg64_strong(T & expected, T desired, volatile T * ptr) BOOST_NOEXCEPT -{ -#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 - const T oldval = __sync_val_compare_and_swap(ptr, expected, desired); - const bool result = (oldval == expected); - expected = oldval; - return result; -#else - uint32_t scratch; - /* Make sure ebx is saved and restored properly in case - this object is compiled as "position independent". Since - programmers on x86 tend to forget specifying -DPIC or - similar, always assume PIC. - - To make this work uniformly even in the non-PIC case, - setup register constraints such that ebx can not be - used by accident e.g. as base address for the variable - to be modified. Accessing "scratch" should always be okay, - as it can only be placed on the stack (and therefore - accessed through ebp or esp only). - - In theory, could push/pop ebx onto/off the stack, but movs - to a prepared stack slot turn out to be faster. */ - bool success; - __asm__ __volatile__ - ( - "movl %%ebx, %[scratch]\n\t" - "movl %[desired_lo], %%ebx\n\t" - "lock; cmpxchg8b %[dest]\n\t" - "movl %[scratch], %%ebx\n\t" - "sete %[success]" - : "+A,A,A,A,A,A" (expected), [dest] "+m,m,m,m,m,m" (*ptr), [scratch] "=m,m,m,m,m,m" (scratch), [success] "=q,m,q,m,q,m" (success) - : [desired_lo] "S,S,D,D,m,m" ((uint32_t)desired), "c,c,c,c,c,c" ((uint32_t)(desired >> 32)) - : "memory", "cc" - ); - return success; -#endif -} - -// Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 3A, 8.1.1. Guaranteed Atomic Operations: -// -// The Pentium processor (and newer processors since) guarantees that the following additional memory operations will always be carried out atomically: -// * Reading or writing a quadword aligned on a 64-bit boundary -// -// Luckily, the memory is almost always 8-byte aligned in our case because atomic<> uses 64 bit native types for storage and dynamic memory allocations -// have at least 8 byte alignment. The only unfortunate case is when atomic is placeod on the stack and it is not 8-byte aligned (like on 32 bit Windows). - -template -inline void -platform_store64(T value, volatile T * ptr) BOOST_NOEXCEPT -{ - if (((uint32_t)ptr & 0x00000007) == 0) - { -#if defined(__SSE2__) - __asm__ __volatile__ - ( - "movq %1, %%xmm4\n\t" - "movq %%xmm4, %0\n\t" - : "=m" (*ptr) - : "m" (value) - : "memory", "xmm4" - ); -#else - __asm__ __volatile__ - ( - "fildll %1\n\t" - "fistpll %0\n\t" - : "=m" (*ptr) - : "m" (value) - : "memory" - ); -#endif - } - else - { - uint32_t scratch; - __asm__ __volatile__ - ( - "movl %%ebx, %[scratch]\n\t" - "movl %[value_lo], %%ebx\n\t" - "movl 0(%[dest]), %%eax\n\t" - "movl 4(%[dest]), %%edx\n\t" - ".align 16\n\t" - "1: lock; cmpxchg8b 0(%[dest])\n\t" - "jne 1b\n\t" - "movl %[scratch], %%ebx" - : [scratch] "=m,m" (scratch) - : [value_lo] "a,a" ((uint32_t)value), "c,c" ((uint32_t)(value >> 32)), [dest] "D,S" (ptr) - : "memory", "cc", "edx" - ); - } -} - -template -inline T -platform_load64(const volatile T * ptr) BOOST_NOEXCEPT -{ - T value; - - if (((uint32_t)ptr & 0x00000007) == 0) - { -#if defined(__SSE2__) - __asm__ __volatile__ - ( - "movq %1, %%xmm4\n\t" - "movq %%xmm4, %0\n\t" - : "=m" (value) - : "m" (*ptr) - : "memory", "xmm4" - ); -#else - __asm__ __volatile__ - ( - "fildll %1\n\t" - "fistpll %0\n\t" - : "=m" (value) - : "m" (*ptr) - : "memory" - ); -#endif - } - else - { - // We don't care for comparison result here; the previous value will be stored into value anyway. - // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b. - __asm__ __volatile__ - ( - "movl %%ebx, %%eax\n\t" - "movl %%ecx, %%edx\n\t" - "lock; cmpxchg8b %[dest]" - : "=&A" (value) - : [dest] "m" (*ptr) - : "cc" - ); - } - - return value; -} - -#endif - -#if defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 - -template -inline bool -platform_cmpxchg128_strong(T& expected, T desired, volatile T* ptr) BOOST_NOEXCEPT -{ - uint64_t const* p_desired = (uint64_t const*)&desired; - bool success; - __asm__ __volatile__ - ( - "lock; cmpxchg16b %[dest]\n\t" - "sete %[success]" - : "+A,A" (expected), [dest] "+m,m" (*ptr), [success] "=q,m" (success) - : "b,b" (p_desired[0]), "c,c" (p_desired[1]) - : "memory", "cc" - ); - return success; -} - -template -inline void -platform_store128(T value, volatile T* ptr) BOOST_NOEXCEPT -{ - uint64_t const* p_value = (uint64_t const*)&value; - __asm__ __volatile__ - ( - "movq 0(%[dest]), %%rax\n\t" - "movq 8(%[dest]), %%rdx\n\t" - ".align 16\n\t" - "1: lock; cmpxchg16b 0(%[dest])\n\t" - "jne 1b" - : - : "b" (p_value[0]), "c" (p_value[1]), [dest] "r" (ptr) - : "memory", "cc", "rax", "rdx" - ); -} - -template -inline T -platform_load128(const volatile T* ptr) BOOST_NOEXCEPT -{ - T value; - - // We don't care for comparison result here; the previous value will be stored into value anyway. - // Also we don't care for rbx and rcx values, they just have to be equal to rax and rdx before cmpxchg16b. - __asm__ __volatile__ - ( - "movq %%rbx, %%rax\n\t" - "movq %%rcx, %%rdx\n\t" - "lock; cmpxchg16b %[dest]" - : "=&A" (value) - : [dest] "m" (*ptr) - : "cc" - ); - - return value; -} - -#endif // defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 - -} -} -} - -/* pull in 64-bit atomic type using cmpxchg8b above */ -#if !defined(__x86_64__) && defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) -#include -#endif - -/* pull in 128-bit atomic type using cmpxchg16b above */ -#if defined(BOOST_ATOMIC_INT128_LOCK_FREE) && BOOST_ATOMIC_INT128_LOCK_FREE > 0 -#include -#endif - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#endif diff --git a/include/boost/atomic/detail/generic-cas.hpp b/include/boost/atomic/detail/generic-cas.hpp deleted file mode 100644 index cf4a3d7..0000000 --- a/include/boost/atomic/detail/generic-cas.hpp +++ /dev/null @@ -1,206 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_GENERIC_CAS_HPP -#define BOOST_ATOMIC_DETAIL_GENERIC_CAS_HPP - -// Copyright (c) 2009 Helge Bahmann -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -/* fallback implementation for various compilation targets; -this is *not* efficient, particularly because all operations -are fully fenced (full memory barriers before and after -each operation) */ - -#if defined(__GNUC__) - namespace boost { namespace atomics { namespace detail { - inline int32_t - fenced_compare_exchange_strong_32(volatile int32_t *ptr, int32_t expected, int32_t desired) - { - return __sync_val_compare_and_swap_4(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - - #if defined(__amd64__) || defined(__i686__) - inline int64_t - fenced_compare_exchange_strong_64(int64_t *ptr, int64_t expected, int64_t desired) - { - return __sync_val_compare_and_swap_8(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif defined(__ICL) || defined(_MSC_VER) - - #if defined(_MSC_VER) - #include - #include - #endif - - namespace boost { namespace atomics { namespace detail { - inline int32_t - fenced_compare_exchange_strong(int32_t *ptr, int32_t expected, int32_t desired) - { - return _InterlockedCompareExchange(reinterpret_cast(ptr), desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - #if defined(_WIN64) - inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return _InterlockedCompareExchange64(ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif (defined(__ICC) || defined(__ECC)) - namespace boost { namespace atomics { namespace detail { - inline int32_t - fenced_compare_exchange_strong_32(int32_t *ptr, int32_t expected, int32_t desired) - { - return _InterlockedCompareExchange((void*)ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - #if defined(__x86_64) - inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return cas64(ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #elif defined(__ECC) //IA-64 version - inline int64_t - fenced_compare_exchange_strong(int64_t *ptr, int64_t expected, int64_t desired) - { - return _InterlockedCompareExchange64((void*)ptr, desired, expected); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - #endif - }}} - -#elif (defined(__SUNPRO_CC) && defined(__sparc)) - #include - namespace boost { namespace atomics { namespace detail { - inline int32_t - fenced_compare_exchange_strong_32(int32_t *ptr, int32_t expected, int32_t desired) - { - return atomic_cas_32((volatile unsigned int*)ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS32 1 - - /* FIXME: check for 64 bit mode */ - inline int64_t - fenced_compare_exchange_strong_64(int64_t *ptr, int64_t expected, int64_t desired) - { - return atomic_cas_64((volatile unsigned long long*)ptr, expected, desired); - } - #define BOOST_ATOMIC_HAVE_CAS64 1 - }}} -#endif - - -namespace boost { -namespace atomics { -namespace detail { - -#ifdef BOOST_ATOMIC_HAVE_CAS32 -template -class atomic_generic_cas32 -{ -private: - typedef atomic_generic_cas32 this_type; -public: - explicit atomic_generic_cas32(T v) : i((int32_t)v) {} - atomic_generic_cas32() {} - T load(memory_order order=memory_order_seq_cst) const volatile - { - T expected=(T)i; - do { } while(!const_cast(this)->compare_exchange_weak(expected, expected, order, memory_order_relaxed)); - return expected; - } - void store(T v, memory_order order=memory_order_seq_cst) volatile - { - exchange(v); - } - bool compare_exchange_strong( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - T found; - found=(T)fenced_compare_exchange_strong_32(&i, (int32_t)expected, (int32_t)desired); - bool success=(found==expected); - expected=found; - return success; - } - bool compare_exchange_weak( - T &expected, - T desired, - memory_order success_order, - memory_order failure_order) volatile - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - T exchange(T r, memory_order order=memory_order_seq_cst) volatile - { - T expected=(T)i; - do { } while(!compare_exchange_weak(expected, r, order, memory_order_relaxed)); - return expected; - } - - bool is_lock_free(void) const volatile {return true;} - typedef T integral_type; -private: - mutable int32_t i; -}; - -template -class platform_atomic_integral : - public build_atomic_from_exchange > -{ -public: - typedef build_atomic_from_exchange > super; - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : - public build_atomic_from_larger_type, T> -{ -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; - -template -class platform_atomic_integral : - public build_atomic_from_larger_type, T> -{ -public: - typedef build_atomic_from_larger_type, T> super; - - explicit platform_atomic_integral(T v) : super(v) {} - platform_atomic_integral(void) {} -}; -#endif - -} } } - -#endif diff --git a/include/boost/atomic/detail/linux-arm.hpp b/include/boost/atomic/detail/linux-arm.hpp deleted file mode 100644 index 702ac3b..0000000 --- a/include/boost/atomic/detail/linux-arm.hpp +++ /dev/null @@ -1,192 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_LINUX_ARM_HPP -#define BOOST_ATOMIC_DETAIL_LINUX_ARM_HPP - -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) -// -// Copyright (c) 2009, 2011 Helge Bahmann -// Copyright (c) 2009 Phil Endecott -// Copyright (c) 2013 Tim Blechmann -// Linux-specific code by Phil Endecott - -// Different ARM processors have different atomic instructions. In particular, -// architecture versions before v6 (which are still in widespread use, e.g. the -// Intel/Marvell XScale chips like the one in the NSLU2) have only atomic swap. -// On Linux the kernel provides some support that lets us abstract away from -// these differences: it provides emulated CAS and barrier functions at special -// addresses that are guaranteed not to be interrupted by the kernel. Using -// this facility is slightly slower than inline assembler would be, but much -// faster than a system call. -// -// While this emulated CAS is "strong" in the sense that it does not fail -// "spuriously" (i.e.: it never fails to perform the exchange when the value -// found equals the value expected), it does not return the found value on -// failure. To satisfy the atomic API, compare_exchange_{weak|strong} must -// return the found value on failure, and we have to manually load this value -// after the emulated CAS reports failure. This in turn introduces a race -// between the CAS failing (due to the "wrong" value being found) and subsequently -// loading (which might turn up the "right" value). From an application's -// point of view this looks like "spurious failure", and therefore the -// emulated CAS is only good enough to provide compare_exchange_weak -// semantics. - -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -namespace boost { -namespace atomics { -namespace detail { - -inline void -arm_barrier(void) -{ - void (*kernel_dmb)(void) = (void (*)(void)) 0xffff0fa0; - kernel_dmb(); -} - -inline void -platform_fence_before(memory_order order) -{ - switch(order) { - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - arm_barrier(); - case memory_order_consume: - default:; - } -} - -inline void -platform_fence_after(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - arm_barrier(); - default:; - } -} - -inline void -platform_fence_before_store(memory_order order) -{ - platform_fence_before(order); -} - -inline void -platform_fence_after_store(memory_order order) -{ - if (order == memory_order_seq_cst) - arm_barrier(); -} - -inline void -platform_fence_after_load(memory_order order) -{ - platform_fence_after(order); -} - -template -inline bool -platform_cmpxchg32(T & expected, T desired, volatile T * ptr) -{ - typedef T (*kernel_cmpxchg32_t)(T oldval, T newval, volatile T * ptr); - - if (((kernel_cmpxchg32_t) 0xffff0fc0)(expected, desired, ptr) == 0) { - return true; - } else { - expected = *ptr; - return false; - } -} - -} -} - -#define BOOST_ATOMIC_THREAD_FENCE 2 -inline void -atomic_thread_fence(memory_order order) -{ - switch(order) { - case memory_order_acquire: - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - atomics::detail::arm_barrier(); - default:; - } -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -inline void -atomic_signal_fence(memory_order) -{ - __asm__ __volatile__ ("" ::: "memory"); -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before_store(order); - const_cast(v_) = 0; - atomics::detail::platform_fence_after_store(order); - } - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - atomics::detail::platform_fence_before(order); - uint32_t expected = v_; - do { - if (expected == 1) - break; - } while (!atomics::detail::platform_cmpxchg32(expected, (uint32_t)1, &v_)); - atomics::detail::platform_fence_after(order); - return expected; - } - - BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) - BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) -}; - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -} - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2 -#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2 -#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -#include - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#endif diff --git a/include/boost/atomic/detail/windows.hpp b/include/boost/atomic/detail/windows.hpp deleted file mode 100644 index 02d1106..0000000 --- a/include/boost/atomic/detail/windows.hpp +++ /dev/null @@ -1,1789 +0,0 @@ -#ifndef BOOST_ATOMIC_DETAIL_WINDOWS_HPP -#define BOOST_ATOMIC_DETAIL_WINDOWS_HPP - -// Copyright (c) 2009 Helge Bahmann -// Copyright (c) 2012 Andrey Semashev -// Copyright (c) 2013 Tim Blechmann, Andrey Semashev -// -// Distributed under the Boost Software License, Version 1.0. -// See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -#include -#include -#include -#include -#include -#include - -#ifdef BOOST_HAS_PRAGMA_ONCE -#pragma once -#endif - -#ifdef _MSC_VER -#pragma warning(push) -// 'order' : unreferenced formal parameter -#pragma warning(disable: 4100) -#endif - -#if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86)) -extern "C" void _mm_pause(void); -#pragma intrinsic(_mm_pause) -#define BOOST_ATOMIC_X86_PAUSE() _mm_pause() -#else -#define BOOST_ATOMIC_X86_PAUSE() -#endif - -#if defined(_M_IX86) && _M_IX86 >= 500 -#define BOOST_ATOMIC_X86_HAS_CMPXCHG8B 1 -#endif - -// Define hardware barriers -#if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2)) -extern "C" void _mm_mfence(void); -#pragma intrinsic(_mm_mfence) -#endif - -#if defined(BOOST_MSVC) && defined(_M_ARM) -extern "C" void __dmb(unsigned int); -#pragma intrinsic(__dmb) -extern "C" __int8 __iso_volatile_load8(const volatile __int8*); -#pragma intrinsic(__iso_volatile_load8) -extern "C" __int16 __iso_volatile_load16(const volatile __int16*); -#pragma intrinsic(__iso_volatile_load16) -extern "C" __int32 __iso_volatile_load32(const volatile __int32*); -#pragma intrinsic(__iso_volatile_load32) -extern "C" __int64 __iso_volatile_load64(const volatile __int64*); -#pragma intrinsic(__iso_volatile_load64) -extern "C" void __iso_volatile_store8(volatile __int8*, __int8); -#pragma intrinsic(__iso_volatile_store8) -extern "C" void __iso_volatile_store16(volatile __int16*, __int16); -#pragma intrinsic(__iso_volatile_store16) -extern "C" void __iso_volatile_store32(volatile __int32*, __int32); -#pragma intrinsic(__iso_volatile_store32) -extern "C" void __iso_volatile_store64(volatile __int64*, __int64); -#pragma intrinsic(__iso_volatile_store64) - -#define BOOST_ATOMIC_LOAD8(p) __iso_volatile_load8((const volatile __int8*)(p)) -#define BOOST_ATOMIC_LOAD16(p) __iso_volatile_load16((const volatile __int16*)(p)) -#define BOOST_ATOMIC_LOAD32(p) __iso_volatile_load32((const volatile __int32*)(p)) -#define BOOST_ATOMIC_LOAD64(p) __iso_volatile_load64((const volatile __int64*)(p)) -#define BOOST_ATOMIC_STORE8(p, v) __iso_volatile_store8((const volatile __int8*)(p), (__int8)(v)) -#define BOOST_ATOMIC_STORE16(p, v) __iso_volatile_store16((const volatile __int16*)(p), (__int16)(v)) -#define BOOST_ATOMIC_STORE32(p, v) __iso_volatile_store32((const volatile __int32*)(p), (__int32)(v)) -#define BOOST_ATOMIC_STORE64(p, v) __iso_volatile_store64((const volatile __int64*)(p), (__int64)(v)) - -#else - -#define BOOST_ATOMIC_LOAD8(p) *p -#define BOOST_ATOMIC_LOAD16(p) *p -#define BOOST_ATOMIC_LOAD32(p) *p -#define BOOST_ATOMIC_LOAD64(p) *p -#define BOOST_ATOMIC_STORE8(p, v) *p = v -#define BOOST_ATOMIC_STORE16(p, v) *p = v -#define BOOST_ATOMIC_STORE32(p, v) *p = v -#define BOOST_ATOMIC_STORE64(p, v) *p = v - -#endif - -// Define compiler barriers -#if defined(__INTEL_COMPILER) -#define BOOST_ATOMIC_COMPILER_BARRIER() __memory_barrier() -#elif defined(_MSC_VER) && !defined(_WIN32_WCE) -extern "C" void _ReadWriteBarrier(void); -#pragma intrinsic(_ReadWriteBarrier) -#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier() -#endif - -#ifndef BOOST_ATOMIC_COMPILER_BARRIER -#define BOOST_ATOMIC_COMPILER_BARRIER() -#endif - -namespace boost { -namespace atomics { -namespace detail { - -BOOST_FORCEINLINE void hardware_full_fence(void) BOOST_NOEXCEPT -{ -#if defined(BOOST_MSVC) && defined(_M_ARM) - __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later -#elif defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2)) - // Use mfence only if SSE2 is available - _mm_mfence(); -#else - long tmp; - BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&tmp, 0); -#endif -} - -BOOST_FORCEINLINE void -platform_fence_before(memory_order order) BOOST_NOEXCEPT -{ - BOOST_ATOMIC_COMPILER_BARRIER(); - -#if defined(BOOST_MSVC) && defined(_M_ARM) - switch(order) - { - case memory_order_release: - case memory_order_acq_rel: - case memory_order_seq_cst: - hardware_full_fence(); - case memory_order_consume: - default:; - } - - BOOST_ATOMIC_COMPILER_BARRIER(); -#endif -} - -BOOST_FORCEINLINE void -platform_fence_after(memory_order order) BOOST_NOEXCEPT -{ - BOOST_ATOMIC_COMPILER_BARRIER(); - -#if defined(BOOST_MSVC) && defined(_M_ARM) - switch(order) - { - case memory_order_acquire: - case memory_order_acq_rel: - case memory_order_seq_cst: - hardware_full_fence(); - default:; - } - - BOOST_ATOMIC_COMPILER_BARRIER(); -#endif -} - -BOOST_FORCEINLINE void -platform_fence_before_store(memory_order order) BOOST_NOEXCEPT -{ - platform_fence_before(order); -} - -BOOST_FORCEINLINE void -platform_fence_after_store(memory_order order) BOOST_NOEXCEPT -{ - BOOST_ATOMIC_COMPILER_BARRIER(); - -#if defined(BOOST_MSVC) && defined(_M_ARM) - if (order == memory_order_seq_cst) - hardware_full_fence(); - - BOOST_ATOMIC_COMPILER_BARRIER(); -#endif -} - -BOOST_FORCEINLINE void -platform_fence_after_load(memory_order order) BOOST_NOEXCEPT -{ - BOOST_ATOMIC_COMPILER_BARRIER(); - - // On x86 and x86_64 there is no need for a hardware barrier, - // even if seq_cst memory order is requested, because all - // seq_cst writes are implemented with lock-prefixed operations - // or xchg which has implied lock prefix. Therefore normal loads - // are already ordered with seq_cst stores on these architectures. - -#if !(defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86))) - if (order == memory_order_seq_cst) - hardware_full_fence(); -#endif -} - -} // namespace detail -} // namespace atomics - -#define BOOST_ATOMIC_THREAD_FENCE 2 -BOOST_FORCEINLINE void -atomic_thread_fence(memory_order order) -{ - BOOST_ATOMIC_COMPILER_BARRIER(); - if (order == memory_order_seq_cst) - atomics::detail::hardware_full_fence(); -} - -#define BOOST_ATOMIC_SIGNAL_FENCE 2 -BOOST_FORCEINLINE void -atomic_signal_fence(memory_order) -{ - BOOST_ATOMIC_COMPILER_BARRIER(); -} - -class atomic_flag -{ -private: - uint32_t v_; - -public: - BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {} - - bool - test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - BOOST_ATOMIC_COMPILER_BARRIER(); - const uint32_t old = (uint32_t)BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, 1); - BOOST_ATOMIC_COMPILER_BARRIER(); - return old != 0; - } - - void - clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - atomics::detail::platform_fence_before_store(order); - BOOST_ATOMIC_STORE32(&v_, 0); - atomics::detail::platform_fence_after_store(order); - } else { - BOOST_ATOMIC_COMPILER_BARRIER(); - BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, 0); - BOOST_ATOMIC_COMPILER_BARRIER(); - } - } - - BOOST_DELETED_FUNCTION(atomic_flag(const atomic_flag&)) - BOOST_DELETED_FUNCTION(atomic_flag & operator= (const atomic_flag&)) -}; - -} // namespace boost - -#define BOOST_ATOMIC_FLAG_LOCK_FREE 2 - -#include - -#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) - -#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 -#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 -#define BOOST_ATOMIC_INT_LOCK_FREE 2 -#define BOOST_ATOMIC_LONG_LOCK_FREE 2 -#if defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) || defined(_M_AMD64) || defined(_M_IA64) -#define BOOST_ATOMIC_LLONG_LOCK_FREE 2 -#else -#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 -#endif -#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 -#define BOOST_ATOMIC_BOOL_LOCK_FREE 2 - -namespace boost { -namespace atomics { -namespace detail { - -#if defined(_MSC_VER) -#pragma warning(push) -// 'char' : forcing value to bool 'true' or 'false' (performance warning) -#pragma warning(disable: 4800) -#endif - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8 - typedef value_type storage_type; -#else - typedef uint32_t storage_type; -#endif - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); - BOOST_ATOMIC_STORE8(&v_, static_cast< storage_type >(v)); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = static_cast< value_type >(BOOST_ATOMIC_LOAD8(&v_)); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8 - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&v_, v)); -#else - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&v_, v)); -#endif - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - typedef typename make_signed< value_type >::type signed_value_type; - return fetch_add(static_cast< value_type >(-static_cast< signed_value_type >(v)), order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE8 - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&v_, v)); -#else - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, v)); -#endif - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8 - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&v_, desired, previous)); -#else - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired, previous)); -#endif - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_AND8 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND8(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_AND) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_OR8 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR8(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_OR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_XOR8 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR8(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_XOR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#if defined(_MSC_VER) -#pragma warning(pop) -#endif - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16 - typedef value_type storage_type; -#else - typedef uint32_t storage_type; -#endif - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); - BOOST_ATOMIC_STORE16(&v_, static_cast< storage_type >(v)); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = static_cast< value_type >(BOOST_ATOMIC_LOAD16(&v_)); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16 - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&v_, v)); -#else - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&v_, v)); -#endif - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - typedef typename make_signed< value_type >::type signed_value_type; - return fetch_add(static_cast< value_type >(-static_cast< signed_value_type >(v)), order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE16 - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&v_, v)); -#else - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, v)); -#endif - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16 - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&v_, desired, previous)); -#else - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired, previous)); -#endif - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_AND16 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND16(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_AND) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_OR16 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR16(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_OR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#ifdef BOOST_ATOMIC_INTERLOCKED_XOR16 - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR16(&v_, v)); - platform_fence_after(order); - return v; -#elif defined(BOOST_ATOMIC_INTERLOCKED_XOR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef value_type storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); - BOOST_ATOMIC_STORE32(&v_, static_cast< storage_type >(v)); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = static_cast< value_type >(BOOST_ATOMIC_LOAD32(&v_)); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&v_, v)); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - typedef typename make_signed< value_type >::type signed_value_type; - return fetch_add(static_cast< value_type >(-static_cast< signed_value_type >(v)), order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, v)); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired, previous)); - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_AND) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_OR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for(; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_XOR) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -// MSVC 2012 fails to recognize sizeof(T) as a constant expression in template specializations -enum msvc_sizeof_pointer_workaround { sizeof_pointer = sizeof(void*) }; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef std::ptrdiff_t difference_type; - typedef void* value_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); -#if defined(BOOST_MSVC) && defined(_M_ARM) - BOOST_ATOMIC_STORE32(&v_, v); -#else - const_cast(v_) = v; -#endif - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { -#if defined(BOOST_MSVC) && defined(_M_ARM) - value_type v = (value_type)BOOST_ATOMIC_LOAD32(&v_); -#else - value_type v = const_cast(v_); -#endif - platform_fence_after_load(order); - return v; - } - - value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = (value_type)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(&v_, v); - platform_fence_after(order); - return v; - } - - bool compare_exchange_strong(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - value_type oldval = (value_type)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&v_, desired, previous); - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool compare_exchange_weak(value_type & expected, value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - value_type res = (value_type)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(&v_, v); - platform_fence_after(order); - return res; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T* value_type; - typedef std::ptrdiff_t difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); -#if defined(BOOST_MSVC) && defined(_M_ARM) - BOOST_ATOMIC_STORE32(&v_, v); -#else - const_cast(v_) = v; -#endif - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { -#if defined(BOOST_MSVC) && defined(_M_ARM) - value_type v = (value_type)BOOST_ATOMIC_LOAD32(&v_); -#else - value_type v = const_cast(v_); -#endif - platform_fence_after_load(order); - return v; - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = (value_type)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(&v_, v); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - value_type oldval = (value_type)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(&v_, desired, previous); - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - v = v * sizeof(*v_); - platform_fence_before(order); - value_type res = (value_type)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(&v_, v); - platform_fence_after(order); - return res; - } - - value_type - fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - return fetch_add(-v, order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_POINTER_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - value_type v_; -}; - - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8 - typedef uint8_t storage_type; -#else - typedef uint32_t storage_type; -#endif - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8 - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v)) - { - } -#else - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } -#endif - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - BOOST_ATOMIC_STORE8(&v_, tmp); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = (storage_type)BOOST_ATOMIC_LOAD8(&v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE8 - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&v_, tmp)); -#else - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, tmp)); -#endif - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8 - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&v_, desired_s, expected_s)); -#else - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired_s, expected_s)); -#endif - bool success = (oldval == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &oldval, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16 - typedef uint16_t storage_type; -#else - typedef uint32_t storage_type; -#endif - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16 - BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(reinterpret_cast< storage_type const& >(v)) - { - } -#else - explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } -#endif - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - BOOST_ATOMIC_STORE16(&v_, tmp); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = (storage_type)BOOST_ATOMIC_LOAD16(&v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); -#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE16 - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&v_, tmp)); -#else - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, tmp)); -#endif - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); -#ifdef BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16 - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&v_, desired_s, expected_s)); -#else - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired_s, expected_s)); -#endif - bool success = (oldval == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &oldval, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint32_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - BOOST_ATOMIC_STORE32(&v_, tmp); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = (storage_type)BOOST_ATOMIC_LOAD32(&v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, tmp)); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&v_, desired_s, expected_s)); - bool success = (oldval == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &oldval, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#if defined(_M_AMD64) || defined(_M_IA64) - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef value_type storage_type; - typedef T difference_type; - -protected: - typedef value_type value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {} - - void - store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - platform_fence_before_store(order); - BOOST_ATOMIC_STORE64(&v_, v); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - value_type v = static_cast< value_type >(BOOST_ATOMIC_LOAD64(&v_)); - platform_fence_after_load(order); - return v; - } - - value_type - fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&v_, v)); - platform_fence_after(order); - return v; - } - - value_type - fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - typedef typename make_signed< value_type >::type signed_value_type; - return fetch_add(static_cast< value_type >(-static_cast< signed_value_type >(v)), order); - } - - value_type - exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&v_, v)); - platform_fence_after(order); - return v; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - value_type previous = expected; - platform_fence_before(success_order); - value_type oldval = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&v_, desired, previous)); - bool success = (previous == oldval); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - expected = oldval; - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - value_type - fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_AND64) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_AND64(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_OR64) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_OR64(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - value_type - fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { -#if defined(BOOST_ATOMIC_INTERLOCKED_XOR64) - platform_fence_before(order); - v = static_cast< value_type >(BOOST_ATOMIC_INTERLOCKED_XOR64(&v_, v)); - platform_fence_after(order); - return v; -#else - value_type tmp = load(memory_order_relaxed); - for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);) - { - BOOST_ATOMIC_X86_PAUSE(); - } - return tmp; -#endif - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -template -class base_atomic -{ -private: - typedef base_atomic this_type; - typedef T value_type; - typedef uint64_t storage_type; - -protected: - typedef value_type const& value_arg_type; - -public: - BOOST_DEFAULTED_FUNCTION(base_atomic(void), {}) - explicit base_atomic(value_type const& v) : v_(0) - { - memcpy(&v_, &v, sizeof(value_type)); - } - - void - store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - if (order != memory_order_seq_cst) { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before_store(order); - BOOST_ATOMIC_STORE64(&v_, tmp); - platform_fence_after_store(order); - } else { - exchange(v, order); - } - } - - value_type - load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT - { - storage_type tmp = (storage_type)BOOST_ATOMIC_LOAD64(&v_); - platform_fence_after_load(order); - value_type v; - memcpy(&v, &tmp, sizeof(value_type)); - return v; - } - - value_type - exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT - { - storage_type tmp = 0; - memcpy(&tmp, &v, sizeof(value_type)); - platform_fence_before(order); - tmp = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&v_, tmp)); - platform_fence_after(order); - value_type res; - memcpy(&res, &tmp, sizeof(value_type)); - return res; - } - - bool - compare_exchange_strong( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - storage_type expected_s = 0, desired_s = 0; - memcpy(&expected_s, &expected, sizeof(value_type)); - memcpy(&desired_s, &desired, sizeof(value_type)); - platform_fence_before(success_order); - storage_type oldval = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&v_, desired_s, expected_s)); - bool success = (oldval == expected_s); - if (success) - platform_fence_after(success_order); - else - platform_fence_after(failure_order); - memcpy(&expected, &oldval, sizeof(value_type)); - return success; - } - - bool - compare_exchange_weak( - value_type & expected, - value_type const& desired, - memory_order success_order, - memory_order failure_order) volatile BOOST_NOEXCEPT - { - return compare_exchange_strong(expected, desired, success_order, failure_order); - } - - bool - is_lock_free(void) const volatile BOOST_NOEXCEPT - { - return true; - } - - BOOST_ATOMIC_DECLARE_BASE_OPERATORS - - BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) - BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) - -private: - storage_type v_; -}; - -#elif defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) - -template -inline bool -platform_cmpxchg64_strong(T & expected, T desired, volatile T * p) BOOST_NOEXCEPT -{ -#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64) - const T oldval = BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(p, desired, expected); - const bool result = (oldval == expected); - expected = oldval; - return result; -#else - bool result; - __asm - { - mov edi, p - mov esi, expected - mov ebx, dword ptr [desired] - mov ecx, dword ptr [desired + 4] - mov eax, dword ptr [esi] - mov edx, dword ptr [esi + 4] - lock cmpxchg8b qword ptr [edi] - mov dword ptr [esi], eax - mov dword ptr [esi + 4], edx - sete result - }; - return result; -#endif -} - -// Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 3A, 8.1.1. Guaranteed Atomic Operations: -// -// The Pentium processor (and newer processors since) guarantees that the following additional memory operations will always be carried out atomically: -// * Reading or writing a quadword aligned on a 64-bit boundary -// -// Luckily, the memory is almost always 8-byte aligned in our case because atomic<> uses 64 bit native types for storage and dynamic memory allocations -// have at least 8 byte alignment. The only unfortunate case is when atomic is placeod on the stack and it is not 8-byte aligned (like on 32 bit Windows). - -template -inline void -platform_store64(T value, volatile T * p) BOOST_NOEXCEPT -{ - if (((uint32_t)p & 0x00000007) == 0) - { -#if defined(_M_IX86_FP) && _M_IX86_FP >= 2 - __asm - { - mov edx, p - movq xmm4, value - movq qword ptr [edx], xmm4 - }; -#else - __asm - { - mov edx, p - fild value - fistp qword ptr [edx] - }; -#endif - } - else - { - __asm - { - mov edi, p - mov ebx, dword ptr [value] - mov ecx, dword ptr [value + 4] - mov eax, dword ptr [edi] - mov edx, dword ptr [edi + 4] - align 16 -again: - lock cmpxchg8b qword ptr [edi] - jne again - }; - } -} - -template -inline T -platform_load64(const volatile T * p) BOOST_NOEXCEPT -{ - T value; - - if (((uint32_t)p & 0x00000007) == 0) - { -#if defined(_M_IX86_FP) && _M_IX86_FP >= 2 - __asm - { - mov edx, p - movq xmm4, qword ptr [edx] - movq value, xmm4 - }; -#else - __asm - { - mov edx, p - fild qword ptr [edx] - fistp value - }; -#endif - } - else - { - // We don't care for comparison result here; the previous value will be stored into value anyway. - // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b. - __asm - { - mov edi, p - mov eax, ebx - mov edx, ecx - lock cmpxchg8b qword ptr [edi] - mov dword ptr [value], eax - mov dword ptr [value + 4], edx - }; - } - - return value; -} - -#endif - -} // namespace detail -} // namespace atomics -} // namespace boost - -#undef BOOST_ATOMIC_COMPILER_BARRIER -#undef BOOST_ATOMIC_LOAD8 -#undef BOOST_ATOMIC_LOAD16 -#undef BOOST_ATOMIC_LOAD32 -#undef BOOST_ATOMIC_LOAD64 -#undef BOOST_ATOMIC_STORE8 -#undef BOOST_ATOMIC_STORE16 -#undef BOOST_ATOMIC_STORE32 -#undef BOOST_ATOMIC_STORE64 - -/* pull in 64-bit atomic type using cmpxchg8b above */ -#if defined(BOOST_ATOMIC_X86_HAS_CMPXCHG8B) -#include -#endif - -#endif /* !defined(BOOST_ATOMIC_FORCE_FALLBACK) */ - -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -#endif